flashstart-client 9.0.2__py3-none-any.whl

flashstart_client/generated/protection/models/list_blocked_malware_categories_response_200_item_time_blocks_item.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="ListBlockedMalwareCategoriesResponse200ItemTimeBlocksItem")
+
+
+@_attrs_define
+class ListBlockedMalwareCategoriesResponse200ItemTimeBlocksItem:
+    """
+    Attributes:
+        day (int):
+        from_ (datetime.datetime):
+        to (datetime.datetime):
+        id (UUID):
+    """
+
+    day: int
+    from_: datetime.datetime
+    to: datetime.datetime
+    id: UUID
+
+    def to_dict(self) -> dict[str, Any]:
+        day = self.day
+
+        from_ = self.from_.isoformat()
+
+        to = self.to.isoformat()
+
+        id = str(self.id)
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "day": day,
+                "from": from_,
+                "to": to,
+                "id": id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        day = d.pop("day")
+
+        from_ = datetime.datetime.fromisoformat(d.pop("from"))
+
+        to = datetime.datetime.fromisoformat(d.pop("to"))
+
+        id = UUID(d.pop("id"))
+
+        list_blocked_malware_categories_response_200_item_time_blocks_item = cls(
+            day=day,
+            from_=from_,
+            to=to,
+            id=id,
+        )
+
+        return list_blocked_malware_categories_response_200_item_time_blocks_item

flashstart_client/generated/protection/models/list_blocked_tlds_response_200_item.py

@@ -0,0 +1,67 @@
+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
+
+T = TypeVar("T", bound="ListBlockedTldsResponse200Item")
+
+
+@_attrs_define
+class ListBlockedTldsResponse200Item:
+    """
+    Attributes:
+        id (UUID):
+        tld (str):
+        policy_id (UUID):
+        tld_id (UUID):
+    """
+
+    id: UUID
+    tld: str
+    policy_id: UUID
+    tld_id: UUID
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        tld = self.tld
+
+        policy_id = str(self.policy_id)
+
+        tld_id = str(self.tld_id)
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "tld": tld,
+                "policyId": policy_id,
+                "tldId": tld_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        tld = d.pop("tld")
+
+        policy_id = UUID(d.pop("policyId"))
+
+        tld_id = UUID(d.pop("tldId"))
+
+        list_blocked_tlds_response_200_item = cls(
+            id=id,
+            tld=tld,
+            policy_id=policy_id,
+            tld_id=tld_id,
+        )
+
+        return list_blocked_tlds_response_200_item

flashstart_client/generated/protection/models/list_categories_response_200_item.py

@@ -0,0 +1,67 @@
+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
+
+T = TypeVar("T", bound="ListCategoriesResponse200Item")
+
+
+@_attrs_define
+class ListCategoriesResponse200Item:
+    """
+    Attributes:
+        code (str):
+        id (UUID):
+        macro_category_id (UUID):
+        name (str):
+    """
+
+    code: str
+    id: UUID
+    macro_category_id: UUID
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        id = str(self.id)
+
+        macro_category_id = str(self.macro_category_id)
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "code": code,
+                "id": id,
+                "macroCategoryId": macro_category_id,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        id = UUID(d.pop("id"))
+
+        macro_category_id = UUID(d.pop("macroCategoryId"))
+
+        name = d.pop("name")
+
+        list_categories_response_200_item = cls(
+            code=code,
+            id=id,
+            macro_category_id=macro_category_id,
+            name=name,
+        )
+
+        return list_categories_response_200_item

flashstart_client/generated/protection/models/list_category_macros_response_200_item.py

@@ -0,0 +1,93 @@
+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 ..models.list_category_macros_response_200_item_protection_module import (
+    ListCategoryMacrosResponse200ItemProtectionModule,
+)
+
+if TYPE_CHECKING:
+    from ..models.list_category_macros_response_200_item_categories_item import (
+        ListCategoryMacrosResponse200ItemCategoriesItem,
+    )
+
+
+T = TypeVar("T", bound="ListCategoryMacrosResponse200Item")
+
+
+@_attrs_define
+class ListCategoryMacrosResponse200Item:
+    """
+    Attributes:
+        id (UUID):
+        name (str):
+        protection_module (ListCategoryMacrosResponse200ItemProtectionModule):
+        categories (list[ListCategoryMacrosResponse200ItemCategoriesItem]):
+    """
+
+    id: UUID
+    name: str
+    protection_module: ListCategoryMacrosResponse200ItemProtectionModule
+    categories: list[ListCategoryMacrosResponse200ItemCategoriesItem]
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        name = self.name
+
+        protection_module = self.protection_module.value
+
+        categories = []
+        for categories_item_data in self.categories:
+            categories_item = categories_item_data.to_dict()
+            categories.append(categories_item)
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "protectionModule": protection_module,
+                "categories": categories,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.list_category_macros_response_200_item_categories_item import (
+            ListCategoryMacrosResponse200ItemCategoriesItem,
+        )
+
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        protection_module = ListCategoryMacrosResponse200ItemProtectionModule(
+            d.pop("protectionModule")
+        )
+
+        categories = []
+        _categories = d.pop("categories")
+        for categories_item_data in _categories:
+            categories_item = ListCategoryMacrosResponse200ItemCategoriesItem.from_dict(
+                categories_item_data
+            )
+
+            categories.append(categories_item)
+
+        list_category_macros_response_200_item = cls(
+            id=id,
+            name=name,
+            protection_module=protection_module,
+            categories=categories,
+        )
+
+        return list_category_macros_response_200_item

flashstart_client/generated/protection/models/list_category_macros_response_200_item_categories_item.py

