stackit-vpn 0.1.0__py3-none-any.whl

src/stackit/vpn/models/connection_response.py

@@ -0,0 +1,149 @@
+# 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 uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, field_validator
+from typing_extensions import Annotated, Self
+
+from stackit.vpn.models.tunnel_configuration import TunnelConfiguration
+
+
+class ConnectionResponse(BaseModel):
+    """
+    ConnectionResponse
+    """  # noqa: E501
+
+    display_name: Annotated[str, Field(strict=True)] = Field(
+        description="A user-friendly name for the connection.", alias="displayName"
+    )
+    enabled: Optional[StrictBool] = Field(
+        default=None, description="This flag decides whether this connection should be enabled or disabled"
+    )
+    id: Optional[UUID] = Field(default=None, description="UUID of the Gateway instance.")
+    labels: Optional[Dict[str, Annotated[str, Field(strict=True, max_length=63)]]] = Field(
+        default=None,
+        description="Map of custom labels. Key and values must be a string with max 63 chars, start/end with alphanumeric. The key of a label follows the same rules as the `LabelValue` except that it cannot be empty. ",
+    )
+    local_subnets: Optional[
+        Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=1, max_length=100)]
+    ] = Field(
+        default=None,
+        description="Optional. Defaults to 0.0.0.0/0 for Route-based VPN configurations. Mandatory for Policy-based.",
+        alias="localSubnets",
+    )
+    remote_subnets: Optional[
+        Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=1, max_length=100)]
+    ] = Field(
+        default=None,
+        description="Optional. Defaults to 0.0.0.0/0 for Route-based VPN configurations. Mandatory for Policy-based.",
+        alias="remoteSubnets",
+    )
+    static_routes: Optional[List[Annotated[str, Field(strict=True)]]] = Field(
+        default=None, description="Optional. Use this for route-based VPN.", alias="staticRoutes"
+    )
+    tunnel1: TunnelConfiguration
+    tunnel2: TunnelConfiguration
+    __properties: ClassVar[List[str]] = [
+        "displayName",
+        "enabled",
+        "id",
+        "labels",
+        "localSubnets",
+        "remoteSubnets",
+        "staticRoutes",
+        "tunnel1",
+        "tunnel2",
+    ]
+
+    @field_validator("display_name")
+    def display_name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/")
+        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 ConnectionResponse 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 tunnel1
+        if self.tunnel1:
+            _dict["tunnel1"] = self.tunnel1.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of tunnel2
+        if self.tunnel2:
+            _dict["tunnel2"] = self.tunnel2.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ConnectionResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "displayName": obj.get("displayName"),
+                "enabled": obj.get("enabled"),
+                "id": obj.get("id"),
+                "labels": obj.get("labels"),
+                "localSubnets": obj.get("localSubnets"),
+                "remoteSubnets": obj.get("remoteSubnets"),
+                "staticRoutes": obj.get("staticRoutes"),
+                "tunnel1": TunnelConfiguration.from_dict(obj["tunnel1"]) if obj.get("tunnel1") is not None else None,
+                "tunnel2": TunnelConfiguration.from_dict(obj["tunnel2"]) if obj.get("tunnel2") is not None else None,
+            }
+        )
+        return _obj

src/stackit/vpn/models/connection_status_response.py

