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

catalystwan/api/templates/models/vpn_vsmart_model.py

@@ -0,0 +1,124 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+
+from pathlib import Path
+from typing import ClassVar, List, Literal, Optional
+
+from pydantic import ConfigDict, Field
+
+from catalystwan.api.templates.bool_str import BoolStr
+from catalystwan.api.templates.feature_template import FeatureTemplate, FeatureTemplateValidator
+
+VpnId = Literal["0", "512"]
+Role = Literal["primary", "secondary"]
+
+
+class Dns(FeatureTemplateValidator):
+    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(description="The role of the DNS server, either 'PRIMARY' or 'SECONDARY'.")
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class Host(FeatureTemplateValidator):
+    hostname: str = Field(..., description="The hostname of the device.")
+    ip: List[str] = Field(..., description="A list of IP addresses associated with the hostname.")
+
+
+class NextHop(FeatureTemplateValidator):
+    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 RouteInterface(FeatureTemplateValidator):
+    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,
+        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] = Field(default=None, description="The IPv4 network prefix for the static route.")
+    next_hop: Optional[List[NextHop]] = Field(
+        default=None,
+        description="A list of IPv4 next hops for the route.",
+        json_schema_extra={"vmanage_key": "next-hop", "priority_order": ["address", "distance"]},
+    )
+    route_interface: Optional[RouteInterface] = Field(
+        default=None,
+        description="The interface configuration for the IPv4 static route.",
+        json_schema_extra={"vmanage_key": "route-interface"},
+    )
+    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."
+    )
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class NextHopv6(FeatureTemplateValidator):
+    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 = 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."
+    )
+    distance: Optional[int] = Field(default=1, description="The administrative distance for the static route.")
+    vpn: Optional[int] = Field(default=0, description="The VPN instance identifier associated with the static route.")
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class VpnVsmartModel(FeatureTemplate):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    _docs_description: str = "vSmart VPN Feature Template configuration."
+
+    vpn_id: VpnId = Field(
+        description="The unique identifier for the VPN, only 0 and 512 are allowed on vsmart",
+        json_schema_extra={"vmanage_key": "vpn-id"},
+    )
+    name: Optional[str] = Field(
+        default=None, description="The name of the VPN.", json_schema_extra={"vmanage_key": "name"}
+    )
+    dns: Optional[List[Dns]] = Field(
+        default=None,
+        description="A list of DNS configurations for the VPN instance.",
+    )
+    host: Optional[List[Host]] = Field(
+        default=None,
+        description="Static DNS mapping",
+        json_schema_extra={"priority_order": ["hostname", "ip"]},
+    )
+    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",
+            "priority_order": ["prefix", "next-hop", "next-hop-with-track"],
+        },
+    )
+    route_v6: Optional[List[Routev6]] = Field(
+        default=None,
+        description="A list of IPv6 route configurations within the VPN instance.",
+        json_schema_extra={"data_path": ["ipv6"], "vmanage_key": "route"},
+    )
+
+    payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
+    type: ClassVar[str] = "vpn-vsmart"

catalystwan/apigw_auth.py

@@ -7,10 +7,10 @@ from urllib.parse import urlparse
 from pydantic import BaseModel, Field, PositiveInt
 from requests import HTTPError, PreparedRequest, post
 from requests.auth import AuthBase
-from requests.exceptions import JSONDecodeError
+from requests.exceptions import JSONDecodeError, Timeout
 
 from catalystwan.abstractions import APIEndpointClient, AuthProtocol
-from catalystwan.exceptions import CatalystwanException
+from catalystwan.exceptions import ApiGwAuthTimeout, CatalystwanException
 from catalystwan.response import auth_response_debug
 
 LoginMode = Literal["machine", "user", "session"]
@@ -106,6 +106,8 @@ class ApiGwAuth(AuthBase, AuthProtocol):
             raise CatalystwanException(
                 f"Problem with connection to ApiGateway login endpoint, ({ex}). Response: ({response.text})"
             )
