stackit-vpn 0.1.0__py3-none-any.whl

src/stackit/vpn/models/phase.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 pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Self
+
+
+class Phase(BaseModel):
+    """
+    Phase
+    """  # 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")
+    __properties: ClassVar[List[str]] = ["dhGroups", "encryptionAlgorithms", "integrityAlgorithms"]
+
+    @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 Phase 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 Phase 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"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/phase1_status.py

@@ -0,0 +1,99 @@
+# 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 Phase1Status(BaseModel):
+    """
+    Phase1Status
+    """  # noqa: E501
+
+    dh_group: Optional[StrictStr] = Field(
+        default=None, description="The negotiated Diffie-Hellman Group", alias="dhGroup"
+    )
+    encryption_algorithm: Optional[StrictStr] = Field(
+        default=None, description="The negotiated encryption algorithm.", alias="encryptionAlgorithm"
+    )
+    integrity_algorithm: Optional[StrictStr] = Field(
+        default=None,
+        description="The negotiated integrity algorithm or pseudo-random-function.",
+        alias="integrityAlgorithm",
+    )
+    state: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["dhGroup", "encryptionAlgorithm", "integrityAlgorithm", "state"]
+
+    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 Phase1Status 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 Phase1Status from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "dhGroup": obj.get("dhGroup"),
+                "encryptionAlgorithm": obj.get("encryptionAlgorithm"),
+                "integrityAlgorithm": obj.get("integrityAlgorithm"),
+                "state": obj.get("state"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/phase2_status.py

@@ -0,0 +1,143 @@
+# 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 Phase2Status(BaseModel):
+    """
+    Phase2Status
+    """  # noqa: E501
+
+    bytes_in: Optional[StrictStr] = Field(
+        default=None,
+        description="The total data volume received through this Security Association, measured in bytes.",
+        alias="bytesIn",
+    )
+    bytes_out: Optional[StrictStr] = Field(
+        default=None,
+        description="The total data volume sent through this Security Association, measured in bytes.",
+        alias="bytesOut",
+    )
+    dh_group: Optional[StrictStr] = Field(
+        default=None, description="The negotiated Diffie-Hellman Group", alias="dhGroup"
+    )
+    encap: Optional[StrictStr] = Field(
+        default=None, description="Indicates whether NAT traversal encapsulation is active for the connection."
+    )
+    encryption_algorithm: Optional[StrictStr] = Field(
+        default=None, description="The negotiated encryption algorithm.", alias="encryptionAlgorithm"
+    )
+    integrity_algorithm: Optional[StrictStr] = Field(
+        default=None,
+        description="The negotiated integrity algorithm or pseudo-random-function.",
+        alias="integrityAlgorithm",
+    )
+    packets_in: Optional[StrictStr] = Field(
+        default=None,
+        description="The total number of packets received through this IPsec Security Association.",
+        alias="packetsIn",
+    )
+    packets_out: Optional[StrictStr] = Field(
+        default=None,
+        description="The total number of packets sent through this IPsec Security Association",
+        alias="packetsOut",
+    )
+    protocol: Optional[StrictStr] = Field(
+        default=None,
+        description="The security protocol used for the tunnel, typically `ESP` (Encapsulating Security Payload).",
+    )
+    state: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = [
+        "bytesIn",
+        "bytesOut",
+        "dhGroup",
+        "encap",
+        "encryptionAlgorithm",
+        "integrityAlgorithm",
+        "packetsIn",
+        "packetsOut",
+        "protocol",
+        "state",
+    ]
+
+    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 Phase2Status 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 Phase2Status from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "bytesIn": obj.get("bytesIn"),
+                "bytesOut": obj.get("bytesOut"),
+                "dhGroup": obj.get("dhGroup"),
+                "encap": obj.get("encap"),
+                "encryptionAlgorithm": obj.get("encryptionAlgorithm"),
+                "integrityAlgorithm": obj.get("integrityAlgorithm"),
+                "packetsIn": obj.get("packetsIn"),
+                "packetsOut": obj.get("packetsOut"),
+                "protocol": obj.get("protocol"),
+                "state": obj.get("state"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/plan.py

@@ -0,0 +1,101 @@
+# 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, StrictInt, StrictStr
+from typing_extensions import Self
+
+
+class Plan(BaseModel):
+    """
+    Plan
+    """  # noqa: E501
+
+    max_bandwidth: Optional[StrictInt] = Field(
+        default=None,
+        description="The maximum throughput supported by the gateway in each direction, measured in MBit/s",
+        alias="maxBandwidth",
+    )
+    max_connections: Optional[StrictInt] = Field(
+        default=None,
+        description="The maximum number of connections supported by the VPN Gateway.",
+        alias="maxConnections",
+    )
+    name: Optional[StrictStr] = Field(default=None, description="The name of the service plan.")
+    plan_id: Optional[StrictStr] = Field(default=None, description="The service plan identifier.", alias="planId")
+    sku: Optional[StrictStr] = Field(default=None, description="The SKU identifier used for billing.")
+    __properties: ClassVar[List[str]] = ["maxBandwidth", "maxConnections", "name", "planId", "sku"]
+
+    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 Plan 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 Plan from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "maxBandwidth": obj.get("maxBandwidth"),
+                "maxConnections": obj.get("maxConnections"),
+                "name": obj.get("name"),
+                "planId": obj.get("planId"),
+                "sku": obj.get("sku"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/plan_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, Field, StrictStr
+from typing_extensions import Self
+
+from stackit.vpn.models.plan import Plan
+
+
+class PlanList(BaseModel):
+    """
+    PlanList
+    """  # noqa: E501
+
+    default_plan_id: Optional[StrictStr] = Field(
+        default=None, description="The service plan identifier.", alias="defaultPlanId"
+    )
+    plans: Optional[List[Plan]] = None
+    __properties: ClassVar[List[str]] = ["defaultPlanId", "plans"]
+
+    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 PlanList 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 plans (list)
+        _items = []
+        if self.plans:
+            for _item_plans in self.plans:
+                if _item_plans:
+                    _items.append(_item_plans.to_dict())
+            _dict["plans"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PlanList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "defaultPlanId": obj.get("defaultPlanId"),
+                "plans": [Plan.from_dict(_item) for _item in obj["plans"]] if obj.get("plans") is not None else None,
+            }
+        )
+        return _obj

src/stackit/vpn/models/quota.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, StrictInt
+from typing_extensions import Self
+
+
+class Quota(BaseModel):
+    """
+    Quota
+    """  # noqa: E501
+
+    limit: StrictInt
+    usage: StrictInt
+    __properties: ClassVar[List[str]] = ["limit", "usage"]
+
+    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 Quota 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 Quota from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"limit": obj.get("limit"), "usage": obj.get("usage")})
+        return _obj