stackit-vpn 0.1.0__py3-none-any.whl

src/stackit/vpn/models/quota_list.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
+
+from stackit.vpn.models.quota import Quota
+
+
+class QuotaList(BaseModel):
+    """
+    QuotaList
+    """  # noqa: E501
+
+    gateways: Quota = Field(description="Current limit and usage for VPN gateways.")
+    __properties: ClassVar[List[str]] = ["gateways"]
+
+    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 QuotaList 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 gateways
+        if self.gateways:
+            _dict["gateways"] = self.gateways.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QuotaList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"gateways": Quota.from_dict(obj["gateways"]) if obj.get("gateways") is not None else None}
+        )
+        return _obj

src/stackit/vpn/models/quota_list_response.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import Self
+
+from stackit.vpn.models.quota_list import QuotaList
+
+
+class QuotaListResponse(BaseModel):
+    """
+    QuotaListResponse
+    """  # noqa: E501
+
+    quotas: QuotaList
+    __properties: ClassVar[List[str]] = ["quotas"]
+
+    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 QuotaListResponse 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 quotas
+        if self.quotas:
+            _dict["quotas"] = self.quotas.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QuotaListResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"quotas": QuotaList.from_dict(obj["quotas"]) if obj.get("quotas") is not None else None}
+        )
+        return _obj

src/stackit/vpn/models/region.py

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    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 Region(str, Enum):
+    """
+    The region in which the resource is located.
+    """
+
+    """
+    allowed enum values
+    """
+    EU01 = "eu01"
+    EU02 = "eu02"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of Region from a JSON string"""
+        return cls(json.loads(json_str))

src/stackit/vpn/models/routing_type.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    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 RoutingType(str, Enum):
+    """
+    RoutingType
+    """
+
+    """
+    allowed enum values
+    """
+    POLICY_BASED = "POLICY_BASED"
+    ROUTE_BASED = "ROUTE_BASED"
+    BGP_ROUTE_BASED = "BGP_ROUTE_BASED"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of RoutingType from a JSON string"""
+        return cls(json.loads(json_str))

src/stackit/vpn/models/tunnel_configuration.py

@@ -0,0 +1,124 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing_extensions import Annotated, Self
+
+from stackit.vpn.models.bgp_tunnel_config import BGPTunnelConfig
+from stackit.vpn.models.peering_config import PeeringConfig
+from stackit.vpn.models.tunnel_configuration_phase1 import TunnelConfigurationPhase1
+from stackit.vpn.models.tunnel_configuration_phase2 import TunnelConfigurationPhase2
+
+
+class TunnelConfiguration(BaseModel):
+    """
+    TunnelConfiguration
+    """  # noqa: E501
+
+    bgp: Optional[BGPTunnelConfig] = None
+    peering: Optional[PeeringConfig] = None
+    phase1: TunnelConfigurationPhase1
+    phase2: TunnelConfigurationPhase2
+    pre_shared_key: Optional[Annotated[str, Field(min_length=20, strict=True)]] = Field(
+        default=None,
+        description="A Pre-Shared Key for authentication.  Required in create-requests, optional in update-requests and omitted in every response.",
+        alias="preSharedKey",
+    )
+    remote_address: Annotated[str, Field(strict=True)] = Field(alias="remoteAddress")
+    __properties: ClassVar[List[str]] = ["bgp", "peering", "phase1", "phase2", "preSharedKey", "remoteAddress"]
+
+    @field_validator("remote_address")
+    def remote_address_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$", value):
+            raise ValueError(r"must validate the regular expression /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/")
+        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 TunnelConfiguration 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 bgp
+        if self.bgp:
+            _dict["bgp"] = self.bgp.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of peering
+        if self.peering:
+            _dict["peering"] = self.peering.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of phase1
+        if self.phase1:
+            _dict["phase1"] = self.phase1.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of phase2
+        if self.phase2:
+            _dict["phase2"] = self.phase2.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TunnelConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "bgp": BGPTunnelConfig.from_dict(obj["bgp"]) if obj.get("bgp") is not None else None,
+                "peering": PeeringConfig.from_dict(obj["peering"]) if obj.get("peering") is not None else None,
+                "phase1": TunnelConfigurationPhase1.from_dict(obj["phase1"]) if obj.get("phase1") is not None else None,
+                "phase2": TunnelConfigurationPhase2.from_dict(obj["phase2"]) if obj.get("phase2") is not None else None,
+                "preSharedKey": obj.get("preSharedKey"),
+                "remoteAddress": obj.get("remoteAddress"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/tunnel_configuration_phase1.py

@@ -0,0 +1,126 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Annotated, Self
+
+
+class TunnelConfigurationPhase1(BaseModel):
+    """
+    TunnelConfigurationPhase1
+    """  # noqa: E501
+
+    dh_groups: Optional[List[StrictStr]] = Field(
+        default=None,
+        description="The Diffie-Hellman Group. Required, except if AEAD algorithms are selected.",
+        alias="dhGroups",
+    )
+    encryption_algorithms: List[StrictStr] = Field(alias="encryptionAlgorithms")
+    integrity_algorithms: List[StrictStr] = Field(alias="integrityAlgorithms")
+    rekey_time: Optional[Annotated[int, Field(le=28800, strict=True, ge=900)]] = Field(
+        default=14400, description="Time to schedule a IKE re-keying (in seconds).", alias="rekeyTime"
+    )
+    __properties: ClassVar[List[str]] = ["dhGroups", "encryptionAlgorithms", "integrityAlgorithms", "rekeyTime"]
+
+    @field_validator("dh_groups")
+    def dh_groups_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(["modp1024", "modp2048", "ecp256", "ecp384", "modp2048s256"]):
+                raise ValueError(
+                    "each list item must be one of ('modp1024', 'modp2048', 'ecp256', 'ecp384', 'modp2048s256')"
+                )
+        return value
+
+    @field_validator("encryption_algorithms")
+    def encryption_algorithms_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(["aes256", "aes128gcm16", "aes256gcm16"]):
+                raise ValueError("each list item must be one of ('aes256', 'aes128gcm16', 'aes256gcm16')")
+        return value
+
+    @field_validator("integrity_algorithms")
+    def integrity_algorithms_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(["sha1", "sha2_256", "sha2_384"]):
+                raise ValueError("each list item must be one of ('sha1', 'sha2_256', 'sha2_384')")
+        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 TunnelConfigurationPhase1 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 TunnelConfigurationPhase1 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "dhGroups": obj.get("dhGroups"),
+                "encryptionAlgorithms": obj.get("encryptionAlgorithms"),
+                "integrityAlgorithms": obj.get("integrityAlgorithms"),
+                "rekeyTime": obj.get("rekeyTime") if obj.get("rekeyTime") is not None else 14400,
+            }
+        )
+        return _obj