+        except Timeout as ex:
+            raise ApiGwAuthTimeout(f"The request to the API GW login timeout, ({ex}).")
         except KeyError as ex:
             raise CatalystwanException(f"Not found token in login response from ApiGateway, ({ex})")
         else:
@@ -139,6 +141,8 @@ class ApiGwAuth(AuthBase, AuthProtocol):
                 f"Problem with connecting to API GW organization registration endpoint, ({ex}).\
                   Response: ({response.text})"
             )
+        except Timeout as ex:
+            raise ApiGwAuthTimeout(f"The request to the API GW organization registration timeout, ({ex}).")
         except Exception as ex:
             raise CatalystwanException(f"Org registration to API-GW failed: {ex}")
 

catalystwan/dataclasses.py

@@ -11,9 +11,9 @@ from catalystwan.utils.alarm_status import Severity
 from catalystwan.utils.certificate_status import ValidityPeriod
 from catalystwan.utils.colors import PrintColors
 from catalystwan.utils.creation_tools import FIELD_NAME, asdict, convert_attributes
+from catalystwan.utils.persona import Persona
 from catalystwan.utils.personality import Personality
 from catalystwan.utils.reachability import Reachability
-from catalystwan.utils.template_type import TemplateType
 
 
 class DataclassBase:
@@ -252,36 +252,6 @@ class User(DataclassBase):
     resource_group: Optional[str] = field(default=None, metadata={FIELD_NAME: "resGroupName"})
 
 
-@define(kw_only=True)
-class TemplateInfo(DataclassBase):
-    last_updated_by: str = field(metadata={FIELD_NAME: "lastUpdatedBy"})
-    id: str = field(metadata={FIELD_NAME: "templateId"})
-    factory_default: bool = field(metadata={FIELD_NAME: "factoryDefault"})
-    name: str = field(metadata={FIELD_NAME: "templateName"})
-    devices_attached: int = field(metadata={FIELD_NAME: "devicesAttached"})
-    description: str = field(metadata={FIELD_NAME: "templateDescription"})
-    last_updated_on: dt.datetime = field(metadata={FIELD_NAME: "lastUpdatedOn"})
-    resource_group: Optional[str] = field(default=None, metadata={FIELD_NAME: "resourceGroup"})
-
-
-@define(kw_only=True)
-class FeatureTemplateInfo(TemplateInfo):
-    template_type: str = field(metadata={FIELD_NAME: "templateType"})
-    device_type: List[str] = field(metadata={FIELD_NAME: "deviceType"})
-    version: str = field(metadata={FIELD_NAME: "templateMinVersion"})
-    template_definiton: Optional[str] = field(default=None, metadata={FIELD_NAME: "templateDefinition"})
-
-
-@define(kw_only=True)
-class DeviceTemplateInfo(TemplateInfo):
-    device_type: str = field(metadata={FIELD_NAME: "deviceType"})
-    template_class: str = field(metadata={FIELD_NAME: "templateClass"})
-    config_type: TemplateType = field(converter=TemplateType, metadata={FIELD_NAME: "configType"})
-    template_attached: int = field(metadata={FIELD_NAME: "templateAttached"})
-    draft_mode: Optional[str] = field(default=None, metadata={FIELD_NAME: "draftMode"})
-    device_role: Optional[str] = field(default=None, metadata={FIELD_NAME: "deviceRole"})
-
-
 @define
 class Speedtest(DataclassBase):
     device_ip: str
@@ -312,7 +282,7 @@ class ServiceConfigurationData(DataclassBase):
     vmanage_id: str = field(metadata={FIELD_NAME: "vmanageID"})
     device_ip: str = field(metadata={FIELD_NAME: "deviceIP"})  # consider using ip4 module to verify
     services: dict = field(metadata={FIELD_NAME: "services"})  # consider using nested dataclasses
-    persona: str = field(default="COMPUTE_AND_DATA")  # TODO Enum
+    persona: Persona = field(default="COMPUTE_AND_DATA")
     username: Optional[str] = field(default=None)
     password: Optional[str] = field(default=None)
 
