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

catalystwan/api/templates/models/cisco_vpn_model.py

@@ -1,53 +1,73 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
-from enum import Enum
 from pathlib import Path
-from typing import ClassVar, List, Optional
+from typing import ClassVar, List, Literal, Optional
 
 from pydantic import ConfigDict, Field, field_validator
 
+from catalystwan.api.templates.bool_str import BoolStr
 from catalystwan.api.templates.feature_template import FeatureTemplate, FeatureTemplateValidator
-
-
-class Role(str, Enum):
-    PRIMARY = "primary"
-    SECONDARY = "secondary"
+from catalystwan.models.common import Protocol, StaticNatDirection
+
+Role = Literal["primary", "secondary"]
+SvcType = Literal["FW", "IDS", "IDP", "netsvc1", "netsvc2", "netsvc3", "netsvc4", "TE", "appqoe"]
+ServiceRouteService = Literal["sig"]
+Nat = Literal["NAT64", "NAT66"]
+AdvertiseProtocol = Literal[
+    "bgp", "ospf", "ospfv3", "connected", "static", "network", "aggregate", "eigrp", "lisp", "isis"
+]
+AdvertiseProtocolSubType = Literal["external"]
+Region = Literal["core", "access"]
+Ipv6AdvertiseProtocol = Literal["bgp", "ospf", "connected", "static", "network", "aggregate"]
+Ipv6AdvertiseProtocolSubType = Literal["external"]
+LeakFromGlobalProtocol = Literal["all", "static", "mobile", "connected", "rip", "odr"]
+Overload = Literal["true", "false"]
+RouteImportProtocol = Literal["static", "connected", "bgp", "ospf"]
+RouteImportProtocolSubType = Literal["external"]
+RouteImportRedistributeProtocol = Literal["bgp", "eigrp", "ospf"]
+RouteImportFromProtocol = Literal["static", "connected", "bgp", "ospf", "eigrp"]
+RouteImportFromProtocolSubType = Literal["external"]
+RouteImportFromRedistributeProtocol = Literal["bgp", "eigrp", "ospf"]
+RouteExportProtocol = Literal["static", "connected", "bgp", "eigrp", "ospf"]
+RouteExportProtocolSubType = Literal["external"]
+RouteExportRedistributeProtocol = Literal["bgp", "ospf"]
 
 
 class Dns(FeatureTemplateValidator):
-    dns_addr: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "dns-addr"})
-    role: Role = Role.PRIMARY
+    dns_addr: Optional[str] = Field(
+        default=None, json_schema_extra={"vmanage_key": "dns-addr"}, description="The IP address of the DNS server."
+    )
+    role: Role = Field(default="primary", description="The role of the DNS server, either 'PRIMARY' or 'SECONDARY'.")
     model_config = ConfigDict(populate_by_name=True)
 
 
 class DnsIpv6(FeatureTemplateValidator):