src/stackit/vpn/models/tunnel_configuration_phase2.py

@@ -0,0 +1,165 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Annotated, Self
+
+
+class TunnelConfigurationPhase2(BaseModel):
+    """
+    TunnelConfigurationPhase2
+    """  # noqa: E501
+
+    dh_groups: Optional[List[StrictStr]] = Field(
+        default=None,
+        description="The Diffie-Hellman Group. Required, except if AEAD algorithms are selected.",
+        alias="dhGroups",
+    )
+    encryption_algorithms: List[StrictStr] = Field(alias="encryptionAlgorithms")
+    integrity_algorithms: List[StrictStr] = Field(alias="integrityAlgorithms")
+    dpd_action: Optional[StrictStr] = Field(
+        default="restart",
+        description='Action to perform for this CHILD_SA on DPD timeout. "clear": Closes the CHILD_SA and does not take further action. "restart": immediately tries to re-negotiate the CILD_SA under a fresh IKE_SA. ',
+        alias="dpdAction",
+    )
+    rekey_time: Optional[Annotated[int, Field(le=3600, strict=True, ge=900)]] = Field(
+        default=3600, description="Time to schedule a Child SA re-keying (in seconds).", alias="rekeyTime"
+    )
+    start_action: Optional[StrictStr] = Field(
+        default="start",
+        description='Action to perform after loading the connection configuration. "none": The connection will be loaded but needs to be manually initiated. "start": initiates the connection actively. ',
+        alias="startAction",
+    )
+    __properties: ClassVar[List[str]] = [
+        "dhGroups",
+        "encryptionAlgorithms",
+        "integrityAlgorithms",
+        "dpdAction",
+        "rekeyTime",
+        "startAction",
+    ]
+
+    @field_validator("dh_groups")
+    def dh_groups_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(["modp1024", "modp2048", "ecp256", "ecp384", "modp2048s256"]):
+                raise ValueError(
+                    "each list item must be one of ('modp1024', 'modp2048', 'ecp256', 'ecp384', 'modp2048s256')"
+                )
+        return value
+
+    @field_validator("encryption_algorithms")
+    def encryption_algorithms_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(["aes256", "aes128gcm16", "aes256gcm16"]):
+                raise ValueError("each list item must be one of ('aes256', 'aes128gcm16', 'aes256gcm16')")
+        return value
+
+    @field_validator("integrity_algorithms")
+    def integrity_algorithms_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(["sha1", "sha2_256", "sha2_384"]):
+                raise ValueError("each list item must be one of ('sha1', 'sha2_256', 'sha2_384')")
+        return value
+
+    @field_validator("dpd_action")
+    def dpd_action_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(["clear", "restart"]):
+            raise ValueError("must be one of enum values ('clear', 'restart')")
+        return value
+
+    @field_validator("start_action")
+    def start_action_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(["none", "start"]):
+            raise ValueError("must be one of enum values ('none', 'start')")
+        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 TunnelConfigurationPhase2 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 TunnelConfigurationPhase2 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "dhGroups": obj.get("dhGroups"),
+                "encryptionAlgorithms": obj.get("encryptionAlgorithms"),
+                "integrityAlgorithms": obj.get("integrityAlgorithms"),
+                "dpdAction": obj.get("dpdAction") if obj.get("dpdAction") is not None else "restart",
+                "rekeyTime": obj.get("rekeyTime") if obj.get("rekeyTime") is not None else 3600,
+                "startAction": obj.get("startAction") if obj.get("startAction") is not None else "start",
+            }
+        )
+        return _obj