kalir-python 0.1.0__py3-none-any.whl

kalir/models/list_ransomware_victims_response_200_victims_item.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="ListRansomwareVictimsResponse200VictimsItem")
+
+
+
+@_attrs_define
+class ListRansomwareVictimsResponse200VictimsItem:
+    
+
+    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: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        list_ransomware_victims_response_200_victims_item = cls(
+        )
+
+
+        list_ransomware_victims_response_200_victims_item.additional_properties = d
+        return list_ransomware_victims_response_200_victims_item
+
+    @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

kalir/models/list_reports_response_200.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.report import Report
+
+
+
+
+
+T = TypeVar("T", bound="ListReportsResponse200")
+
+
+
+@_attrs_define
+class ListReportsResponse200:
+    """ 
+        Attributes:
+            reports (list[Report] | Unset):
+            total (int | Unset):
+     """
+
+    reports: list[Report] | Unset = UNSET
+    total: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.report import Report # noqa: PLC0415
+        reports: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.reports, Unset):
+            reports = []
+            for reports_item_data in self.reports:
+                reports_item = reports_item_data.to_dict()
+                reports.append(reports_item)
+
+
+
+        total = self.total
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if reports is not UNSET:
+            field_dict["reports"] = reports
+        if total is not UNSET:
+            field_dict["total"] = total
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.report import Report # noqa: PLC0415
+        d = dict(src_dict)
+        _reports = d.pop("reports", UNSET)
+        reports: list[Report] | Unset = UNSET
+        if _reports is not UNSET:
+            reports = []
+            for reports_item_data in _reports:
+                reports_item = Report.from_dict(reports_item_data)
+
+
+
+                reports.append(reports_item)
+
+
+        total = d.pop("total", UNSET)
+
+        list_reports_response_200 = cls(
+            reports=reports,
+            total=total,
+        )
+
+
+        list_reports_response_200.additional_properties = d
+        return list_reports_response_200
+
+    @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

kalir/models/list_rules_response_200.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.rule import Rule
+
+
+
+
+
+T = TypeVar("T", bound="ListRulesResponse200")
+
+
+
+@_attrs_define
+class ListRulesResponse200:
+    """ 
+        Attributes:
+            rules (list[Rule] | Unset):
+     """
+
+    rules: list[Rule] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.rule import Rule # noqa: PLC0415
+        rules: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.rules, Unset):
+            rules = []
+            for rules_item_data in self.rules:
+                rules_item = rules_item_data.to_dict()
+                rules.append(rules_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if rules is not UNSET:
+            field_dict["rules"] = rules
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.rule import Rule # noqa: PLC0415
+        d = dict(src_dict)
+        _rules = d.pop("rules", UNSET)
+        rules: list[Rule] | Unset = UNSET
+        if _rules is not UNSET:
+            rules = []
+            for rules_item_data in _rules:
+                rules_item = Rule.from_dict(rules_item_data)
+
+
+
+                rules.append(rules_item)
+
+
+        list_rules_response_200 = cls(
+            rules=rules,
+        )
+
+
+        list_rules_response_200.additional_properties = d
+        return list_rules_response_200
+
+    @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

kalir/models/list_takedowns_response_200.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.takedown import Takedown
+
+
+
+
+
+T = TypeVar("T", bound="ListTakedownsResponse200")
+
+
+
+@_attrs_define
+class ListTakedownsResponse200:
+    """ 
+        Attributes:
+            takedowns (list[Takedown] | Unset):
+            total (int | Unset):
+     """
+
+    takedowns: list[Takedown] | Unset = UNSET
+    total: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.takedown import Takedown # noqa: PLC0415
+        takedowns: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.takedowns, Unset):
+            takedowns = []
+            for takedowns_item_data in self.takedowns:
+                takedowns_item = takedowns_item_data.to_dict()
+                takedowns.append(takedowns_item)
+
+
+
+        total = self.total
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if takedowns is not UNSET:
+            field_dict["takedowns"] = takedowns
+        if total is not UNSET:
+            field_dict["total"] = total
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.takedown import Takedown # noqa: PLC0415
+        d = dict(src_dict)
+        _takedowns = d.pop("takedowns", UNSET)
+        takedowns: list[Takedown] | Unset = UNSET
+        if _takedowns is not UNSET:
+            takedowns = []
+            for takedowns_item_data in _takedowns:
+                takedowns_item = Takedown.from_dict(takedowns_item_data)
+
+
+
+                takedowns.append(takedowns_item)
+
+
+        total = d.pop("total", UNSET)
+
+        list_takedowns_response_200 = cls(
+            takedowns=takedowns,
+            total=total,
+        )
+
+
+        list_takedowns_response_200.additional_properties = d
+        return list_takedowns_response_200
+
+    @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