-    dns_addr: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "dns-addr"})
-    role: Optional[Role] = Role.PRIMARY
+    dns_addr: Optional[str] = Field(
+        default=None, json_schema_extra={"vmanage_key": "dns-addr"}, description="The IPv6 address of the DNS server."
+    )
+    role: Optional[Role] = Field(
+        default="primary",
+        description="The role of the DNS server for IPv6, optionally either 'PRIMARY' or 'SECONDARY'.",
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class Host(FeatureTemplateValidator):
-    hostname: str
-    ip: List[str]
-
-
-class SvcType(str, Enum):
-    FW = "FW"
-    IDS = "IDS"
-    IDP = "IDP"
-    NETSVC1 = "netsvc1"
-    NETSVC2 = "netsvc2"
-    NETSVC3 = "netsvc3"
-    NETSVC4 = "netsvc4"
-    TE = "TE"
-    APPQOE = "appqoe"
+    hostname: str = Field(..., description="The hostname of the device.")
+    ip: List[str] = Field(..., description="A list of IP addresses associated with the hostname.")
 
 
 class Service(FeatureTemplateValidator):
-    svc_type: SvcType = Field(json_schema_extra={"vmanage_key": "svc-type"})
-    address: Optional[List[str]] = None
-    interface: Optional[str] = None
-    track_enable: bool = Field(True, json_schema_extra={"vmanage_key": "track-enable"})
+    svc_type: SvcType = Field(
+        description="The type of service to be configured.", json_schema_extra={"vmanage_key": "svc-type"}
+    )
+    address: Optional[List[str]] = Field(default=None, description="A list of IP addresses for the service.")
+    interface: Optional[str] = Field(default=None, description="The interface associated with the service.")
+    track_enable: BoolStr = Field(
+        default=True,
+        description="Indicates whether tracking is enabled for the service.",
+        json_schema_extra={"vmanage_key": "track-enable"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
     @field_validator("track_enable")
@@ -56,345 +76,450 @@ class Service(FeatureTemplateValidator):
         return str(value).lower()
 
 
-class ServiceRouteService(str, Enum):
-    SIG = "sig"
-
-
 class ServiceRoute(FeatureTemplateValidator):
-    prefix: str
-    vpn: int
-    service: ServiceRouteService = ServiceRouteService.SIG
+    prefix: str = Field(description="The network prefix for the service route.")
+    vpn: int = Field(description="The VPN identifier where the service route is to be applied.")
+    service: ServiceRouteService = Field(default="sig", description="The service associated with the route.")
 
 
 class NextHop(FeatureTemplateValidator):
-    address: Optional[str] = None
-    distance: Optional[int] = 1
+    address: Optional[str] = Field(default=None, description="The IP address of the next hop for the route.")
+    distance: Optional[int] = Field(default=1, description="The administrative distance of the next hop.")
 
 
 class NextHopWithTrack(FeatureTemplateValidator):
-    address: Optional[str] = None
-    distance: Optional[int] = 1
-    tracker: str
+    address: Optional[str] = Field(
+        default=None, description="The IP address of the next hop for the route that requires tracking."
+    )
+    distance: Optional[int] = Field(
+        default=1, description="The administrative distance of the next hop that requires tracking."
+    )
+    tracker: str = Field(description="The tracker associated with this next hop.")
 
 
 class RouteInterface(FeatureTemplateValidator):
-    interface_name: str = Field(json_schema_extra={"vmanage_key": "interface-name"})
+    interface_name: str = Field(
+        description="The name of the interface used for routing.", json_schema_extra={"vmanage_key": "interface-name"}
+    )
     interface_next_hop: Optional[List[NextHop]] = Field(
-        default=None, json_schema_extra={"vmanage_key": "interface-next-hop", "priority_order": ["address", "distance"]}
+        default=None,
+        description="A list of next hops associated with the interface for routing purposes.",
+        json_schema_extra={"vmanage_key": "interface-next-hop", "priority_order": ["address", "distance"]},
     )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class Routev4(FeatureTemplateValidator):
-    prefix: Optional[str] = None
+    prefix: Optional[str] = Field(default=None, description="The IPv4 network prefix for the static route.")
     next_hop: Optional[List[NextHop]] = Field(
-        default=None, json_schema_extra={"vmanage_key": "next-hop", "priority_order": ["address", "distance"]}
+        default=None,
+        description="A list of IPv4 next hops for the route.",
+        json_schema_extra={"vmanage_key": "next-hop", "priority_order": ["address", "distance"]},
     )
     next_hop_with_track: Optional[List[NextHopWithTrack]] = Field(
-        default=None, json_schema_extra={"vmanage_key": "next-hop-with-track"}
+        default=None,
+        description="A list of IPv4 next hops with tracking for the route.",
+        json_schema_extra={"vmanage_key": "next-hop-with-track"},
     )
     route_interface: Optional[RouteInterface] = Field(
-        default=None, json_schema_extra={"vmanage_key": "route-interface"}
+        default=None,
+        description="The interface configuration for the IPv4 static route.",
+        json_schema_extra={"vmanage_key": "route-interface"},
     )
-    null0: Optional[bool] = None
-    distance: Optional[int] = None
-    vpn: Optional[int] = None
-    dhcp: Optional[bool] = None
+    null0: Optional[BoolStr] = Field(
+        default=None, description="A flag indicating whether to route traffic to null0 for this static route."
+    )
+    distance: Optional[int] = Field(default=None, description="The administrative distance for the static route.")
+    vpn: Optional[int] = Field(
+        default=None, description="The VPN instance identifier associated with the static route."
+    )
+    dhcp: Optional[BoolStr] = Field(
+        default=None, description="A flag indicating whether DHCP is used for this static route."
+    )
+
     model_config = ConfigDict(populate_by_name=True)
 
 
 class NextHopv6(FeatureTemplateValidator):
-    address: str
-    distance: Optional[int] = 1
-
-
-class Nat(str, Enum):
-    NAT64 = "NAT64"
-    NAT66 = "NAT66"
+    address: str = Field(description="The IPv6 address of the next hop for the route.")
+    distance: Optional[int] = Field(default=1, description="The administrative distance of the IPv6 next hop.")
 
 
 class Routev6(FeatureTemplateValidator):
-    prefix: str
-    next_hop: Optional[List[NextHopv6]] = Field(default=None, json_schema_extra={"vmanage_key": "next-hop"})
-    null0: Optional[bool] = None
-    vpn: Optional[int] = None
-    nat: Optional[Nat] = None
+    prefix: str = Field(description="The IPv6 network prefix for the static route.")
+    next_hop: Optional[List[NextHopv6]] = Field(
+        default=None,
+        description="A list of IPv6 next hops for the route.",
+        json_schema_extra={"vmanage_key": "next-hop"},
+    )
+    null0: Optional[BoolStr] = Field(
+        default=None, description="A flag indicating whether to route IPv6 traffic to null0 for this static route."
+    )
+    vpn: Optional[int] = Field(
+        default=None, description="The VPN instance identifier associated with the IPv6 static route."
+    )
+    nat: Optional[Nat] = Field(
+        default=None, description="The type of NAT to apply for the IPv6 static route, if applicable."
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class GreRoute(FeatureTemplateValidator):
-    prefix: str
-    vpn: int
-    interface: Optional[List[str]] = None
+    prefix: str = Field(description="The network prefix for the GRE (Generic Routing Encapsulation) route.")
+    vpn: int = Field(description="The VPN identifier where the GRE route is to be applied.")
+    interface: Optional[List[str]] = Field(
+        default=None, description="A list of interfaces associated with the GRE route."
+    )
 
 
 class IpsecRoute(FeatureTemplateValidator):
-    prefix: str
-    vpn: int
-    interface: Optional[List[str]] = None
-
-
-class AdvertiseProtocol(str, Enum):
-    BGP = "bgp"
-    OSPF = "ospf"
-    OSPFV3 = "ospfv3"
-    CONNECTED = "connected"
-    STATIC = "static"
-    NETWORK = "network"
-    AGGREGATE = "aggregate"
-    EIGRP = "eigrp"
-    LISP = "lisp"
-    ISIS = "isis"
-
-
-class AdvertiseProtocolSubType(str, Enum):
-    EXTERNAL = "external"
-
-
-class Region(str, Enum):
-    CORE = "core"
-    ACCESS = "access"
+    prefix: str = Field(description="The network prefix for the IPSec (Internet Protocol Security) route.")
+    vpn: int = Field(description="The VPN identifier where the IPSec route is to be applied.")
+    interface: Optional[List[str]] = Field(
+        default=None, description="A list of interfaces associated with the IPSec route."
+    )
 
 
 class PrefixList(FeatureTemplateValidator):
-    prefix_entry: str = Field(json_schema_extra={"vmanage_key": "prefix-entry"})
-    aggregate_only: Optional[bool] = Field(default=None, json_schema_extra={"vmanage_key": "aggregate-only"})
-    region: Optional[Region]
+    prefix_entry: str = Field(
+        description="The network prefix entry for the prefix list.", json_schema_extra={"vmanage_key": "prefix-entry"}
+    )
+    aggregate_only: Optional[BoolStr] = Field(
+        default=None,
+        description="A flag indicating if only aggregate routes should be considered.",
+        json_schema_extra={"vmanage_key": "aggregate-only"},
+    )
+    region: Optional[Region] = Field(default=None, description="The network region where the prefix list is applied.")
     model_config = ConfigDict(populate_by_name=True)
 
 
 class Advertise(FeatureTemplateValidator):
-    protocol: AdvertiseProtocol
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
+    protocol: AdvertiseProtocol = Field(description="The protocol used for route advertisement.")
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy associated with advertisement.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
     protocol_sub_type: Optional[List[AdvertiseProtocolSubType]] = Field(
-        default=None, json_schema_extra={"vmanage_key": "protocol-sub-type"}
+        default=None,
+        description="A list of subtypes for the advertisement protocol.",
+        json_schema_extra={"vmanage_key": "protocol-sub-type"},
+    )
+    prefix_list: Optional[List[PrefixList]] = Field(
+        default=None,
+        description="A list of prefix lists associated with the advertisement settings.",
+        json_schema_extra={"vmanage_key": "prefix-list"},
     )
-    prefix_list: Optional[List[PrefixList]] = Field(default=None, json_schema_extra={"vmanage_key": "prefix-list"})
     model_config = ConfigDict(populate_by_name=True)
 
 
-class Ipv6AdvertiseProtocol(str, Enum):
-    BGP = "bgp"
-    OSPF = "ospf"
-    CONNECTED = "connected"
-    STATIC = "static"
-    NETWORK = "network"
-    AGGREGATE = "aggregate"
-
-
-class Ipv6AdvertiseProtocolSubType(str, Enum):
-    EXTERNAL = "external"
-
-
 class Ipv6Advertise(FeatureTemplateValidator):
-    protocol: Ipv6AdvertiseProtocol
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
+    protocol: Ipv6AdvertiseProtocol = Field(description="The IPv6 protocol used for route advertisement.")
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The IPv6 route policy associated with advertisement.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
     protocol_sub_type: Optional[List[Ipv6AdvertiseProtocolSubType]] = Field(
-        default=None, json_schema_extra={"vmanage_key": "protocol-sub-type"}
+        default=None,
+        description="A list of subtypes for the IPv6 advertisement protocol.",
+        json_schema_extra={"vmanage_key": "protocol-sub-type"},
+    )
+    prefix_list: Optional[List[PrefixList]] = Field(
+        default=None,
+        description="A list of IPv6 prefix lists associated with the advertisement settings.",
+        json_schema_extra={"vmanage_key": "prefix-list"},
     )
-    prefix_list: Optional[List[PrefixList]] = Field(default=None, json_schema_extra={"vmanage_key": "prefix-list"})
     model_config = ConfigDict(populate_by_name=True)
 
 
-class LeakFromGlobalProtocol(str, Enum):
-    ALL = "all"
-    STATIC = "static"
-    MOBILE = "mobile"
-    CONNECTED = "connected"
-    RIP = "rip"
-    ODR = "odr"
-
-
 class Pool(FeatureTemplateValidator):
-    name: str
-    start_address: str = Field(json_schema_extra={"vmanage_key": "start-address"})
-    end_address: str = Field(json_schema_extra={"vmanage_key": "end-address"})
-    overload: Optional[bool] = None
-    leak_from_global: bool
-    leak_from_global_protocol: LeakFromGlobalProtocol
-    leak_to_global: bool
+    name: str = Field(description="The name of the IP address pool.")
+    start_address: str = Field(
+        description="The starting IP address of the pool.", json_schema_extra={"vmanage_key": "start-address"}
+    )
+    end_address: str = Field(
+        description="The ending IP address of the pool.", json_schema_extra={"vmanage_key": "end-address"}
+    )
+    overload: Optional[BoolStr] = Field(
+        default=None, description="A flag indicating whether address overload is allowed."
+    )
+    leak_from_global: BoolStr = Field(description="A flag indicating whether leaking from the global table is enabled.")
+    leak_from_global_protocol: LeakFromGlobalProtocol = Field(
+        description="The protocol used for leaking from the global routing table."
+    )
+    leak_to_global: BoolStr = Field(description="A flag indicating whether leaking to the global table is enabled.")
     model_config = ConfigDict(populate_by_name=True)
 
 
-class Direction(str, Enum):
-    INSIDE = "inside"
-    OUTSIDE = "outside"
-
-
-class Overload(str, Enum):
-    TRUE = "true"
-    FALSE = "false"
-
-
 class Natpool(FeatureTemplateValidator):
-    name: int
-    prefix_length: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "prefix-length"})
-    range_start: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "range-start"})
-    range_end: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "range-end"})
-    overload: Overload = Overload.TRUE
-    direction: Direction
-    tracker_id: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "tracker-id"})
+    name: int = Field(description="The identifier for the NAT pool.")
+    prefix_length: Optional[int] = Field(
+        default=None,
+        description="The length of the network prefix for the NAT pool.",
+        json_schema_extra={"vmanage_key": "prefix-length"},
+    )
+    range_start: str = Field(
+        description="The starting IP address for the NAT pool range.",
+        json_schema_extra={"vmanage_key": "range-start"},
+    )
+    range_end: Optional[str] = Field(
+        default=None,
+        description="The ending IP address for the NAT pool range.",
+        json_schema_extra={"vmanage_key": "range-end"},
+    )
+    overload: Overload = Field(
+        default="true", description="Flag indicating whether NAT overload (PAT) is enabled for the pool."
+    )
+    direction: StaticNatDirection = Field(description="The direction (inside or outside) associated with the NAT pool.")
+    tracker_id: Optional[int] = Field(
+        default=None,
+        description="The tracker identifier associated with the NAT pool.",
+        json_schema_extra={"vmanage_key": "tracker-id"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
-class StaticNatDirection(str, Enum):
-    INSIDE = "inside"
-    OUTSIDE = "outside"
-
-
 class Static(FeatureTemplateValidator):
-    pool_name: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "pool-name"})
-    source_ip: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "source-ip"})
-    translate_ip: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "translate-ip"})
-    static_nat_direction: StaticNatDirection = Field(json_schema_extra={"vmanage_key": "static-nat-direction"})
-    tracker_id: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "tracker-id"})
+    pool_name: Optional[int] = Field(
+        default=None,
+        description="The identifier for the NAT pool associated with the static NAT rule.",
+        json_schema_extra={"vmanage_key": "pool-name"},
+    )
+    source_ip: Optional[str] = Field(
+        default=None,
+        description="The original source IP address to be translated by static NAT.",
+        json_schema_extra={"vmanage_key": "source-ip"},
+    )
+    translate_ip: Optional[str] = Field(
+        default=None,
+        description="The translated IP address used by static NAT.",
+        json_schema_extra={"vmanage_key": "translate-ip"},
+    )
+    static_nat_direction: StaticNatDirection = Field(
+        description="The direction (inside or outside) for the static NAT rule.",
+        json_schema_extra={"vmanage_key": "static-nat-direction"},
+    )
+    tracker_id: Optional[int] = Field(
+        default=None,
+        description="The tracker identifier associated with the static NAT rule.",
+        json_schema_extra={"vmanage_key": "tracker-id"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class SubnetStatic(FeatureTemplateValidator):
-    source_ip_subnet: str = Field(json_schema_extra={"vmanage_key": "source-ip-subnet"})
-    translate_ip_subnet: str = Field(json_schema_extra={"vmanage_key": "translate-ip-subnet"})
-    prefix_length: int = Field(json_schema_extra={"vmanage_key": "prefix-length"})
-    static_nat_direction: StaticNatDirection = Field(json_schema_extra={"vmanage_key": "static-nat-direction"})
-    tracker_id: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "tracker-id"})
+    source_ip_subnet: str = Field(
+        description="The original source IP subnet to be translated by static NAT.",
+        json_schema_extra={"vmanage_key": "source-ip-subnet"},
+    )
+    translate_ip_subnet: str = Field(
+        description="The translated IP subnet used by static NAT.",
+        json_schema_extra={"vmanage_key": "translate-ip-subnet"},
+    )
+    prefix_length: int = Field(
+        description="The prefix length for the translated IP subnet in static NAT.",
+        json_schema_extra={"vmanage_key": "prefix-length"},
+    )
+    static_nat_direction: StaticNatDirection = Field(
+        description="The direction (inside or outside) for the subnet static NAT rule.",
+        json_schema_extra={"vmanage_key": "static-nat-direction"},
+    )
+    tracker_id: Optional[int] = Field(
+        default=None,
+        description="The tracker identifier associated with the subnet static NAT rule.",
+        json_schema_extra={"vmanage_key": "tracker-id"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
-class Proto(str, Enum):
-    TCP = "tcp"
-    UDP = "udp"
-
-
 class PortForward(FeatureTemplateValidator):
-    pool_name: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "pool-name"})
-    source_port: int = Field(json_schema_extra={"vmanage_key": "source-port"})
-    translate_port: int = Field(json_schema_extra={"vmanage_key": "translate-port"})
-    source_ip: str = Field(json_schema_extra={"vmanage_key": "source-ip"})
-    translate_ip: str = Field(json_schema_extra={"vmanage_key": "translate-ip"})
-    proto: Proto
+    pool_name: Optional[int] = Field(
+        default=None,
+        description="The identifier for the NAT pool associated with the port forwarding rule.",
+        json_schema_extra={"vmanage_key": "pool-name"},
+    )
+    source_port: int = Field(
+        description="The source port number for the port forwarding rule.",
+        json_schema_extra={"vmanage_key": "source-port"},
+    )
+    translate_port: int = Field(
+        description="The destination port number to which the source port is translated.",
+        json_schema_extra={"vmanage_key": "translate-port"},
+    )
+    source_ip: str = Field(
+        description="The source IP address for the port forwarding rule.",
+        json_schema_extra={"vmanage_key": "source-ip"},
+    )
+    translate_ip: str = Field(
+        description="The destination IP address to which the source IP is translated.",
+        json_schema_extra={"vmanage_key": "translate-ip"},
+    )
+    proto: Protocol = Field(description="The protocol used in the port forwarding rule (TCP/UDP).")
     model_config = ConfigDict(populate_by_name=True)
 
 