@@ -0,0 +1,113 @@
+# 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 uuid import UUID
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictStr,
+)
+from typing_extensions import Self
+
+from stackit.vpn.models.tunnel_status import TunnelStatus
+
+
+class ConnectionStatusResponse(BaseModel):
+    """
+    ConnectionStatusResponse
+    """  # noqa: E501
+
+    display_name: Optional[StrictStr] = Field(
+        default=None, description="The name of the connection.", alias="displayName"
+    )
+    enabled: Optional[StrictBool] = None
+    id: Optional[UUID] = Field(default=None, description="UUID of the connection.")
+    tunnels: Optional[List[TunnelStatus]] = None
+    __properties: ClassVar[List[str]] = ["displayName", "enabled", "id", "tunnels"]
+
+    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 ConnectionStatusResponse 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 tunnels (list)
+        _items = []
+        if self.tunnels:
+            for _item_tunnels in self.tunnels:
+                if _item_tunnels:
+                    _items.append(_item_tunnels.to_dict())
+            _dict["tunnels"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ConnectionStatusResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "displayName": obj.get("displayName"),
+                "enabled": obj.get("enabled"),
+                "id": obj.get("id"),
+                "tunnels": (
+                    [TunnelStatus.from_dict(_item) for _item in obj["tunnels"]]
+                    if obj.get("tunnels") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

src/stackit/vpn/models/create_gateway_connection_payload.py

@@ -0,0 +1,139 @@
+# 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, StrictBool, field_validator
+from typing_extensions import Annotated, Self
+
+from stackit.vpn.models.tunnel_configuration import TunnelConfiguration
+
+
+class CreateGatewayConnectionPayload(BaseModel):
+    """
+    CreateGatewayConnectionPayload
+    """  # noqa: E501
+
+    display_name: Annotated[str, Field(strict=True)] = Field(
+        description="A user-friendly name for the connection.", alias="displayName"
+    )
+    enabled: Optional[StrictBool] = Field(
+        default=None, description="This flag decides whether this connection should be enabled or disabled"
+    )
+    local_subnets: Optional[
+        Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=1, max_length=100)]
+    ] = Field(
+        default=None,
+        description="Optional. Defaults to 0.0.0.0/0 for Route-based VPN configurations. Mandatory for Policy-based.",
+        alias="localSubnets",
+    )
+    remote_subnets: Optional[
+        Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=1, max_length=100)]
+    ] = Field(
+        default=None,
+        description="Optional. Defaults to 0.0.0.0/0 for Route-based VPN configurations. Mandatory for Policy-based.",
+        alias="remoteSubnets",
+    )
+    static_routes: Optional[List[Annotated[str, Field(strict=True)]]] = Field(
+        default=None, description="Optional. Use this for route-based VPN.", alias="staticRoutes"
+    )
+    tunnel1: TunnelConfiguration
+    tunnel2: TunnelConfiguration
+    __properties: ClassVar[List[str]] = [
+        "displayName",
+        "enabled",
+        "localSubnets",
+        "remoteSubnets",
+        "staticRoutes",
+        "tunnel1",
+        "tunnel2",
+    ]
+
+    @field_validator("display_name")
+    def display_name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/")
+        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 CreateGatewayConnectionPayload 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 tunnel1
+        if self.tunnel1:
+            _dict["tunnel1"] = self.tunnel1.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of tunnel2
+        if self.tunnel2:
+            _dict["tunnel2"] = self.tunnel2.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateGatewayConnectionPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "displayName": obj.get("displayName"),
+                "enabled": obj.get("enabled"),
+                "localSubnets": obj.get("localSubnets"),
+                "remoteSubnets": obj.get("remoteSubnets"),
+                "staticRoutes": obj.get("staticRoutes"),
+                "tunnel1": TunnelConfiguration.from_dict(obj["tunnel1"]) if obj.get("tunnel1") is not None else None,
+                "tunnel2": TunnelConfiguration.from_dict(obj["tunnel2"]) if obj.get("tunnel2") is not None else None,
+            }
+        )
+        return _obj

src/stackit/vpn/models/create_vpn_gateway_payload.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, StrictStr, field_validator
+from typing_extensions import Annotated, Self
+
+from stackit.vpn.models.bgp_gateway_config import BGPGatewayConfig
+from stackit.vpn.models.create_vpn_gateway_payload_availability_zones import (
+    CreateVPNGatewayPayloadAvailabilityZones,
+)
+from stackit.vpn.models.routing_type import RoutingType
+
+
+class CreateVPNGatewayPayload(BaseModel):
+    """
+    CreateVPNGatewayPayload
+    """  # noqa: E501
+
+    availability_zones: CreateVPNGatewayPayloadAvailabilityZones = Field(alias="availabilityZones")
+    bgp: Optional[BGPGatewayConfig] = None
+    display_name: Annotated[str, Field(strict=True)] = Field(
+        description="A user-friendly name for the VPN gateway.", alias="displayName"
+    )
+    labels: Optional[Dict[str, Annotated[str, Field(strict=True, max_length=63)]]] = Field(
+        default=None,
+        description="Map of custom labels. Key and values must be a string with max 63 chars, start/end with alphanumeric. The key of a label follows the same rules as the `LabelValue` except that it cannot be empty. ",
+    )
+    plan_id: StrictStr = Field(description="The service plan identifier.", alias="planId")
+    routing_type: RoutingType = Field(alias="routingType")
+    __properties: ClassVar[List[str]] = ["availabilityZones", "bgp", "displayName", "labels", "planId", "routingType"]
+
+    @field_validator("display_name")
+    def display_name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/")
+        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 CreateVPNGatewayPayload 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 availability_zones
+        if self.availability_zones:
+            _dict["availabilityZones"] = self.availability_zones.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of bgp
+        if self.bgp:
+            _dict["bgp"] = self.bgp.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateVPNGatewayPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "availabilityZones": (
+                    CreateVPNGatewayPayloadAvailabilityZones.from_dict(obj["availabilityZones"])
+                    if obj.get("availabilityZones") is not None
+                    else None
+                ),
+                "bgp": BGPGatewayConfig.from_dict(obj["bgp"]) if obj.get("bgp") is not None else None,
+                "displayName": obj.get("displayName"),
+                "labels": obj.get("labels"),
+                "planId": obj.get("planId"),
+                "routingType": obj.get("routingType"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/create_vpn_gateway_payload_availability_zones.py

@@ -0,0 +1,82 @@
+# 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
+from typing_extensions import Self
+
+
+class CreateVPNGatewayPayloadAvailabilityZones(BaseModel):
+    """
+    CreateVPNGatewayPayloadAvailabilityZones
+    """  # noqa: E501
+
+    tunnel1: StrictStr = Field(description="Object that represents an availability zone.")
+    tunnel2: StrictStr = Field(description="Object that represents an availability zone.")
+    __properties: ClassVar[List[str]] = ["tunnel1", "tunnel2"]
+
+    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 CreateVPNGatewayPayloadAvailabilityZones 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 CreateVPNGatewayPayloadAvailabilityZones from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"tunnel1": obj.get("tunnel1"), "tunnel2": obj.get("tunnel2")})
+        return _obj