@@ -374,27 +344,6 @@ class TierInfo(DataclassBase):
     nat_session_limit: Optional[int] = field(default=None, metadata={FIELD_NAME: "natSessionLimit"})
 
 
-@define(frozen=True)
-class FeatureTemplateInformation(DataclassBase):
-    """Endpoint: /dataservice/template/feature"""
-
-    id: str = field(metadata={FIELD_NAME: "templateId"})
-    name: str = field(metadata={FIELD_NAME: "templateName"})
-    description: str = field(metadata={FIELD_NAME: "templateDescription"})
-    type: str = field(metadata={FIELD_NAME: "templateType"})  # TODO Enum
-    device_types: List[str] = field(metadata={FIELD_NAME: "deviceType"})  # TODO Enum
-    last_updated_by: str = field(metadata={FIELD_NAME: "lastUpdatedBy"})
-    last_updated_on: dt.datetime = field(metadata={FIELD_NAME: "lastUpdatedOn"})
-    factory_default: bool = field(metadata={FIELD_NAME: "factoryDefault"})
-    devices_attached: int = field(metadata={FIELD_NAME: "devicesAttached"})
-    attached_masters: int = field(metadata={FIELD_NAME: "attachedMastersCount"})
-    version: str = field(metadata={FIELD_NAME: "templateMinVersion"})
-    config_type: str = field(metadata={FIELD_NAME: "configType"})
-    created_by: str = field(metadata={FIELD_NAME: "createdBy"})
-    created_on: dt.datetime = field(metadata={FIELD_NAME: "createdOn"})
-    resource_group: str = field(metadata={FIELD_NAME: "resourceGroup"})
-
-
 @define
 class Organization(DataclassBase):
     name: str = field(metadata={FIELD_NAME: "org"})

catalystwan/endpoints/__init__.py

@@ -61,11 +61,12 @@ from uuid import UUID
 from packaging.specifiers import SpecifierSet  # type: ignore
 from packaging.version import Version  # type: ignore
 from pydantic import BaseModel
-from typing_extensions import Annotated, get_args, get_origin
+from typing_extensions import get_args, get_origin
 
 from catalystwan.abstractions import APIEndpointClient, APIEndpointClientResponse
 from catalystwan.exceptions import APIEndpointError, APIRequestPayloadTypeError, APIVersionError, APIViewError
 from catalystwan.typed_list import DataSequence
+from catalystwan.utils.model import resolve_nested_base_model_unions
 from catalystwan.utils.session_type import SessionType
 
 BASE_PATH: Final[str] = "/dataservice"
@@ -75,8 +76,7 @@ logger = logging.getLogger(__name__)
 
 @runtime_checkable
 class CustomPayloadType(Protocol):
-    def prepared(self) -> PreparedPayload:
-        ...
+    def prepared(self) -> PreparedPayload: ...
 
 
 JSON = Union[str, int, float, bool, None, Dict[str, "JSON"], List["JSON"]]
@@ -113,6 +113,19 @@ class TypeSpecifier:
     def model_union(cls, models: Sequence[type]) -> TypeSpecifier:
         return TypeSpecifier(present=True, payload_union_model_types=models)
 
+    @classmethod
+    def resolve_nested(cls, annotation: Any, models_types: List[type]) -> List[type]:
+        try:
+            return resolve_nested_base_model_unions(annotation)
+        except TypeError:
+            raise APIEndpointError(f"Expected: {PayloadType}")
+
+    @property
+    def payload_model_set(self) -> Optional[Set[type]]:
+        if self.payload_union_model_types is not None:
+            return set(self.payload_union_model_types)
+        return None
+
 
 @dataclass
 class APIEndpointRequestMeta:
