proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/paginated_webhook_list.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.webhook_list import WebhookList
+
+
+T = TypeVar("T", bound="PaginatedWebhookList")
+
+
+@_attrs_define
+class PaginatedWebhookList:
+    count: int
+    results: list[WebhookList]
+    next_: None | str | Unset = UNSET
+    previous: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.webhook_list import WebhookList
+
+        count = self.count
+
+        results = []
+        for results_item_data in self.results:
+            results_item = results_item_data.to_dict()
+            results.append(results_item)
+
+        next_: None | str | Unset
+        if isinstance(self.next_, Unset):
+            next_ = UNSET
+        else:
+            next_ = self.next_
+
+        previous: None | str | Unset
+        if isinstance(self.previous, Unset):
+            previous = UNSET
+        else:
+            previous = self.previous
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "count": count,
+                "results": results,
+            }
+        )
+        if next_ is not UNSET:
+            field_dict["next"] = next_
+        if previous is not UNSET:
+            field_dict["previous"] = previous
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.webhook_list import WebhookList
+
+        d = dict(src_dict)
+        count = d.pop("count")
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = WebhookList.from_dict(results_item_data)
+
+            results.append(results_item)
+
+        def _parse_next_(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        next_ = _parse_next_(d.pop("next", UNSET))
+
+        def _parse_previous(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        previous = _parse_previous(d.pop("previous", UNSET))
+
+        paginated_webhook_list = cls(
+            count=count,
+            results=results,
+            next_=next_,
+            previous=previous,
+        )
+
+        paginated_webhook_list.additional_properties = d
+        return paginated_webhook_list
+
+    @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

proxyrequest_sdk/_generated/models/password_recovery_response.py

@@ -0,0 +1,66 @@
+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="PasswordRecoveryResponse")
+
+
+@_attrs_define
+class PasswordRecoveryResponse:
+    message: str
+    email: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        email = self.email
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "message": message,
+                "email": email,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        message = d.pop("message")
+
+        email = d.pop("email")
+
+        password_recovery_response = cls(
+            message=message,
+            email=email,
+        )
+
+        password_recovery_response.additional_properties = d
+        return password_recovery_response
+
+    @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

proxyrequest_sdk/_generated/models/patched_coupon_update_request.py

@@ -0,0 +1,188 @@
+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 ..models.coupon_type_enum import CouponTypeEnum
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+T = TypeVar("T", bound="PatchedCouponUpdateRequest")
+
+
+@_attrs_define
+class PatchedCouponUpdateRequest:
+    value: int | Unset = UNSET
+    """ Arbitrary coupon value """
+    code: str | Unset = UNSET
+    """ Coupon code cannot be changed if already set """
+    is_multi_use: bool | Unset = UNSET
+    """ If true, coupon can be used multiple times. """
+    is_available_to_one_time: bool | Unset = UNSET
+    """ If true, coupon can not be used for one-time package tiers. """
+    marketer: None | Unset | UUID = UNSET
+    """ The marketer who owns this coupon. Required if is_marketer is true. """
+    type_: CouponTypeEnum | Unset = UNSET
+    """ * `free_data` - Free Data * `monetary` - Money * `percentage` - Percentage """
+    limit: int | Unset = UNSET
+    """ Number of times coupon can be used """
+    valid_until: datetime.datetime | None | Unset = UNSET
+    """ Leave empty for coupons that never expire """
+    packages: list[str] | Unset = UNSET
+    """ Select packages for which this coupon is available. If no packages are selected, the coupon is available to
+    all packages. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = self.value
+
+        code = self.code
+
+        is_multi_use = self.is_multi_use
+
+        is_available_to_one_time = self.is_available_to_one_time
+
+        marketer: None | str | Unset
+        if isinstance(self.marketer, Unset):
+            marketer = UNSET
+        elif isinstance(self.marketer, UUID):
+            marketer = str(self.marketer)
+        else:
+            marketer = self.marketer
+
+        type_: str | Unset = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        limit = self.limit
+
+        valid_until: None | str | Unset
+        if isinstance(self.valid_until, Unset):
+            valid_until = UNSET
+        elif isinstance(self.valid_until, datetime.datetime):
+            valid_until = self.valid_until.isoformat()
+        else:
+            valid_until = self.valid_until
+
+        packages: list[str] | Unset = UNSET
+        if not isinstance(self.packages, Unset):
+            packages = self.packages
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if value is not UNSET:
+            field_dict["value"] = value
+        if code is not UNSET:
+            field_dict["code"] = code
+        if is_multi_use is not UNSET:
+            field_dict["is_multi_use"] = is_multi_use
+        if is_available_to_one_time is not UNSET:
+            field_dict["is_available_to_one_time"] = is_available_to_one_time
+        if marketer is not UNSET:
+            field_dict["marketer"] = marketer
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if valid_until is not UNSET:
+            field_dict["valid_until"] = valid_until
+        if packages is not UNSET:
+            field_dict["packages"] = packages
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        value = d.pop("value", UNSET)
+
+        code = d.pop("code", UNSET)
+
+        is_multi_use = d.pop("is_multi_use", UNSET)
+
+        is_available_to_one_time = d.pop("is_available_to_one_time", UNSET)
+
+        def _parse_marketer(data: object) -> None | Unset | UUID:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                marketer_type_0 = UUID(data)
+
+                return marketer_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        marketer = _parse_marketer(d.pop("marketer", UNSET))
+
+        _type_ = d.pop("type", UNSET)
+        type_: CouponTypeEnum | Unset
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = CouponTypeEnum(_type_)
+
+        limit = d.pop("limit", UNSET)
+
+        def _parse_valid_until(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()
+                valid_until_type_0 = datetime.datetime.fromisoformat(data)
+
+                return valid_until_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        valid_until = _parse_valid_until(d.pop("valid_until", UNSET))
+
+        packages = cast(list[str], d.pop("packages", UNSET))
+
+        patched_coupon_update_request = cls(
+            value=value,
+            code=code,
+            is_multi_use=is_multi_use,
+            is_available_to_one_time=is_available_to_one_time,
+            marketer=marketer,
+            type_=type_,
+            limit=limit,
+            valid_until=valid_until,
+            packages=packages,
+        )
+
+        patched_coupon_update_request.additional_properties = d
+        return patched_coupon_update_request
+
+    @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

proxyrequest_sdk/_generated/models/patched_order_auto_renewal_request.py

@@ -0,0 +1,67 @@
+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="PatchedOrderAutoRenewalRequest")
+
+
+@_attrs_define
+class PatchedOrderAutoRenewalRequest:
+    auto_renewal_percentage: int | Unset = UNSET
+    auto_renewal_data: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        auto_renewal_percentage = self.auto_renewal_percentage
+
+        auto_renewal_data = self.auto_renewal_data
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if auto_renewal_percentage is not UNSET:
+            field_dict["auto_renewal_percentage"] = auto_renewal_percentage
+        if auto_renewal_data is not UNSET:
+            field_dict["auto_renewal_data"] = auto_renewal_data
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        auto_renewal_percentage = d.pop("auto_renewal_percentage", UNSET)
+
+        auto_renewal_data = d.pop("auto_renewal_data", UNSET)
+
+        patched_order_auto_renewal_request = cls(
+            auto_renewal_percentage=auto_renewal_percentage,
+            auto_renewal_data=auto_renewal_data,
+        )
+
+        patched_order_auto_renewal_request.additional_properties = d
+        return patched_order_auto_renewal_request
+
+    @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

proxyrequest_sdk/_generated/models/patched_profile_update_request.py

@@ -0,0 +1,207 @@
+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
+
+
+T = TypeVar("T", bound="PatchedProfileUpdateRequest")
+
+
+@_attrs_define
+class PatchedProfileUpdateRequest:
+    """for updating user profile information with comprehensive validation. Handles personal profile data, company
+    information, security settings, and password changes. All fields are optional, but at least one field must be
+    provided for the update to be valid. Includes validation for domain patterns with support for wildcards
+    (*.example.com) and subdomains.
+
+    """
+
+    email: str | Unset = UNSET
+    first_name: str | Unset = UNSET
+    last_name: str | Unset = UNSET
+    country: str | Unset = UNSET
+    state: str | Unset = UNSET
+    city: str | Unset = UNSET
+    address: str | Unset = UNSET
+    zip_: str | Unset = UNSET
+    company_name: str | Unset = UNSET
+    company_country: str | Unset = UNSET
+    company_city: str | Unset = UNSET
+    company_address: str | Unset = UNSET
+    company_postal_code: str | Unset = UNSET
+    company_vat_number: str | Unset = UNSET
+    blocked_domains: list[str] | Unset = UNSET
+    allowed_ips: list[str] | Unset = UNSET
+    new_password: str | Unset = UNSET
+    old_password: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        email = self.email
+
+        first_name = self.first_name
+
+        last_name = self.last_name
+
+        country = self.country
+
+        state = self.state
+
+        city = self.city
+
+        address = self.address
+
+        zip_ = self.zip_
+
+        company_name = self.company_name
+
+        company_country = self.company_country
+
+        company_city = self.company_city
+
+        company_address = self.company_address
+
+        company_postal_code = self.company_postal_code
+
+        company_vat_number = self.company_vat_number
+
+        blocked_domains: list[str] | Unset = UNSET
+        if not isinstance(self.blocked_domains, Unset):
+            blocked_domains = self.blocked_domains
+
+        allowed_ips: list[str] | Unset = UNSET
+        if not isinstance(self.allowed_ips, Unset):
+            allowed_ips = self.allowed_ips
+
+        new_password = self.new_password
+
+        old_password = self.old_password
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if email is not UNSET:
+            field_dict["email"] = email
+        if first_name is not UNSET:
+            field_dict["first_name"] = first_name
+        if last_name is not UNSET:
+            field_dict["last_name"] = last_name
+        if country is not UNSET:
+            field_dict["country"] = country
+        if state is not UNSET:
+            field_dict["state"] = state
+        if city is not UNSET:
+            field_dict["city"] = city
+        if address is not UNSET:
+            field_dict["address"] = address
+        if zip_ is not UNSET:
+            field_dict["zip"] = zip_
+        if company_name is not UNSET:
+            field_dict["company_name"] = company_name
+        if company_country is not UNSET:
+            field_dict["company_country"] = company_country
+        if company_city is not UNSET:
+            field_dict["company_city"] = company_city
+        if company_address is not UNSET:
+            field_dict["company_address"] = company_address
+        if company_postal_code is not UNSET:
+            field_dict["company_postal_code"] = company_postal_code
+        if company_vat_number is not UNSET:
+            field_dict["company_vat_number"] = company_vat_number
+        if blocked_domains is not UNSET:
+            field_dict["blocked_domains"] = blocked_domains
+        if allowed_ips is not UNSET:
+            field_dict["allowed_ips"] = allowed_ips
+        if new_password is not UNSET:
+            field_dict["new_password"] = new_password
+        if old_password is not UNSET:
+            field_dict["old_password"] = old_password
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        email = d.pop("email", UNSET)
+
+        first_name = d.pop("first_name", UNSET)
+
+        last_name = d.pop("last_name", UNSET)
+
+        country = d.pop("country", UNSET)
+
+        state = d.pop("state", UNSET)
+
+        city = d.pop("city", UNSET)
+
+        address = d.pop("address", UNSET)
+
+        zip_ = d.pop("zip", UNSET)
+
+        company_name = d.pop("company_name", UNSET)
+
+        company_country = d.pop("company_country", UNSET)
+
+        company_city = d.pop("company_city", UNSET)
+
+        company_address = d.pop("company_address", UNSET)
+
+        company_postal_code = d.pop("company_postal_code", UNSET)
+
+        company_vat_number = d.pop("company_vat_number", UNSET)
+
+        blocked_domains = cast(list[str], d.pop("blocked_domains", UNSET))
+
+        allowed_ips = cast(list[str], d.pop("allowed_ips", UNSET))
+
+        new_password = d.pop("new_password", UNSET)
+
+        old_password = d.pop("old_password", UNSET)
+
+        patched_profile_update_request = cls(
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            country=country,
+            state=state,
+            city=city,
+            address=address,
+            zip_=zip_,
+            company_name=company_name,
+            company_country=company_country,
+            company_city=company_city,
+            company_address=company_address,
+            company_postal_code=company_postal_code,
+            company_vat_number=company_vat_number,
+            blocked_domains=blocked_domains,
+            allowed_ips=allowed_ips,
+            new_password=new_password,
+            old_password=old_password,
+        )
+
+        patched_profile_update_request.additional_properties = d
+        return patched_profile_update_request
+
+    @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