-class RouteImportProtocol(str, Enum):
-    STATIC = "static"
-    CONNECTED = "connected"
-    BGP = "bgp"
-    OSPF = "ospf"
-
-
-class RouteImportProtocolSubType(str, Enum):
-    EXTERNAL = "external"
-
-
-class RouteImportRedistributeProtocol(str, Enum):
-    BGP = "bgp"
-    EIGRP = "eigrp"
-    OSPF = "ospf"
-
-
 class RouteImportRedistribute(FeatureTemplateValidator):
-    protocol: RouteImportRedistributeProtocol
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
+    protocol: RouteImportRedistributeProtocol = Field(
+        description="The protocol from which routes are to be redistributed."
+    )
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy that specifies the conditions for route redistribution.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class RouteImport(FeatureTemplateValidator):
-    protocol: RouteImportProtocol
-    protocol_sub_type: List[RouteImportProtocolSubType] = Field(json_schema_extra={"vmanage_key": "protocol-sub-type"})
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
-    redistribute: Optional[List[RouteImportRedistribute]] = None
+    protocol: RouteImportProtocol = Field(description="The protocol from which routes are to be imported.")
+    protocol_sub_type: List[RouteImportProtocolSubType] = Field(
+        description="The list of subtypes for the import protocol.",
+        json_schema_extra={"vmanage_key": "protocol-sub-type"},
+    )
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy that specifies the conditions for route import.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
+    redistribute: Optional[List[RouteImportRedistribute]] = Field(
+        default=None,
+        description="A list of redistribute configurations that define how routes from other protocols are imported.",
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
-class RouteImportFromProtocol(str, Enum):
-    STATIC = "static"
-    CONNECTED = "connected"
-    BGP = "bgp"
-    OSPF = "ospf"
-    EIGRP = "eigrp"
-
-
-class RouteImportFromProtocolSubType(str, Enum):
-    EXTERNAL = "external"
-
-
-class RouteImportFromRedistributeProtocol(str, Enum):
-    BGP = "bgp"
-    EIGRP = "eigrp"
-    OSPF = "ospf"
-
-
 class RouteImportFromRedistribute(FeatureTemplateValidator):
-    protocol: RouteImportFromRedistributeProtocol
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
+    protocol: RouteImportFromRedistributeProtocol = Field(
+        description="The protocol from which routes are to be redistributed into the local routing table."
+    )
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy that defines the conditions for route redistribution.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class RouteImportFrom(FeatureTemplateValidator):
-    source_vpn: int = Field(json_schema_extra={"vmanage_key": "source-vpn"})
-    protocol: RouteImportFromProtocol
+    source_vpn: int = Field(
+        description="The VPN instance (VRF) from which routes are to be imported.",
+        json_schema_extra={"vmanage_key": "source-vpn"},
+    )
+    protocol: RouteImportFromProtocol = Field(description="The routing protocol from which routes are to be imported.")
     protocol_sub_type: List[RouteImportFromProtocolSubType] = Field(
-        json_schema_extra={"vmanage_key": "protocol-sub-type"}
+        description="The list of protocol subtypes for route importation.",
+        json_schema_extra={"vmanage_key": "protocol-sub-type"},
+    )
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy that specifies the criteria for route importation.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
+    redistribute: Optional[List[RouteImportFromRedistribute]] = Field(
+        default=None,
+        description=(
+            "A list of route redistribution configurations specifying how routes from other protocols are imported."
+        ),
     )
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
-    redistribute: Optional[List[RouteImportFromRedistribute]] = None
     model_config = ConfigDict(populate_by_name=True)
 
 
-class RouteExportProtocol(str, Enum):
-    STATIC = "static"
-    CONNECTED = "connected"
-    BGP = "bgp"
-    EIGRP = "eigrp"
-    OSPF = "ospf"
-
-
-class RouteExportProtocolSubType(str, Enum):
-    EXTERNAL = "external"
-
-
-class RouteExportRedistributeProtocol(str, Enum):
-    BGP = "bgp"
-    OSPF = "ospf"
-
-
 class RouteExportRedistribute(FeatureTemplateValidator):
-    protocol: RouteExportRedistributeProtocol
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
+    protocol: RouteExportRedistributeProtocol = Field(
+        description="The protocol from which routes are to be redistributed out of the local routing table."
+    )
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy that defines the conditions for route redistribution.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class RouteExport(FeatureTemplateValidator):
-    protocol: RouteExportProtocol
-    protocol_sub_type: List[RouteExportProtocolSubType] = Field(json_schema_extra={"vmanage_key": "protocol-sub-type"})
-    route_policy: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "route-policy"})
-    redistribute: Optional[List[RouteExportRedistribute]]
+    protocol: RouteExportProtocol = Field(description="The routing protocol to which routes are to be exported.")
+    protocol_sub_type: List[RouteExportProtocolSubType] = Field(
+        description="The list of protocol subtypes for route exportation.",
+        json_schema_extra={"vmanage_key": "protocol-sub-type"},
+    )
+    route_policy: Optional[str] = Field(
+        default=None,
+        description="The route policy that specifies the criteria for route exportation.",
+        json_schema_extra={"vmanage_key": "route-policy"},
+    )
+    redistribute: Optional[List[RouteExportRedistribute]] = Field(
+        default=None,
+        description=(
+            "A list of route redistribution configurations specifying how routes from other protocols are exported."
+        ),
+    )
     model_config = ConfigDict(populate_by_name=True)
 
 
 class CiscoVPNModel(FeatureTemplate):
     model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    _docs_description: str = "Cisco VPN Feature Template configuration."
 