@@ -161,16 +174,18 @@ class APIEndpoints:
     """
 
     @classmethod
-    def _prepare_payload(cls, payload: PayloadType, force_json: bool = False) -> PreparedPayload:
+    def _prepare_payload(
+        cls, payload: PayloadType, force_json: bool = False, context: Dict[str, Any] = {}
+    ) -> PreparedPayload:
         """Helper method to prepare data for sending based on type"""
         if force_json or isinstance(payload, dict):
             return PreparedPayload(data=json.dumps(payload), headers={"content-type": "application/json"})
         if isinstance(payload, (str, bytes)):
             return PreparedPayload(data=payload)
         elif isinstance(payload, (BaseModel)):
-            return cls._prepare_basemodel_payload(payload)
+            return cls._prepare_basemodel_payload(payload, context)
         elif isinstance(payload, Sequence) and not isinstance(payload, (str, bytes)):
-            return cls._prepare_sequence_payload(payload)  # type: ignore[arg-type]
+            return cls._prepare_sequence_payload(payload, context)  # type: ignore[arg-type]
             # offender is List[JSON] which is also a Sequence can be ignored as long as force_json is passed correctly
         elif isinstance(payload, CustomPayloadType):
             return payload.prepared()
@@ -178,26 +193,27 @@ class APIEndpoints:
             raise APIRequestPayloadTypeError(payload)
 
     @classmethod
-    def _prepare_basemodel_payload(cls, payload: BaseModel) -> PreparedPayload:
+    def _prepare_basemodel_payload(cls, payload: BaseModel, context: Dict[str, Any] = {}) -> PreparedPayload:
         """Helper method to prepare BaseModel instance for sending"""
         return PreparedPayload(
-            data=payload.model_dump_json(exclude_none=True, by_alias=True), headers={"content-type": "application/json"}
+            data=payload.model_dump_json(exclude_none=True, by_alias=True, context=context),
+            headers={"content-type": "application/json"},
         )
 
     @classmethod
-    def _prepare_sequence_payload(cls, payload: Iterable[BaseModel]) -> PreparedPayload:
+    def _prepare_sequence_payload(cls, payload: Iterable[BaseModel], context: Dict[str, Any] = {}) -> PreparedPayload:
         """Helper method to prepare sequences for sending"""
         items = []
         for item in payload:
-            items.append(item.model_dump(exclude_none=True, by_alias=True))
+            items.append(item.model_dump(exclude_none=True, by_alias=True, context=context))
         data = json.dumps(items)
         return PreparedPayload(data=data, headers={"content-type": "application/json"})
 
     @classmethod
-    def _prepare_params(cls, params: RequestParamsType) -> Dict[str, Any]:
+    def _prepare_params(cls, params: RequestParamsType, context: Dict[str, Any] = {}) -> Dict[str, Any]:
         """Helper method to prepare params for sending"""
         if isinstance(params, BaseModel):
-            return params.model_dump(exclude_none=True, by_alias=True)
+            return params.model_dump(exclude_none=True, by_alias=True, context=context)
         return params
 
     def __init__(self, client: APIEndpointClient):
@@ -215,10 +231,11 @@ class APIEndpoints:
     ) -> APIEndpointClientResponse:
         """Prepares and sends request using client protocol"""
         _kwargs = dict(kwargs)
+        context = dict(api_version=self._api_version)
         if payload is not None:
-            _kwargs.update(self._prepare_payload(payload, force_json_payload).asdict())
+            _kwargs.update(self._prepare_payload(payload, force_json_payload, context).asdict())
         if params is not None:
-            _kwargs.update({"params": self._prepare_params(params)})
+            _kwargs.update({"params": self._prepare_params(params, context)})
         return self._client.request(method, self._basepath + url, **_kwargs)
 
     @property
@@ -245,9 +262,9 @@ class versions(APIEndpointsDecorator):
     Logs warning or raises exception when incompatibility found during runtime.
     """
 
-    versions_lookup: ClassVar[
-        Dict[str, SpecifierSet]
-    ] = {}  # maps decorated method instance to it's supported verisions
+    versions_lookup: ClassVar[Dict[str, SpecifierSet]] = (
+        {}
+    )  # maps decorated method instance to it's supported verisions
 
     def __init__(self, supported_versions: str, raises: bool = False):
         self.supported_versions = SpecifierSet(supported_versions)