@@ -0,0 +1,67 @@
+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
+
+T = TypeVar("T", bound="ListCategoryMacrosResponse200ItemCategoriesItem")
+
+
+@_attrs_define
+class ListCategoryMacrosResponse200ItemCategoriesItem:
+    """
+    Attributes:
+        code (str):
+        id (UUID):
+        macro_category_id (UUID):
+        name (str):
+    """
+
+    code: str
+    id: UUID
+    macro_category_id: UUID
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        id = str(self.id)
+
+        macro_category_id = str(self.macro_category_id)
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "code": code,
+                "id": id,
+                "macroCategoryId": macro_category_id,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        id = UUID(d.pop("id"))
+
+        macro_category_id = UUID(d.pop("macroCategoryId"))
+
+        name = d.pop("name")
+
+        list_category_macros_response_200_item_categories_item = cls(
+            code=code,
+            id=id,
+            macro_category_id=macro_category_id,
+            name=name,
+        )
+
+        return list_category_macros_response_200_item_categories_item

flashstart_client/generated/protection/models/list_category_macros_response_200_item_protection_module.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class ListCategoryMacrosResponse200ItemProtectionModule(StrEnum):
+    APP_BLOCKER = "app_blocker"
+    BETA_LIST = "beta_list"
+    CONTENT_FILTER = "content_filter"
+    MALWARE_PROTECTION = "malware_protection"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/protection/models/list_continents_response_200_item.py

@@ -0,0 +1,87 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.list_continents_response_200_item_countries_item import (
+        ListContinentsResponse200ItemCountriesItem,
+    )
+
+
+T = TypeVar("T", bound="ListContinentsResponse200Item")
+
+
+@_attrs_define
+class ListContinentsResponse200Item:
+    """
+    Attributes:
+        code (str):
+        id (UUID):
+        name (str):
+        countries (list[ListContinentsResponse200ItemCountriesItem]):
+    """
+
+    code: str
+    id: UUID
+    name: str
+    countries: list[ListContinentsResponse200ItemCountriesItem]
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        id = str(self.id)
+
+        name = self.name
+
+        countries = []
+        for countries_item_data in self.countries:
+            countries_item = countries_item_data.to_dict()
+            countries.append(countries_item)
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "code": code,
+                "id": id,
+                "name": name,
+                "countries": countries,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.list_continents_response_200_item_countries_item import (
+            ListContinentsResponse200ItemCountriesItem,
+        )
+
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        countries = []
+        _countries = d.pop("countries")
+        for countries_item_data in _countries:
+            countries_item = ListContinentsResponse200ItemCountriesItem.from_dict(
+                countries_item_data
+            )
+
+            countries.append(countries_item)
+
+        list_continents_response_200_item = cls(
+            code=code,
+            id=id,
+            name=name,
+            countries=countries,
+        )
+
+        return list_continents_response_200_item

flashstart_client/generated/protection/models/list_continents_response_200_item_countries_item.py

@@ -0,0 +1,67 @@
+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
+
+T = TypeVar("T", bound="ListContinentsResponse200ItemCountriesItem")
+
+
+@_attrs_define
+class ListContinentsResponse200ItemCountriesItem:
+    """
+    Attributes:
+        code (str):
+        continent_id (UUID):
+        id (UUID):
+        name (str):
+    """
+
+    code: str
+    continent_id: UUID
+    id: UUID
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        continent_id = str(self.continent_id)
+
+        id = str(self.id)
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "code": code,
+                "continentId": continent_id,
+                "id": id,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        continent_id = UUID(d.pop("continentId"))
+
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        list_continents_response_200_item_countries_item = cls(
+            code=code,
+            continent_id=continent_id,
+            id=id,
+            name=name,
+        )
+
+        return list_continents_response_200_item_countries_item

flashstart_client/generated/protection/models/list_countries_response_200_item.py

@@ -0,0 +1,67 @@
+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
+
+T = TypeVar("T", bound="ListCountriesResponse200Item")
+
+
+@_attrs_define
+class ListCountriesResponse200Item:
+    """
+    Attributes:
+        code (str):
+        continent_id (UUID):
+        id (UUID):
+        name (str):
+    """
+
+    code: str
+    continent_id: UUID
+    id: UUID
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        continent_id = str(self.continent_id)
+
+        id = str(self.id)
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "code": code,
+                "continentId": continent_id,
+                "id": id,
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        continent_id = UUID(d.pop("continentId"))
+
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        list_countries_response_200_item = cls(
+            code=code,
+            continent_id=continent_id,
+            id=id,
+            name=name,
+        )
+
+        return list_countries_response_200_item

flashstart_client/generated/protection/models/list_exception_group_domains_response_200_item.py

@@ -0,0 +1,73 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ListExceptionGroupDomainsResponse200Item")
+
+
+@_attrs_define
+class ListExceptionGroupDomainsResponse200Item:
+    """
+    Attributes:
+        id (UUID):
+        name (str):
+        note (None | str | Unset):
+    """
+
+    id: UUID
+    name: str
+    note: None | str | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        name = self.name
+
+        note: None | str | Unset
+        if isinstance(self.note, Unset):
+            note = UNSET
+        else:
+            note = self.note
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+            }
+        )
+        if note is not UNSET:
+            field_dict["note"] = note
+
+        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 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        note = _parse_note(d.pop("note", UNSET))
+
+        list_exception_group_domains_response_200_item = cls(
+            id=id,
+            name=name,
+            note=note,
+        )
+
+        return list_exception_group_domains_response_200_item

flashstart_client/generated/protection/models/list_exception_groups_include_associated_policies.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class ListExceptionGroupsIncludeAssociatedPolicies(StrEnum):
+    FALSE = "false"
+    TRUE = "true"
+
+    def __str__(self) -> str:
+        return str(self.value)