stackit-vpn 0.1.0__py3-none-any.whl

src/stackit/vpn/models/gateway.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 Gateway(BaseModel):
+    """
+    Gateway
+    """  # 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 Gateway 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 Gateway 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/gateway_list.py

@@ -0,0 +1,98 @@
+# 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.gateway_response import GatewayResponse
+
+
+class GatewayList(BaseModel):
+    """
+    GatewayList
+    """  # noqa: E501
+
+    gateways: List[GatewayResponse]
+    __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 GatewayList 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 gateways (list)
+        _items = []
+        if self.gateways:
+            for _item_gateways in self.gateways:
+                if _item_gateways:
+                    _items.append(_item_gateways.to_dict())
+            _dict["gateways"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GatewayList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "gateways": (
+                    [GatewayResponse.from_dict(_item) for _item in obj["gateways"]]
+                    if obj.get("gateways") is not None
+                    else None
+                )
+            }
+        )
+        return _obj

src/stackit/vpn/models/gateway_response.py

@@ -0,0 +1,144 @@
+# 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, 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.gateway_status import GatewayStatus
+from stackit.vpn.models.routing_type import RoutingType
+
+
+class GatewayResponse(BaseModel):
+    """
+    GatewayResponse
+    """  # 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")
+    id: Optional[UUID] = Field(default=None, description="The server-generated UUID of the VPN gateway.")
+    state: Optional[GatewayStatus] = None
+    __properties: ClassVar[List[str]] = [
+        "availabilityZones",
+        "bgp",
+        "displayName",
+        "labels",
+        "planId",
+        "routingType",
+        "id",
+        "state",
+    ]
+
+    @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 GatewayResponse 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.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set(
+            [
+                "id",
+            ]
+        )
+
+        _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 GatewayResponse 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"),
+                "id": obj.get("id"),
+                "state": obj.get("state"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/gateway_status.py

@@ -0,0 +1,38 @@
+# 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 GatewayStatus(str, Enum):
+    """
+    The current lifecycle state of the gateway infrastructure. - `PENDING`: Provisioning or update is in progress. - `READY`: The gateway is fully operational. - `ERROR`: A failure occurred. - `DELETING`: The resource is being removed.
+    """
+
+    """
+    allowed enum values
+    """
+    PENDING = "PENDING"
+    READY = "READY"
+    ERROR = "ERROR"
+    DELETING = "DELETING"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of GatewayStatus from a JSON string"""
+        return cls(json.loads(json_str))

src/stackit/vpn/models/gateway_status_response.py

@@ -0,0 +1,122 @@
+# 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, StrictStr
+from typing_extensions import Self
+
+from stackit.vpn.models.connection_status_response import ConnectionStatusResponse
+from stackit.vpn.models.gateway_status import GatewayStatus
+from stackit.vpn.models.vpn_tunnels import VPNTunnels
+
+
+class GatewayStatusResponse(BaseModel):
+    """
+    GatewayStatusResponse
+    """  # noqa: E501
+
+    connections: Optional[List[ConnectionStatusResponse]] = None
+    display_name: Optional[StrictStr] = Field(
+        default=None, description="Name of the Gateway instance.", alias="displayName"
+    )
+    gateway_status: Optional[GatewayStatus] = Field(default=None, alias="gatewayStatus")
+    id: Optional[UUID] = Field(default=None, description="UUID of the Gateway instance.")
+    tunnels: Optional[List[VPNTunnels]] = None
+    __properties: ClassVar[List[str]] = ["connections", "displayName", "gatewayStatus", "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 GatewayStatusResponse 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 connections (list)
+        _items = []
+        if self.connections:
+            for _item_connections in self.connections:
+                if _item_connections:
+                    _items.append(_item_connections.to_dict())
+            _dict["connections"] = _items
+        # 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 GatewayStatusResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "connections": (
+                    [ConnectionStatusResponse.from_dict(_item) for _item in obj["connections"]]
+                    if obj.get("connections") is not None
+                    else None
+                ),
+                "displayName": obj.get("displayName"),
+                "gatewayStatus": obj.get("gatewayStatus"),
+                "id": obj.get("id"),
+                "tunnels": (
+                    [VPNTunnels.from_dict(_item) for _item in obj["tunnels"]]
+                    if obj.get("tunnels") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

src/stackit/vpn/models/peering_config.py

@@ -0,0 +1,103 @@
+# 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
+
+
+class PeeringConfig(BaseModel):
+    """
+    The peering object defines the point-to-point IP configuration for the Tunnel Interface.  These addresses serve as next-hop identifiers and are used for BGP peering sessions and can be used in Static Route-Based connectivity.
+    """  # noqa: E501
+
+    local_address: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, alias="localAddress")
+    remote_address: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, alias="remoteAddress")
+    __properties: ClassVar[List[str]] = ["localAddress", "remoteAddress"]
+
+    @field_validator("local_address")
+    def local_address_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        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
+
+    @field_validator("remote_address")
+    def remote_address_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        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 PeeringConfig 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 PeeringConfig from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"localAddress": obj.get("localAddress"), "remoteAddress": obj.get("remoteAddress")})
+        return _obj