kalir/models/list_webhook_deliveries_response_200.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.pagination import Pagination
+  from ..models.webhook_delivery import WebhookDelivery
+
+
+
+
+
+T = TypeVar("T", bound="ListWebhookDeliveriesResponse200")
+
+
+
+@_attrs_define
+class ListWebhookDeliveriesResponse200:
+    """ 
+        Attributes:
+            data (list[WebhookDelivery] | Unset):
+            pagination (Pagination | Unset):
+     """
+
+    data: list[WebhookDelivery] | Unset = UNSET
+    pagination: Pagination | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.pagination import Pagination # noqa: PLC0415
+        from ..models.webhook_delivery import WebhookDelivery # noqa: PLC0415
+        data: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = []
+            for data_item_data in self.data:
+                data_item = data_item_data.to_dict()
+                data.append(data_item)
+
+
+
+        pagination: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.pagination, Unset):
+            pagination = self.pagination.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+        if pagination is not UNSET:
+            field_dict["pagination"] = pagination
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.pagination import Pagination # noqa: PLC0415
+        from ..models.webhook_delivery import WebhookDelivery # noqa: PLC0415
+        d = dict(src_dict)
+        _data = d.pop("data", UNSET)
+        data: list[WebhookDelivery] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = WebhookDelivery.from_dict(data_item_data)
+
+
+
+                data.append(data_item)
+
+
+        _pagination = d.pop("pagination", UNSET)
+        pagination: Pagination | Unset
+        if isinstance(_pagination,  Unset):
+            pagination = UNSET
+        else:
+            pagination = Pagination.from_dict(_pagination)
+
+
+
+
+        list_webhook_deliveries_response_200 = cls(
+            data=data,
+            pagination=pagination,
+        )
+
+
+        list_webhook_deliveries_response_200.additional_properties = d
+        return list_webhook_deliveries_response_200
+
+    @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

kalir/models/list_webhook_event_types_response_200.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.list_webhook_event_types_response_200_data_item import ListWebhookEventTypesResponse200DataItem
+
+
+
+
+
+T = TypeVar("T", bound="ListWebhookEventTypesResponse200")
+
+
+
+@_attrs_define
+class ListWebhookEventTypesResponse200:
+    """ 
+        Attributes:
+            data (list[ListWebhookEventTypesResponse200DataItem] | Unset):
+     """
+
+    data: list[ListWebhookEventTypesResponse200DataItem] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.list_webhook_event_types_response_200_data_item import ListWebhookEventTypesResponse200DataItem # noqa: PLC0415
+        data: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = []
+            for data_item_data in self.data:
+                data_item = data_item_data.to_dict()
+                data.append(data_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.list_webhook_event_types_response_200_data_item import ListWebhookEventTypesResponse200DataItem # noqa: PLC0415
+        d = dict(src_dict)
+        _data = d.pop("data", UNSET)
+        data: list[ListWebhookEventTypesResponse200DataItem] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = ListWebhookEventTypesResponse200DataItem.from_dict(data_item_data)
+
+
+
+                data.append(data_item)
+
+
+        list_webhook_event_types_response_200 = cls(
+            data=data,
+        )
+
+
+        list_webhook_event_types_response_200.additional_properties = d
+        return list_webhook_event_types_response_200
+
+    @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

kalir/models/list_webhook_event_types_response_200_data_item.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+T = TypeVar("T", bound="ListWebhookEventTypesResponse200DataItem")
+
+
+
+@_attrs_define
+class ListWebhookEventTypesResponse200DataItem:
+    """ 
+        Attributes:
+            type_ (str | Unset):
+            description (str | Unset):
+     """
+
+    type_: str | Unset = UNSET
+    description: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        description = self.description
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = d.pop("type", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        list_webhook_event_types_response_200_data_item = cls(
+            type_=type_,
+            description=description,
+        )
+
+
+        list_webhook_event_types_response_200_data_item.additional_properties = d
+        return list_webhook_event_types_response_200_data_item
+
+    @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