flashstart-client 9.0.2__py3-none-any.whl

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_3_ddns.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ListNetworksResponse200ItemType1NetworkType3Ddns")
+
+
+@_attrs_define
+class ListNetworksResponse200ItemType1NetworkType3Ddns:
+    """
+    Attributes:
+        username (str):
+        password (str):
+        last_sync (datetime.datetime | None | Unset):
+    """
+
+    username: str
+    password: str
+    last_sync: datetime.datetime | None | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        username = self.username
+
+        password = self.password
+
+        last_sync: None | str | Unset
+        if isinstance(self.last_sync, Unset):
+            last_sync = UNSET
+        elif isinstance(self.last_sync, datetime.datetime):
+            last_sync = self.last_sync.isoformat()
+        else:
+            last_sync = self.last_sync
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "username": username,
+                "password": password,
+            }
+        )
+        if last_sync is not UNSET:
+            field_dict["lastSync"] = last_sync
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        username = d.pop("username")
+
+        password = d.pop("password")
+
+        def _parse_last_sync(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_sync_type_0 = datetime.datetime.fromisoformat(data)
+
+                return last_sync_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_sync = _parse_last_sync(d.pop("lastSync", UNSET))
+
+        list_networks_response_200_item_type_1_network_type_3_ddns = cls(
+            username=username,
+            password=password,
+            last_sync=last_sync,
+        )
+
+        return list_networks_response_200_item_type_1_network_type_3_ddns

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_3_dynamic_ip_type_2.py

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

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_3_type.py

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

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_4.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import datetime
+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.list_networks_response_200_item_type_1_network_type_4_dynamic_ip_type_1 import (
+    ListNetworksResponse200ItemType1NetworkType4DynamicIpType1,
+)
+from ..models.list_networks_response_200_item_type_1_network_type_4_type import (
+    ListNetworksResponse200ItemType1NetworkType4Type,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ListNetworksResponse200ItemType1NetworkType4")
+
+
+@_attrs_define
+class ListNetworksResponse200ItemType1NetworkType4:
+    """
+    Attributes:
+        id (UUID):
+        name (str):
+        note (None | str):
+        organization_id (UUID):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        type_ (ListNetworksResponse200ItemType1NetworkType4Type):
+        domain (str):
+        dynamic_ip (ListNetworksResponse200ItemType1NetworkType4DynamicIpType1 | str):
+        last_queried_at (datetime.datetime | None | Unset):
+        last_changed (datetime.datetime | None | Unset):
+    """
+
+    id: UUID
+    name: str
+    note: None | str
+    organization_id: UUID
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    type_: ListNetworksResponse200ItemType1NetworkType4Type
+    domain: str
+    dynamic_ip: ListNetworksResponse200ItemType1NetworkType4DynamicIpType1 | str
+    last_queried_at: datetime.datetime | None | Unset = UNSET
+    last_changed: datetime.datetime | None | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        name = self.name
+
+        note: None | str
+        note = self.note
+
+        organization_id = str(self.organization_id)
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        type_ = self.type_.value
+
+        domain = self.domain
+
+        dynamic_ip: str
+        if isinstance(
+            self.dynamic_ip, ListNetworksResponse200ItemType1NetworkType4DynamicIpType1
+        ):
+            dynamic_ip = self.dynamic_ip.value
+        else:
+            dynamic_ip = self.dynamic_ip
+
+        last_queried_at: None | str | Unset
+        if isinstance(self.last_queried_at, Unset):
+            last_queried_at = UNSET
+        elif isinstance(self.last_queried_at, datetime.datetime):
+            last_queried_at = self.last_queried_at.isoformat()
+        else:
+            last_queried_at = self.last_queried_at
+
+        last_changed: None | str | Unset
+        if isinstance(self.last_changed, Unset):
+            last_changed = UNSET
+        elif isinstance(self.last_changed, datetime.datetime):
+            last_changed = self.last_changed.isoformat()
+        else:
+            last_changed = self.last_changed
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "note": note,
+                "organizationId": organization_id,
+                "createdAt": created_at,
+                "updatedAt": updated_at,
+                "type": type_,
+                "domain": domain,
+                "dynamicIp": dynamic_ip,
+            }
+        )
+        if last_queried_at is not UNSET:
+            field_dict["lastQueriedAt"] = last_queried_at
+        if last_changed is not UNSET:
+            field_dict["lastChanged"] = last_changed
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        def _parse_note(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        note = _parse_note(d.pop("note"))
+
+        organization_id = UUID(d.pop("organizationId"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("createdAt"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updatedAt"))
+
+        type_ = ListNetworksResponse200ItemType1NetworkType4Type(d.pop("type"))
+
+        domain = d.pop("domain")
+
+        def _parse_dynamic_ip(
+            data: object,
+        ) -> ListNetworksResponse200ItemType1NetworkType4DynamicIpType1 | str:
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                dynamic_ip_type_1 = (
+                    ListNetworksResponse200ItemType1NetworkType4DynamicIpType1(data)
+                )
+
+                return dynamic_ip_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(
+                ListNetworksResponse200ItemType1NetworkType4DynamicIpType1 | str, data
+            )
+
+        dynamic_ip = _parse_dynamic_ip(d.pop("dynamicIp"))
+
+        def _parse_last_queried_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_queried_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return last_queried_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_queried_at = _parse_last_queried_at(d.pop("lastQueriedAt", UNSET))
+
+        def _parse_last_changed(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_changed_type_0 = datetime.datetime.fromisoformat(data)
+
+                return last_changed_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_changed = _parse_last_changed(d.pop("lastChanged", UNSET))
+
+        list_networks_response_200_item_type_1_network_type_4 = cls(
+            id=id,
+            name=name,
+            note=note,
+            organization_id=organization_id,
+            created_at=created_at,
+            updated_at=updated_at,
+            type_=type_,
+            domain=domain,
+            dynamic_ip=dynamic_ip,
+            last_queried_at=last_queried_at,
+            last_changed=last_changed,
+        )
+
+        return list_networks_response_200_item_type_1_network_type_4

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_4_dynamic_ip_type_1.py

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

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_4_type.py

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

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_5.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import datetime
+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.list_networks_response_200_item_type_1_network_type_5_type import (
+    ListNetworksResponse200ItemType1NetworkType5Type,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ListNetworksResponse200ItemType1NetworkType5")
+
+
+@_attrs_define
+class ListNetworksResponse200ItemType1NetworkType5:
+    """
+    Attributes:
+        id (UUID):
+        name (str):
+        note (None | str):
+        organization_id (UUID):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        type_ (ListNetworksResponse200ItemType1NetworkType5Type):
+        tag (str):
+        policy_id (UUID):
+        last_queried_at (datetime.datetime | None | Unset):
+    """
+
+    id: UUID
+    name: str
+    note: None | str
+    organization_id: UUID
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    type_: ListNetworksResponse200ItemType1NetworkType5Type
+    tag: str
+    policy_id: UUID
+    last_queried_at: datetime.datetime | None | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        name = self.name
+
+        note: None | str
+        note = self.note
+
+        organization_id = str(self.organization_id)
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        type_ = self.type_.value
+
+        tag = self.tag
+
+        policy_id = str(self.policy_id)
+
+        last_queried_at: None | str | Unset
+        if isinstance(self.last_queried_at, Unset):
+            last_queried_at = UNSET
+        elif isinstance(self.last_queried_at, datetime.datetime):
+            last_queried_at = self.last_queried_at.isoformat()
+        else:
+            last_queried_at = self.last_queried_at
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "note": note,
+                "organizationId": organization_id,
+                "createdAt": created_at,
+                "updatedAt": updated_at,
+                "type": type_,
+                "tag": tag,
+                "policyId": policy_id,
+            }
+        )
+        if last_queried_at is not UNSET:
+            field_dict["lastQueriedAt"] = last_queried_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        def _parse_note(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        note = _parse_note(d.pop("note"))
+
+        organization_id = UUID(d.pop("organizationId"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("createdAt"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updatedAt"))
+
+        type_ = ListNetworksResponse200ItemType1NetworkType5Type(d.pop("type"))
+
+        tag = d.pop("tag")
+
+        policy_id = UUID(d.pop("policyId"))
+
+        def _parse_last_queried_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_queried_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return last_queried_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_queried_at = _parse_last_queried_at(d.pop("lastQueriedAt", UNSET))
+
+        list_networks_response_200_item_type_1_network_type_5 = cls(
+            id=id,
+            name=name,
+            note=note,
+            organization_id=organization_id,
+            created_at=created_at,
+            updated_at=updated_at,
+            type_=type_,
+            tag=tag,
+            policy_id=policy_id,
+            last_queried_at=last_queried_at,
+        )
+
+        return list_networks_response_200_item_type_1_network_type_5

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_network_type_5_type.py

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

flashstart_client/generated/network/models/list_networks_response_200_item_type_1_policies_item.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+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.list_networks_response_200_item_type_1_policies_item_dns_type_0 import (
+        ListNetworksResponse200ItemType1PoliciesItemDnsType0,
+    )
+    from ..models.list_networks_response_200_item_type_1_policies_item_policy import (
+        ListNetworksResponse200ItemType1PoliciesItemPolicy,
+    )
+
+
+T = TypeVar("T", bound="ListNetworksResponse200ItemType1PoliciesItem")
+
+
+@_attrs_define
+class ListNetworksResponse200ItemType1PoliciesItem:
+    """
+    Attributes:
+        id (None | UUID):
+        network_id (UUID):
+        dns (ListNetworksResponse200ItemType1PoliciesItemDnsType0 | None):
+        policy (ListNetworksResponse200ItemType1PoliciesItemPolicy):
+        note (None | str):
+        tag (None | str | Unset):
+    """
+
+    id: None | UUID
+    network_id: UUID
+    dns: ListNetworksResponse200ItemType1PoliciesItemDnsType0 | None
+    policy: ListNetworksResponse200ItemType1PoliciesItemPolicy
+    note: None | str
+    tag: None | str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.list_networks_response_200_item_type_1_policies_item_dns_type_0 import (
+            ListNetworksResponse200ItemType1PoliciesItemDnsType0,
+        )
+
+        id: None | str
+        if isinstance(self.id, UUID):
+            id = str(self.id)
+        else:
+            id = self.id
+
+        network_id = str(self.network_id)
+
+        dns: dict[str, Any] | None
+        if isinstance(self.dns, ListNetworksResponse200ItemType1PoliciesItemDnsType0):
+            dns = self.dns.to_dict()
+        else:
+            dns = self.dns
+
+        policy = self.policy.to_dict()
+
+        note: None | str
+        note = self.note
+
+        tag: None | str | Unset
+        if isinstance(self.tag, Unset):
+            tag = UNSET
+        else:
+            tag = self.tag
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "networkId": network_id,
+                "dns": dns,
+                "policy": policy,
+                "note": note,
+            }
+        )
+        if tag is not UNSET:
+            field_dict["tag"] = tag
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.list_networks_response_200_item_type_1_policies_item_dns_type_0 import (
+            ListNetworksResponse200ItemType1PoliciesItemDnsType0,
+        )
+        from ..models.list_networks_response_200_item_type_1_policies_item_policy import (
+            ListNetworksResponse200ItemType1PoliciesItemPolicy,
+        )
+
+        d = dict(src_dict)
+
+        def _parse_id(data: object) -> None | UUID:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                id_type_0 = UUID(data)
+
+                return id_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | UUID, data)
+
+        id = _parse_id(d.pop("id"))
+
+        network_id = UUID(d.pop("networkId"))
+
+        def _parse_dns(
+            data: object,
+        ) -> ListNetworksResponse200ItemType1PoliciesItemDnsType0 | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                dns_type_0 = (
+                    ListNetworksResponse200ItemType1PoliciesItemDnsType0.from_dict(data)
+                )
+
+                return dns_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(
+                ListNetworksResponse200ItemType1PoliciesItemDnsType0 | None, data
+            )
+
+        dns = _parse_dns(d.pop("dns"))
+
+        policy = ListNetworksResponse200ItemType1PoliciesItemPolicy.from_dict(
+            d.pop("policy")
+        )
+
+        def _parse_note(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        note = _parse_note(d.pop("note"))
+
+        def _parse_tag(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        tag = _parse_tag(d.pop("tag", UNSET))
+
+        list_networks_response_200_item_type_1_policies_item = cls(
+            id=id,
+            network_id=network_id,
+            dns=dns,
+            policy=policy,
+            note=note,
+            tag=tag,
+        )
+
+        return list_networks_response_200_item_type_1_policies_item