-    vpn_id: int = Field(default=0, json_schema_extra={"vmanage_key": "vpn-id"})
-    vpn_name: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "name"})
-    tenant_vpn_id: Optional[int] = Field(default=None, json_schema_extra={"vmanage_key": "tenant-vpn-id"})
-    org_name: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "org-name"})
+    vpn_id: int = Field(
+        default=0,
+        description="The unique identifier for the VPN instance (VRF).",
+        json_schema_extra={"vmanage_key": "vpn-id"},
+    )
+    vpn_name: Optional[str] = Field(
+        default=None, description="The name of the VPN instance.", json_schema_extra={"vmanage_key": "name"}
+    )
+    tenant_vpn_id: Optional[int] = Field(
+        default=None,
+        description="The tenant-specific identifier for the VPN instance, used in multi-tenant environments.",
+        json_schema_extra={"vmanage_key": "tenant-vpn-id"},
+    )
+    org_name: Optional[str] = Field(
+        default=None,
+        description="The name of the organization to which the VPN instance belongs.",
+        json_schema_extra={"vmanage_key": "org-name"},
+    )
     omp_admin_distance_ipv4: Optional[int] = Field(
-        default=None, json_schema_extra={"vmanage_key": "omp-admin-distance-ipv4"}
+        default=None,
+        description="The administrative distance for IPv4 routes received over the Overlay Management Protocol (OMP).",
+        json_schema_extra={"vmanage_key": "omp-admin-distance-ipv4"},
     )
     omp_admin_distance_ipv6: Optional[int] = Field(
-        default=None, json_schema_extra={"vmanage_key": "omp-admin-distance-ipv6"}
+        default=None,
+        description="The administrative distance for IPv6 routes received over OMP.",
+        json_schema_extra={"vmanage_key": "omp-admin-distance-ipv6"},
+    )
+    dns: Optional[List[Dns]] = Field(
+        default=None,
+        description="A list of DNS configurations for the VPN instance.",
+    )
+    dns_ipv6: Optional[List[DnsIpv6]] = Field(
+        default=None,
+        description="A list of DNS configurations for IPv6 within the VPN instance.",
+        json_schema_extra={"vmanage_key": "dns-ipv6"},
+    )
+    layer4: Optional[BoolStr] = Field(
+        default=None,
+        description="A flag indicating whether Layer 4 information is included in the ECMP hash key.",
+        json_schema_extra={"data_path": ["ecmp-hash-key"]},
+    )
+    host: Optional[List[Host]] = Field(
+        default=None,
+        description="A list of host configurations within the VPN instance.",
+        json_schema_extra={"priority_order": ["hostname", "ip"]},
+    )
+    service: Optional[List[Service]] = Field(
+        default=None,
+        description="A list of service configurations associated with the VPN instance.",
     )