@@ -337,9 +354,9 @@ class request(APIEndpointsDecorator):
     """
 
     forbidden_url_field_names = {"self", "payload", "params"}
-    request_lookup: ClassVar[
-        Dict[str, APIEndpointRequestMeta]
-    ] = {}  # maps decorated method instance to it's meta information
+    request_lookup: ClassVar[Dict[str, APIEndpointRequestMeta]] = (
+        {}
+    )  # maps decorated method instance to it's meta information
 
     def __init__(self, http_method: str, url: str, resp_json_key: Optional[str] = None, **kwargs):
         self.http_method = http_method
@@ -441,27 +458,10 @@ class request(APIEndpointsDecorator):
                     and issubclass(type_args[0], BaseModel)
                 ):
                     return TypeSpecifier(True, type_origin, type_args[0], None, False, is_optional)
-            # Check if Annnotated[Union[PayloadModelType, ...]], only unions of pydantic models allowed
-            elif type_origin == Annotated:
-                if annotated_origin := get_args(annotation):
-                    if (len(annotated_origin) >= 1) and get_origin(annotated_origin[0]) == Union:
-                        if (
-                            (type_args := get_args(annotated_origin[0]))
-                            and all(isclass(t) for t in type_args)
-                            and all(issubclass(t, BaseModel) for t in type_args)
-                        ):
-                            return TypeSpecifier.model_union(models=list(type_args))
-            # Check if Union[PayloadModelType, ...], only unions of pydantic models allowed
-            elif type_origin == Union:
-                if (
-                    (type_args := get_args(annotation))
-                    and all(isclass(t) for t in type_args)
-                    and all(issubclass(t, BaseModel) for t in type_args)
-                ):
-                    return TypeSpecifier.model_union(models=list(type_args))
-            raise APIEndpointError(f"Expected: {PayloadType} but found payload {annotation}")
-        else:
-            raise APIEndpointError(f"Expected: {PayloadType} but found payload {annotation}")
+            else:
+                models = TypeSpecifier.resolve_nested(annotation, [])
+                return TypeSpecifier.model_union(models)
+        raise APIEndpointError(f"'payload' param must be annotated with supported type: {PayloadType}")
 
     def check_params(self):
         """Checks params in decorated method definition

catalystwan/endpoints/certificate_management_device.py

@@ -135,3 +135,7 @@ class CertificateManagementDevice(APIEndpoints):
     @post("/certificate/vsmart/list")
     def send_to_vbond(self) -> CertActionResponse:
         ...
+
+    @post("/certificate/install/signedCert")
+    def install_signed_cert(self, payload: str) -> CertActionResponse:
+        ...

catalystwan/endpoints/cluster_management.py

@@ -1,12 +1,13 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 # mypy: disable-error-code="empty-body"
-from typing import Literal, Optional
+from typing import Dict, Literal, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field
 
-from catalystwan.endpoints import APIEndpoints, get
+from catalystwan.endpoints import JSON, APIEndpoints, get, post, put
 from catalystwan.typed_list import DataSequence
+from catalystwan.utils.persona import Persona
 
 TenancyModes = Literal["SingleTenant", "MultiTenant"]
 
@@ -24,12 +25,30 @@ class VManageDetails(BaseModel):
     status: str
 
 
