flashstart-client 9.0.2__py3-none-any.whl

flashstart_client/generated/integration/models/delete_device_response_200_info.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.delete_device_response_200_info_metadata import (
+        DeleteDeviceResponse200InfoMetadata,
+    )
+
+
+T = TypeVar("T", bound="DeleteDeviceResponse200Info")
+
+
+@_attrs_define
+class DeleteDeviceResponse200Info:
+    """
+    Attributes:
+        device_id (UUID | Unset):
+        local_dns_ip (str | Unset):
+        public_dns_fallback (bool | Unset):
+        version (str | Unset):
+        last_version_check_time (datetime.datetime | str | Unset):
+        last_login_check_time (datetime.datetime | str | Unset):
+        last_stats_check_time (datetime.datetime | None | str | Unset):
+        hardware_model (str | Unset):
+        os_version (str | Unset):
+        release_version (str | Unset):
+        firmware_version (str | Unset):
+        cpu_usage (float | None | Unset):
+        ram_usage (float | None | Unset):
+        disk_usage (float | None | Unset):
+        uptime (float | Unset):
+        temperature (float | Unset):
+        metadata (DeleteDeviceResponse200InfoMetadata | Unset):
+    """
+
+    device_id: UUID | Unset = UNSET
+    local_dns_ip: str | Unset = UNSET
+    public_dns_fallback: bool | Unset = UNSET
+    version: str | Unset = UNSET
+    last_version_check_time: datetime.datetime | str | Unset = UNSET
+    last_login_check_time: datetime.datetime | str | Unset = UNSET
+    last_stats_check_time: datetime.datetime | None | str | Unset = UNSET
+    hardware_model: str | Unset = UNSET
+    os_version: str | Unset = UNSET
+    release_version: str | Unset = UNSET
+    firmware_version: str | Unset = UNSET
+    cpu_usage: float | None | Unset = UNSET
+    ram_usage: float | None | Unset = UNSET
+    disk_usage: float | None | Unset = UNSET
+    uptime: float | Unset = UNSET
+    temperature: float | Unset = UNSET
+    metadata: DeleteDeviceResponse200InfoMetadata | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        device_id: str | Unset = UNSET
+        if not isinstance(self.device_id, Unset):
+            device_id = str(self.device_id)
+
+        local_dns_ip = self.local_dns_ip
+
+        public_dns_fallback = self.public_dns_fallback
+
+        version = self.version
+
+        last_version_check_time: str | Unset
+        if isinstance(self.last_version_check_time, Unset):
+            last_version_check_time = UNSET
+        elif isinstance(self.last_version_check_time, datetime.datetime):
+            last_version_check_time = self.last_version_check_time.isoformat()
+        else:
+            last_version_check_time = self.last_version_check_time
+
+        last_login_check_time: str | Unset
+        if isinstance(self.last_login_check_time, Unset):
+            last_login_check_time = UNSET
+        elif isinstance(self.last_login_check_time, datetime.datetime):
+            last_login_check_time = self.last_login_check_time.isoformat()
+        else:
+            last_login_check_time = self.last_login_check_time
+
+        last_stats_check_time: None | str | Unset
+        if isinstance(self.last_stats_check_time, Unset):
+            last_stats_check_time = UNSET
+        elif isinstance(self.last_stats_check_time, datetime.datetime):
+            last_stats_check_time = self.last_stats_check_time.isoformat()
+        else:
+            last_stats_check_time = self.last_stats_check_time
+
+        hardware_model = self.hardware_model
+
+        os_version = self.os_version
+
+        release_version = self.release_version
+
+        firmware_version = self.firmware_version
+
+        cpu_usage: float | None | Unset
+        if isinstance(self.cpu_usage, Unset):
+            cpu_usage = UNSET
+        else:
+            cpu_usage = self.cpu_usage
+
+        ram_usage: float | None | Unset
+        if isinstance(self.ram_usage, Unset):
+            ram_usage = UNSET
+        else:
+            ram_usage = self.ram_usage
+
+        disk_usage: float | None | Unset
+        if isinstance(self.disk_usage, Unset):
+            disk_usage = UNSET
+        else:
+            disk_usage = self.disk_usage
+
+        uptime = self.uptime
+
+        temperature = self.temperature
+
+        metadata: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({})
+        if device_id is not UNSET:
+            field_dict["deviceId"] = device_id
+        if local_dns_ip is not UNSET:
+            field_dict["localDnsIp"] = local_dns_ip
+        if public_dns_fallback is not UNSET:
+            field_dict["publicDnsFallback"] = public_dns_fallback
+        if version is not UNSET:
+            field_dict["version"] = version
+        if last_version_check_time is not UNSET:
+            field_dict["lastVersionCheckTime"] = last_version_check_time
+        if last_login_check_time is not UNSET:
+            field_dict["lastLoginCheckTime"] = last_login_check_time
+        if last_stats_check_time is not UNSET:
+            field_dict["lastStatsCheckTime"] = last_stats_check_time
+        if hardware_model is not UNSET:
+            field_dict["hardwareModel"] = hardware_model
+        if os_version is not UNSET:
+            field_dict["osVersion"] = os_version
+        if release_version is not UNSET:
+            field_dict["releaseVersion"] = release_version
+        if firmware_version is not UNSET:
+            field_dict["firmwareVersion"] = firmware_version
+        if cpu_usage is not UNSET:
+            field_dict["cpuUsage"] = cpu_usage
+        if ram_usage is not UNSET:
+            field_dict["ramUsage"] = ram_usage
+        if disk_usage is not UNSET:
+            field_dict["diskUsage"] = disk_usage
+        if uptime is not UNSET:
+            field_dict["uptime"] = uptime
+        if temperature is not UNSET:
+            field_dict["temperature"] = temperature
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.delete_device_response_200_info_metadata import (
+            DeleteDeviceResponse200InfoMetadata,
+        )
+
+        d = dict(src_dict)
+        _device_id = d.pop("deviceId", UNSET)
+        device_id: UUID | Unset
+        if isinstance(_device_id, Unset):
+            device_id = UNSET
+        else:
+            device_id = UUID(_device_id)
+
+        local_dns_ip = d.pop("localDnsIp", UNSET)
+
+        public_dns_fallback = d.pop("publicDnsFallback", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        def _parse_last_version_check_time(
+            data: object,
+        ) -> datetime.datetime | str | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_version_check_time_type_1 = datetime.datetime.fromisoformat(data)
+
+                return last_version_check_time_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | str | Unset, data)
+
+        last_version_check_time = _parse_last_version_check_time(
+            d.pop("lastVersionCheckTime", UNSET)
+        )
+
+        def _parse_last_login_check_time(
+            data: object,
+        ) -> datetime.datetime | str | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_login_check_time_type_1 = datetime.datetime.fromisoformat(data)
+
+                return last_login_check_time_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | str | Unset, data)
+
+        last_login_check_time = _parse_last_login_check_time(
+            d.pop("lastLoginCheckTime", UNSET)
+        )
+
+        def _parse_last_stats_check_time(
+            data: object,
+        ) -> datetime.datetime | None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_stats_check_time_type_0_type_1 = datetime.datetime.fromisoformat(
+                    data
+                )
+
+                return last_stats_check_time_type_0_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | str | Unset, data)
+
+        last_stats_check_time = _parse_last_stats_check_time(
+            d.pop("lastStatsCheckTime", UNSET)
+        )
+
+        hardware_model = d.pop("hardwareModel", UNSET)
+
+        os_version = d.pop("osVersion", UNSET)
+
+        release_version = d.pop("releaseVersion", UNSET)
+
+        firmware_version = d.pop("firmwareVersion", UNSET)
+
+        def _parse_cpu_usage(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        cpu_usage = _parse_cpu_usage(d.pop("cpuUsage", UNSET))
+
+        def _parse_ram_usage(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        ram_usage = _parse_ram_usage(d.pop("ramUsage", UNSET))
+
+        def _parse_disk_usage(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        disk_usage = _parse_disk_usage(d.pop("diskUsage", UNSET))
+
+        uptime = d.pop("uptime", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: DeleteDeviceResponse200InfoMetadata | Unset
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = DeleteDeviceResponse200InfoMetadata.from_dict(_metadata)
+
+        delete_device_response_200_info = cls(
+            device_id=device_id,
+            local_dns_ip=local_dns_ip,
+            public_dns_fallback=public_dns_fallback,
+            version=version,
+            last_version_check_time=last_version_check_time,
+            last_login_check_time=last_login_check_time,
+            last_stats_check_time=last_stats_check_time,
+            hardware_model=hardware_model,
+            os_version=os_version,
+            release_version=release_version,
+            firmware_version=firmware_version,
+            cpu_usage=cpu_usage,
+            ram_usage=ram_usage,
+            disk_usage=disk_usage,
+            uptime=uptime,
+            temperature=temperature,
+            metadata=metadata,
+        )
+
+        return delete_device_response_200_info

flashstart_client/generated/integration/models/delete_device_response_200_info_metadata.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DeleteDeviceResponse200InfoMetadata")
+
+
+@_attrs_define
+class DeleteDeviceResponse200InfoMetadata:
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        delete_device_response_200_info_metadata = cls()
+
+        delete_device_response_200_info_metadata.additional_properties = d
+        return delete_device_response_200_info_metadata
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

flashstart_client/generated/integration/models/delete_device_response_200_type.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class DeleteDeviceResponse200Type(StrEnum):
+    CLOUDBOX = "CLOUDBOX"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/integration/models/delete_dns_route_response_200.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+
+from ..models.delete_dns_route_response_200_target import (
+    DeleteDnsRouteResponse200Target,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DeleteDnsRouteResponse200")
+
+
+@_attrs_define
+class DeleteDnsRouteResponse200:
+    """
+    Attributes:
+        id (UUID):
+        primary_forward_ip (str):
+        domain (str):
+        device_ids (list[UUID]):
+        organization_id (UUID):
+        target (DeleteDnsRouteResponse200Target):
+        secondary_forward_ip (str | Unset):
+    """
+
+    id: UUID
+    primary_forward_ip: str
+    domain: str
+    device_ids: list[UUID]
+    organization_id: UUID
+    target: DeleteDnsRouteResponse200Target
+    secondary_forward_ip: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        primary_forward_ip = self.primary_forward_ip
+
+        domain = self.domain
+
+        device_ids = []
+        for device_ids_item_data in self.device_ids:
+            device_ids_item = str(device_ids_item_data)
+            device_ids.append(device_ids_item)
+
+        organization_id = str(self.organization_id)
+
+        target = self.target.value
+
+        secondary_forward_ip = self.secondary_forward_ip
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "primaryForwardIp": primary_forward_ip,
+                "domain": domain,
+                "deviceIds": device_ids,
+                "organizationId": organization_id,
+                "target": target,
+            }
+        )
+        if secondary_forward_ip is not UNSET:
+            field_dict["secondaryForwardIp"] = secondary_forward_ip
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        primary_forward_ip = d.pop("primaryForwardIp")
+
+        domain = d.pop("domain")
+
+        device_ids = []
+        _device_ids = d.pop("deviceIds")
+        for device_ids_item_data in _device_ids:
+            device_ids_item = UUID(device_ids_item_data)
+
+            device_ids.append(device_ids_item)
+
+        organization_id = UUID(d.pop("organizationId"))
+
+        target = DeleteDnsRouteResponse200Target(d.pop("target"))
+
+        secondary_forward_ip = d.pop("secondaryForwardIp", UNSET)
+
+        delete_dns_route_response_200 = cls(
+            id=id,
+            primary_forward_ip=primary_forward_ip,
+            domain=domain,
+            device_ids=device_ids,
+            organization_id=organization_id,
+            target=target,
+            secondary_forward_ip=secondary_forward_ip,
+        )
+
+        return delete_dns_route_response_200

flashstart_client/generated/integration/models/delete_dns_route_response_200_target.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class DeleteDnsRouteResponse200Target(StrEnum):
+    CLOUDBOX = "CLOUDBOX"
+    ENDPOINT = "ENDPOINT"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/integration/models/delete_end_point_dns_route_response_200.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+
+from ..models.delete_end_point_dns_route_response_200_target import (
+    DeleteEndPointDnsRouteResponse200Target,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DeleteEndPointDnsRouteResponse200")
+
+
+@_attrs_define
+class DeleteEndPointDnsRouteResponse200:
+    """
+    Attributes:
+        id (UUID):
+        primary_forward_ip (str):
+        domain (str):
+        endpoint_policy_ids (list[str]):
+        organization_id (UUID):
+        target (DeleteEndPointDnsRouteResponse200Target):
+        secondary_forward_ip (str | Unset):
+    """
+
+    id: UUID
+    primary_forward_ip: str
+    domain: str
+    endpoint_policy_ids: list[str]
+    organization_id: UUID
+    target: DeleteEndPointDnsRouteResponse200Target
+    secondary_forward_ip: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        primary_forward_ip = self.primary_forward_ip
+
+        domain = self.domain
+
+        endpoint_policy_ids = self.endpoint_policy_ids
+
+        organization_id = str(self.organization_id)
+
+        target = self.target.value
+
+        secondary_forward_ip = self.secondary_forward_ip
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "primaryForwardIp": primary_forward_ip,
+                "domain": domain,
+                "endpointPolicyIds": endpoint_policy_ids,
+                "organizationId": organization_id,
+                "target": target,
+            }
+        )
+        if secondary_forward_ip is not UNSET:
+            field_dict["secondaryForwardIp"] = secondary_forward_ip
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        primary_forward_ip = d.pop("primaryForwardIp")
+
+        domain = d.pop("domain")
+
+        endpoint_policy_ids = cast(list[str], d.pop("endpointPolicyIds"))
+
+        organization_id = UUID(d.pop("organizationId"))
+
+        target = DeleteEndPointDnsRouteResponse200Target(d.pop("target"))
+
+        secondary_forward_ip = d.pop("secondaryForwardIp", UNSET)
+
+        delete_end_point_dns_route_response_200 = cls(
+            id=id,
+            primary_forward_ip=primary_forward_ip,
+            domain=domain,
+            endpoint_policy_ids=endpoint_policy_ids,
+            organization_id=organization_id,
+            target=target,
+            secondary_forward_ip=secondary_forward_ip,
+        )
+
+        return delete_end_point_dns_route_response_200

flashstart_client/generated/integration/models/delete_end_point_dns_route_response_200_target.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class DeleteEndPointDnsRouteResponse200Target(StrEnum):
+    CLOUDBOX = "CLOUDBOX"
+    ENDPOINT = "ENDPOINT"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/integration/models/delete_router_response_200.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.delete_router_response_200_networks_item import (
+        DeleteRouterResponse200NetworksItem,
+    )
+
+
+T = TypeVar("T", bound="DeleteRouterResponse200")
+
+
+@_attrs_define
+class DeleteRouterResponse200:
+    """
+    Attributes:
+        id (UUID):
+        name (str):
+        organization_id (UUID):
+        physical_device_id (UUID):
+        networks (list[DeleteRouterResponse200NetworksItem]):
+        note (str | Unset):
+    """
+
+    id: UUID
+    name: str
+    organization_id: UUID
+    physical_device_id: UUID
+    networks: list[DeleteRouterResponse200NetworksItem]
+    note: str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        name = self.name
+
+        organization_id = str(self.organization_id)
+
+        physical_device_id = str(self.physical_device_id)
+
+        networks = []
+        for networks_item_data in self.networks:
+            networks_item = networks_item_data.to_dict()
+            networks.append(networks_item)
+
+        note = self.note
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "organizationId": organization_id,
+                "physicalDeviceId": physical_device_id,
+                "networks": networks,
+            }
+        )
+        if note is not UNSET:
+            field_dict["note"] = note
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.delete_router_response_200_networks_item import (
+            DeleteRouterResponse200NetworksItem,
+        )
+
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        organization_id = UUID(d.pop("organizationId"))
+
+        physical_device_id = UUID(d.pop("physicalDeviceId"))
+
+        networks = []
+        _networks = d.pop("networks")
+        for networks_item_data in _networks:
+            networks_item = DeleteRouterResponse200NetworksItem.from_dict(
+                networks_item_data
+            )
+
+            networks.append(networks_item)
+
+        note = d.pop("note", UNSET)
+
+        delete_router_response_200 = cls(
+            id=id,
+            name=name,
+            organization_id=organization_id,
+            physical_device_id=physical_device_id,
+            networks=networks,
+            note=note,
+        )
+
+        return delete_router_response_200