scc-firewall-manager-sdk 1.13.665__py3-none-any.whl → 1.13.666__py3-none-any.whl

scc_firewall_manager_sdk/models/ether_channel_interface_patch_input.py

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.interface_ipv4_address import InterfaceIpv4Address
+from scc_firewall_manager_sdk.models.interface_ipv6_address import InterfaceIpv6Address
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EtherChannelInterfacePatchInput(BaseModel):
+    """
+    EtherChannelInterfacePatchInput
+    """ # noqa: E501
+    description: Optional[StrictStr] = Field(default=None, description="The description of the interface.")
+    enabled: Optional[StrictBool] = Field(default=None, description="Indicates whether the interface is enabled.")
+    ipv4: Optional[InterfaceIpv4Address] = None
+    ipv6: Optional[InterfaceIpv6Address] = None
+    lacp_mode: Optional[StrictStr] = Field(default=None, description="The Link Aggregation Control Protocol (LACP) mode of the EtherChannel interface.", alias="lacpMode")
+    mac_address: Optional[StrictStr] = Field(default=None, description="The interface Media Access Control (MAC) address, a unique hardware identifier assigned to each physical interface. it is used for Layer 2 communication within a network segment.", alias="macAddress")
+    management_only: Optional[StrictBool] = Field(default=None, description="Indicates whether the interface is exclusively used for management traffic and does not carry regular user or data traffic", alias="managementOnly")
+    member_interfaces: Optional[List[StrictStr]] = Field(default=None, description="The set of unique identifiers, represented as UUIDs, of the member interfaces that are part of the EtherChannel group.", alias="memberInterfaces")
+    monitor_interface: Optional[StrictBool] = Field(default=None, description="Indicates if the interface is actively monitored for checking its operational status and health as part of an HA setup. It helps determine if the interface is functioning correctly and whether a failover to a standby device should be triggered in case of failure.", alias="monitorInterface")
+    mtu: Optional[StrictInt] = Field(default=None, description="The interface MTU (Maximum Transmission Unit), the largest size, in bytes, of a packet or frame that can be sent over a network interface without needing to be fragmented. It defines the maximum payload size that the interface can handle in a single transmission.")
+    name: Optional[StrictStr] = Field(default=None, description="The logical name of the interface. Interface names are unique in the scope of the device.")
+    security_level: Optional[StrictInt] = Field(default=None, description="Indicates the interface trust level, ranging from 0 (lowest) to 100 (highest).", alias="securityLevel")
+    standby_mac_address: Optional[StrictStr] = Field(default=None, description="The standby interface Media Access Control (MAC) address, for use in a high-availability (HA) pair.", alias="standbyMacAddress")
+    __properties: ClassVar[List[str]] = ["description", "enabled", "ipv4", "ipv6", "lacpMode", "macAddress", "managementOnly", "memberInterfaces", "monitorInterface", "mtu", "name", "securityLevel", "standbyMacAddress"]
+
+    @field_validator('lacp_mode')
+    def lacp_mode_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['ACTIVE', 'PASSIVE', 'ON']):
+            raise ValueError("must be one of enum values ('ACTIVE', 'PASSIVE', 'ON')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of EtherChannelInterfacePatchInput from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of ipv4
+        if self.ipv4:
+            _dict['ipv4'] = self.ipv4.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of ipv6
+        if self.ipv6:
+            _dict['ipv6'] = self.ipv6.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EtherChannelInterfacePatchInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "description": obj.get("description"),
+            "enabled": obj.get("enabled"),
+            "ipv4": InterfaceIpv4Address.from_dict(obj["ipv4"]) if obj.get("ipv4") is not None else None,
+            "ipv6": InterfaceIpv6Address.from_dict(obj["ipv6"]) if obj.get("ipv6") is not None else None,
+            "lacpMode": obj.get("lacpMode"),
+            "macAddress": obj.get("macAddress"),
+            "managementOnly": obj.get("managementOnly"),
+            "memberInterfaces": obj.get("memberInterfaces"),
+            "monitorInterface": obj.get("monitorInterface"),
+            "mtu": obj.get("mtu"),
+            "name": obj.get("name"),
+            "securityLevel": obj.get("securityLevel"),
+            "standbyMacAddress": obj.get("standbyMacAddress")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/interface_ip_address.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InterfaceIpAddress(BaseModel):
+    """
+    InterfaceIpAddress
+    """ # noqa: E501
+    ip_address: Optional[StrictStr] = Field(default=None, description="A unique network address assigned to a physical or logical port, enabling it to communicate on a specific network segment and enforce security policies for traffic traversing that interface.", alias="ipAddress")
+    netmask: Optional[StrictStr] = Field(default=None, description="A 32-bit number that defines the network portion of the IP address, differentiating it from the host portion. It determines the size of the local network segment directly connected to that interface, allowing to identify which traffic belongs to its local network and which needs to be routed.")
+    setroute: Optional[StrictBool] = Field(default=None, description="Indicates whether a default route using the gateway information provided by the DHCP server is created automatically. Essentially, the DHCP-assigned gateway is used as the next-hop for routing traffic")
+    standby_ip_address: Optional[StrictStr] = Field(default=None, description="A secondary IP address configured on an interface, specifically for use in a high-availability (HA) pair. This address remains inactive on the standby unit until a failover occurs, at which point the standby assumes ownership of this IP address (along with the primary IP) to maintain network connectivity for devices.", alias="standbyIpAddress")
+    __properties: ClassVar[List[str]] = ["ipAddress", "netmask", "setroute", "standbyIpAddress"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InterfaceIpAddress from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InterfaceIpAddress from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "ipAddress": obj.get("ipAddress"),
+            "netmask": obj.get("netmask"),
+            "setroute": obj.get("setroute"),
+            "standbyIpAddress": obj.get("standbyIpAddress")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/interface_ipv4_address.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.interface_ip_address import InterfaceIpAddress
+from scc_firewall_manager_sdk.models.ip_type import IpType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InterfaceIpv4Address(BaseModel):
+    """
+    InterfaceIpv4Address
+    """ # noqa: E501
+    ip_address: Optional[InterfaceIpAddress] = Field(default=None, alias="ipAddress")
+    ip_type: Optional[IpType] = Field(default=None, alias="ipType")
+    __properties: ClassVar[List[str]] = ["ipAddress", "ipType"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InterfaceIpv4Address from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of ip_address
+        if self.ip_address:
+            _dict['ipAddress'] = self.ip_address.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InterfaceIpv4Address from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "ipAddress": InterfaceIpAddress.from_dict(obj["ipAddress"]) if obj.get("ipAddress") is not None else None,
+            "ipType": obj.get("ipType")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/interface_ipv6_address.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.interface_ip_address import InterfaceIpAddress
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InterfaceIpv6Address(BaseModel):
+    """
+    InterfaceIpv6Address
+    """ # noqa: E501
+    auto_config: Optional[StrictBool] = Field(default=None, description="Indicates whether the address is automatically configured.", alias="autoConfig")
+    dad_attempts: Optional[StrictInt] = Field(default=None, description="Indicates how many times the device performs Duplicate Address Detection (DAD) to verify the uniqueness of an address before assigning the IPv6 address. Range is 0-600.", alias="dadAttempts")
+    enabled: Optional[StrictBool] = Field(default=None, description="Indicates whether IPV6 is enabled on the interface.")
+    ip_addresses: Optional[List[InterfaceIpAddress]] = Field(default=None, description="List of IPV6 addresses assigned to the interface.", alias="ipAddresses")
+    link_local_address: Optional[InterfaceIpAddress] = Field(default=None, alias="linkLocalAddress")
+    suppress_ra: Optional[StrictBool] = Field(default=None, description="Indicates whether to suppress router advertisements.", alias="suppressRA")
+    __properties: ClassVar[List[str]] = ["autoConfig", "dadAttempts", "enabled", "ipAddresses", "linkLocalAddress", "suppressRA"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InterfaceIpv6Address from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in ip_addresses (list)
+        _items = []
+        if self.ip_addresses:
+            for _item in self.ip_addresses:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['ipAddresses'] = _items
+        # override the default output from pydantic by calling `to_dict()` of link_local_address
+        if self.link_local_address:
+            _dict['linkLocalAddress'] = self.link_local_address.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InterfaceIpv6Address from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "autoConfig": obj.get("autoConfig"),
+            "dadAttempts": obj.get("dadAttempts"),
+            "enabled": obj.get("enabled"),
+            "ipAddresses": [InterfaceIpAddress.from_dict(_item) for _item in obj["ipAddresses"]] if obj.get("ipAddresses") is not None else None,
+            "linkLocalAddress": InterfaceIpAddress.from_dict(obj["linkLocalAddress"]) if obj.get("linkLocalAddress") is not None else None,
+            "suppressRA": obj.get("suppressRA")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/interface_mode.py

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class InterfaceMode(str, Enum):
+    """
+    InterfaceMode
+    """
+
+    """
+    allowed enum values
+    """
+    ROUTED = 'ROUTED'
+    PASSIVE = 'PASSIVE'
+    SWITCHPORT = 'SWITCHPORT'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of InterfaceMode from a JSON string"""
+        return cls(json.loads(json_str))
+
+

scc_firewall_manager_sdk/models/interface_runtime_data.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scc_firewall_manager_sdk.models.link_state import LinkState
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InterfaceRuntimeData(BaseModel):
+    """
+    InterfaceRuntimeData
+    """ # noqa: E501
+    duplex_type: Optional[StrictStr] = Field(default=None, description="The actual duplex mode of the physical interface.", alias="duplexType")
+    ip_address: Optional[StrictStr] = Field(default=None, description="The actual IP address of the interface.", alias="ipAddress")
+    link_enabled: Optional[StrictBool] = Field(default=None, description="Indicates whether the interface link is enabled.", alias="linkEnabled")
+    link_state: Optional[LinkState] = Field(default=None, alias="linkState")
+    mac_address: Optional[StrictStr] = Field(default=None, description="The actual Media Access Control (MAC) address of the interface.", alias="macAddress")
+    mtu: Optional[StrictInt] = Field(default=None, description="The actual MTU (Maximum Transmission Unit) of the interface.")
+    speed_type: Optional[StrictStr] = Field(default=None, description="The actual speed of the physical interface.", alias="speedType")
+    __properties: ClassVar[List[str]] = ["duplexType", "ipAddress", "linkEnabled", "linkState", "macAddress", "mtu", "speedType"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InterfaceRuntimeData from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InterfaceRuntimeData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "duplexType": obj.get("duplexType"),
+            "ipAddress": obj.get("ipAddress"),
+            "linkEnabled": obj.get("linkEnabled"),
+            "linkState": obj.get("linkState"),
+            "macAddress": obj.get("macAddress"),
+            "mtu": obj.get("mtu"),
+            "speedType": obj.get("speedType")
+        })
+        return _obj
+
+

scc_firewall_manager_sdk/models/interface_type.py

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class InterfaceType(str, Enum):
+    """
+    InterfaceType
+    """
+
+    """
+    allowed enum values
+    """
+    PHYSICAL_INTERFACE = 'PHYSICAL_INTERFACE'
+    SUB_INTERFACE = 'SUB_INTERFACE'
+    VIRTUAL_TUNNEL_INTERFACE = 'VIRTUAL_TUNNEL_INTERFACE'
+    VLAN_INTERFACE = 'VLAN_INTERFACE'
+    ETHER_CHANNEL_INTERFACE = 'ETHER_CHANNEL_INTERFACE'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of InterfaceType from a JSON string"""
+        return cls(json.loads(json_str))
+
+

scc_firewall_manager_sdk/models/ip_type.py

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+"""
+    Cisco Security Cloud Control Firewall Manager API
+
+    Use the documentation to explore the endpoints Security Cloud Control Firewall Manager has to offer
+
+    The version of the OpenAPI document: 1.13.0
+    Contact: cdo.tac@cisco.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class IpType(str, Enum):
+    """
+    IpType
+    """
+
+    """
+    allowed enum values
+    """
+    STATIC = 'STATIC'
+    DHCP = 'DHCP'
+    PPPOE = 'PPPOE'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of IpType from a JSON string"""
+        return cls(json.loads(json_str))
+
+