-    dns: Optional[List[Dns]] = None
-    dns_ipv6: Optional[List[DnsIpv6]] = Field(default=None, json_schema_extra={"vmanage_key": "dns-ipv6"})
-    layer4: Optional[bool] = Field(default=None, json_schema_extra={"data_path": ["ecmp-hash-key"]})
-    host: Optional[List[Host]] = Field(default=None, json_schema_extra={"priority_order": ["hostname", "ip"]})
-    service: Optional[List[Service]] = None
     service_route: Optional[List[ServiceRoute]] = Field(
-        default=None, json_schema_extra={"data_path": ["ip"], "vmanage_key": "service-route"}
+        default=None,
+        description="A list of service route configurations for directing traffic to services within the VPN.",
+        json_schema_extra={"data_path": ["ip"], "vmanage_key": "service-route"},
     )
     route_v4: Optional[List[Routev4]] = Field(
         default=None,
+        description="A list of IPv4 route configurations within the VPN instance.",
         json_schema_extra={
             "data_path": ["ip"],
             "vmanage_key": "route",
@@ -402,32 +527,70 @@ class CiscoVPNModel(FeatureTemplate):
         },
     )
     route_v6: Optional[List[Routev6]] = Field(
-        default=None, json_schema_extra={"data_path": ["ipv6"], "vmanage_key": "route"}
+        default=None,
+        description="A list of IPv6 route configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["ipv6"], "vmanage_key": "route"},
     )
     gre_route: Optional[List[GreRoute]] = Field(
-        default=None, json_schema_extra={"data_path": ["ip"], "vmanage_key": "gre-route"}
+        default=None,
+        description="A list of GRE tunnel route configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["ip"], "vmanage_key": "gre-route"},
     )
     ipsec_route: Optional[List[IpsecRoute]] = Field(
-        default=None, json_schema_extra={"data_path": ["ip"], "vmanage_key": "ipsec-route"}
+        default=None,
+        description="A list of IPSec route configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["ip"], "vmanage_key": "ipsec-route"},
+    )
+    advertise: Optional[List[Advertise]] = Field(
+        default=None,
+        description="A list of configurations for advertising routes via OMP within the VPN instance.",
+        json_schema_extra={"data_path": ["omp"]},
     )