+class ConnectedDevice(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    uuid: str
+    device_id: str = Field(serialization_alias="deviceId", validation_alias="deviceId")
+
+
+class VManageSetup(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    vmanage_id: Optional[str] = Field(default=None, serialization_alias="vmanageID", validation_alias="vmanageID")
+    device_ip: str = Field(serialization_alias="deviceIP", validation_alias="deviceIP")
+    username: str
+    password: str
+    gen_csr: Optional[bool] = Field(default=None, serialization_alias="genCSR", validation_alias="genCSR")
+    persona: Persona
+    services: Optional[Dict[str, Dict[str, bool]]] = Field(default=None)
+
+
 class ClusterManagement(APIEndpoints):
     def add_or_update_user_credentials(self):
         # POST /clusterManagement/userCreds
         ...
 
-    def add_vmanage(self):
+    @post("/clusterManagement/setup")
+    def add_vmanage(self, payload: VManageSetup) -> JSON:
         # POST /clusterManagement/setup
         ...
 
@@ -41,7 +60,8 @@ class ClusterManagement(APIEndpoints):
         # POST /clusterManagement/configure
         ...
 
-    def edit_vmanage(self):
+    @put("/clusterManagement/setup")
+    def edit_vmanage(self, payload: VManageSetup) -> JSON:
         # PUT /clusterManagement/setup
         ...
 
@@ -53,8 +73,8 @@ class ClusterManagement(APIEndpoints):
         # GET /clusterManagement/iplist/{vmanageID}
         ...
 
-    def get_connected_devices(self):
-        # GET /clusterManagement/connectedDevices/{vmanageIP}
+    @get("/clusterManagement/connectedDevices/{vmanageIP}", "data")
+    def get_connected_devices(self, vmanageIP: str) -> DataSequence[ConnectedDevice]:
         ...
 
     def get_connected_devices_per_tenant(self):

catalystwan/endpoints/configuration/feature_profile/sdwan/application_priority.py

@@ -0,0 +1,107 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+# mypy: disable-error-code="empty-body"
+from uuid import UUID
+
+from catalystwan.endpoints import APIEndpoints, delete, get, post, put, versions
+from catalystwan.models.configuration.feature_profile.common import (
+    FeatureProfileCreationPayload,
+    FeatureProfileCreationResponse,
+    FeatureProfileDetail,
+    FeatureProfileEditPayload,
+    FeatureProfileInfo,
+    GetFeatureProfilesParams,
+)
+from catalystwan.models.configuration.feature_profile.parcel import Parcel, ParcelCreationResponse
+from catalystwan.models.configuration.feature_profile.sdwan.application_priority import AnyApplicationPriorityParcel
+from catalystwan.models.configuration.feature_profile.sdwan.application_priority.policy_settings import (
+    PolicySettingsParcel,
+)
+from catalystwan.typed_list import DataSequence
+
+
+class ApplicationPriorityFeatureProfile(APIEndpoints):
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @post("/v1/feature-profile/sdwan/application-priority")
+    def create_application_priority_feature_profile(
+        self, payload: FeatureProfileCreationPayload
+    ) -> FeatureProfileCreationResponse:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @get("/v1/feature-profile/sdwan/application-priority")
+    def get_application_priority_feature_profiles(
+        self, params: GetFeatureProfilesParams
+    ) -> DataSequence[FeatureProfileInfo]:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @get("/v1/feature-profile/sdwan/application-priority/{profile_id}")
+    def get_application_priority_feature_profile(
+        self, profile_id: str, params: GetFeatureProfilesParams
+    ) -> FeatureProfileDetail:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @put("/v1/feature-profile/sdwan/application-priority/{profile_id}")
+    def edit_application_priority_feature_profile(
+        self, profile_id: str, payload: FeatureProfileEditPayload
+    ) -> FeatureProfileCreationResponse:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @delete("/v1/feature-profile/sdwan/application-priority/{profile_id}")
+    def delete_application_priority_feature_profile(self, profile_id: str) -> None:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @post("/v1/feature-profile/sdwan/application-priority/{profile_id}/{application_priority_list_type}")
+    def create(
+        self, profile_id: UUID, application_priority_list_type: str, payload: AnyApplicationPriorityParcel
+    ) -> ParcelCreationResponse:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @delete(
+        "/v1/feature-profile/sdwan/application-priority/{profile_id}/{application_priority_list_type}/{list_object_id}"
+    )
+    def delete(self, profile_id: UUID, application_priority_list_type: str, list_object_id: UUID) -> None:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @put(
+        "/v1/feature-profile/sdwan/application-priority/{profile_id}/{application_priority_list_type}/{list_object_id}"
+    )
+    def update(
+        self,
+        profile_id: UUID,
+        application_priority_list_type: str,
+        list_object_id: UUID,
+        payload: AnyApplicationPriorityParcel,
+    ) -> ParcelCreationResponse:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @get(
+        "/v1/feature-profile/sdwan/application-priority/{profile_id}/{application_priority_list_type}/{list_object_id}"
+    )
+    def get_by_id(self, profile_id: UUID, application_priority_list_type: str, list_object_id: UUID) -> Parcel:
+        ...
+
+    @versions(supported_versions=(">=20.12"), raises=False)
+    @get(
+        "/v1/feature-profile/sdwan/application-priority/{profile_id}/{application_priority_list_type}",
+        resp_json_key="data",
+    )
+    def get_all(self, profile_id: UUID, application_priority_list_type: str) -> DataSequence[Parcel]:
+        ...
+
+    @versions(supported_versions=(">20.12"), raises=False)
+    @post("/v1/feature-profile/sdwan/application-priority/{profile_id}/policy-settings")
+    def create_policy_settings(self, profile_id: UUID, payload: PolicySettingsParcel) -> ParcelCreationResponse:
+        ...
+
+    @versions(supported_versions=(">20.12"), raises=False)
+    @get("/v1/feature-profile/sdwan/application-priority/{profile_id}/policy-settings/{list_object_id}")
+    def get_policy_settings(self, profile_id: UUID, list_object_id: UUID) -> Parcel:
+        ...

catalystwan/endpoints/configuration/feature_profile/sdwan/cli.py

@@ -0,0 +1,60 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+# mypy: disable-error-code="empty-body"
+from typing import Optional
+from uuid import UUID
+
+from catalystwan.endpoints import APIEndpoints, delete, get, post, put, versions
+from catalystwan.models.configuration.feature_profile.common import (
+    FeatureProfileCreationPayload,
+    FeatureProfileCreationResponse,
+    FeatureProfileInfo,
+    GetFeatureProfilesParams,
+)
+from catalystwan.models.configuration.feature_profile.parcel import Parcel, ParcelCreationResponse
+from catalystwan.models.configuration.feature_profile.sdwan.cli import AnyCliParcel
+from catalystwan.typed_list import DataSequence
+
+
+class CliFeatureProfile(APIEndpoints):
+    @versions(">=20.9")
+    @get("/v1/feature-profile/sdwan/cli")
+    def get_profiles(self, payload: Optional[GetFeatureProfilesParams]) -> DataSequence[FeatureProfileInfo]:
+        ...
+
+    @versions(">=20.9")
+    @post("/v1/feature-profile/sdwan/cli")
+    def create_profile(self, payload: FeatureProfileCreationPayload) -> FeatureProfileCreationResponse:
+        ...
+
+    @versions(">=20.9")
+    @delete("/v1/feature-profile/sdwan/cli/{profile_id}")
+    def delete_profile(self, profile_id: UUID) -> None:
+        ...
+
+    @versions(">=20.9")
+    @get("/v1/feature-profile/sdwan/cli/{profile_id}/{parcel_type}")
+    def get_all(self, profile_id: UUID, parcel_type: str) -> DataSequence[Parcel[AnyCliParcel]]:
+        ...
+
+    @versions(">=20.9")
+    @get("/v1/feature-profile/sdwan/cli/{profile_id}/{parcel_type}/{parcel_id}")
+    def get_by_id(self, profile_id: UUID, parcel_type: str, parcel_id: UUID) -> Parcel[AnyCliParcel]:
+        ...
+
+    @versions(">=20.9")
+    @post("/v1/feature-profile/sdwan/cli/{profile_id}/{parcel_type}")
+    def create(self, profile_id: UUID, parcel_type: str, payload: AnyCliParcel) -> ParcelCreationResponse:
+        ...
+
+    @versions(">=20.9")
+    @put("/v1/feature-profile/sdwan/cli/{profile_id}/{parcel_type}/{parcel_id}")
+    def update(
+        self, profile_id: UUID, parcel_type: str, parcel_id: UUID, payload: AnyCliParcel
+    ) -> ParcelCreationResponse:
+        ...
+
+    @versions(">=20.9")
+    @delete("/v1/feature-profile/sdwan/cli/{profile_id}/{parcel_type}/{parcel_id}")
+    def delete(self, profile_id: UUID, parcel_type: str, parcel_id: UUID) -> None:
+        ...