-    advertise: Optional[List[Advertise]] = Field(default=None, json_schema_extra={"data_path": ["omp"]})
     ipv6_advertise: Optional[List[Ipv6Advertise]] = Field(
-        default=None, json_schema_extra={"data_path": ["omp"], "vmanage_key": "ipv6-advertise"}
+        default=None,
+        description="A list of configurations for advertising IPv6 routes via OMP within the VPN instance.",
+        json_schema_extra={"data_path": ["omp"], "vmanage_key": "ipv6-advertise"},
+    )
+    pool: Optional[List[Pool]] = Field(
+        default=None,
+        description="A list of NAT64 pool configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["nat64", "v4"]},
+    )
+    natpool: Optional[List[Natpool]] = Field(
+        default=None,
+        description="A list of NAT pool configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["nat"]},
+    )
+    static: Optional[List[Static]] = Field(
+        default=None,
+        description="A list of static configurations within the VPN instance for NAT.",
+        json_schema_extra={"data_path": ["nat"]},
     )
-    pool: Optional[List[Pool]] = Field(default=None, json_schema_extra={"data_path": ["nat64", "v4"]})
-    natpool: Optional[List[Natpool]] = Field(default=None, json_schema_extra={"data_path": ["nat"]})
-    static: Optional[List[Static]] = Field(default=None, json_schema_extra={"data_path": ["nat"]})
     subnet_static: Optional[List[SubnetStatic]] = Field(
-        default=None, json_schema_extra={"data_path": ["nat"], "vmanage_key": "subnet-static"}
+        default=None,
+        description="A list of subnet-specific static configurations within the VPN instance for NAT.",
+        json_schema_extra={"data_path": ["nat"], "vmanage_key": "subnet-static"},
     )
     port_forward: Optional[List[PortForward]] = Field(
-        default=None, json_schema_extra={"data_path": ["nat"], "vmanage_key": "port-forward"}
+        default=None,
+        description="A list of port forwarding configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["nat"], "vmanage_key": "port-forward"},
+    )
+    route_import: Optional[List[RouteImport]] = Field(
+        default=None,
+        description="A list of route import configurations within the VPN instance.",
+        json_schema_extra={"vmanage_key": "route-import"},
     )
-    route_import: Optional[List[RouteImport]] = Field(default=None, json_schema_extra={"vmanage_key": "route-import"})
     route_import_from: Optional[List[RouteImportFrom]] = Field(
-        default=None, json_schema_extra={"vmanage_key": "route-import-from"}
+        default=None,
+        description="A list of configurations specifying routes to import from other sources into the VPN instance.",
+        json_schema_extra={"vmanage_key": "route-import-from"},
+    )
+    route_export: Optional[List[RouteExport]] = Field(
+        default=None,
+        description="A list of route export configurations within the VPN instance.",
+        json_schema_extra={"vmanage_key": "route-export"},
     )
-    route_export: Optional[List[RouteExport]] = Field(default=None, json_schema_extra={"vmanage_key": "route-export"})
 
     payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
     type: ClassVar[str] = "cisco_vpn"