wazzapi 0.3.0__tar.gz → 0.5.0__tar.gz

{wazzapi-0.3.0 → wazzapi-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wazzapi
-Version: 0.3.0
+Version: 0.5.0
 Summary: Typed Python SDK for WazzAPI
 Project-URL: API, https://api.wazzapi.com
 Project-URL: Homepage, https://github.com/wazzapihq/wazzapi-py
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: cryptography<45.0,>=44.0
+Requires-Dist: cryptography<50.0,>=46.0
 Requires-Dist: httpx<1.0,>=0.28
 Requires-Dist: pydantic<3.0,>=2.11
 Description-Content-Type: text/markdown

{wazzapi-0.3.0 → wazzapi-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wazzapi"
-version = "0.3.0"
+version = "0.5.0"
 description = "Typed Python SDK for WazzAPI"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
@@ -19,7 +19,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "cryptography>=44.0,<45.0",
+  "cryptography>=46.0,<50.0",
   "httpx>=0.28,<1.0",
   "pydantic>=2.11,<3.0",
 ]
@@ -30,8 +30,8 @@ Homepage = "https://github.com/wazzapihq/wazzapi-py"
 
 [dependency-groups]
 dev = [
-  "pytest>=8.3,<9.0",
-  "pytest-asyncio>=0.25,<1.0",
+  "pytest>=9.0,<10.0",
+  "pytest-asyncio>=1.0,<2.0",
   "twine>=6.1,<7.0",
 ]
 

{wazzapi-0.3.0 → wazzapi-0.5.0}/tests/smoke_test.py

@@ -10,7 +10,7 @@ from wazzapi import (
 
 
 def main() -> None:
-    assert __version__ == "0.3.0"
+    assert __version__ == "0.5.0"
 
     client = WazzapiClient(api_key="smoke-test-token")
     try:

{wazzapi-0.3.0 → wazzapi-0.5.0}/tests/test_resources.py

@@ -213,3 +213,70 @@ def test_sync_status_returns_typed_list() -> None:
     assert len(result) == 1
     assert isinstance(result[0], models.ContactSyncStatusResponse)
     assert result[0].account_id == "wa_123"
+
+
+def test_get_profile_picture_returns_metadata() -> None:
+    seen: dict[str, object] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["method"] = request.method
+        seen["path"] = request.url.path
+        seen["query"] = dict(request.url.params)
+        return httpx.Response(
+            200,
+            json={
+                "contact_id": "contact_1",
+                "phone_number": "+6281234567890",
+                "url": "https://cdn.example.com/pic.jpg",
+                "picture_id": "pic_1",
+                "picture_type": "image",
+                "preview": True,
+                "whatsapp_account_id": "wa_1",
+                "cached": False,
+            },
+        )
+
+    transport = httpx.MockTransport(handler)
+    with WazzapiClient(base_url="https://api.example.com", transport=transport) as client:
+        result = client.contacts.get_profile_picture(
+            "contact_1",
+            whatsapp_account_id="wa_1",
+            preview=True,
+        )
+
+    assert seen["method"] == "GET"
+    assert seen["path"] == "/api/v1/contacts/contact_1/profile-picture"
+    assert seen["query"] == {"whatsapp_account_id": "wa_1", "preview": "true"}
+    assert isinstance(result, models.ContactProfilePictureResponse)
+    assert result.url == "https://cdn.example.com/pic.jpg"
+    assert result.preview is True
+
+
+def test_get_profile_picture_image_returns_bytes() -> None:
+    seen: dict[str, object] = {}
+    image_bytes = b"\xff\xd8\xff\xe0fake-jpeg"
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["method"] = request.method
+        seen["path"] = request.url.path
+        seen["query"] = dict(request.url.params)
+        return httpx.Response(
+            200,
+            content=image_bytes,
+            headers={"content-type": "image/jpeg"},
+        )
+
+    transport = httpx.MockTransport(handler)
+    with WazzapiClient(base_url="https://api.example.com", transport=transport) as client:
+        result = client.contacts.get_profile_picture_image(
+            "contact_1",
+            proxy=True,
+            preview=False,
+        )
+
+    assert seen["method"] == "GET"
+    assert seen["path"] == "/api/v1/contacts/contact_1/profile-picture/image"
+    assert seen["query"] == {"proxy": "true", "preview": "false"}
+    assert isinstance(result, models.ContactProfilePictureImageResult)
+    assert result.content == image_bytes
+    assert result.content_type == "image/jpeg"

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/__init__.py

@@ -16,7 +16,7 @@ from .webhooks import (
     verify_webhook_signature,
 )
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 
 __all__ = [
     "EVENT_HEADER",

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/client.py

@@ -7,7 +7,16 @@ import httpx
 from pydantic import BaseModel, TypeAdapter
 
 from .errors import WazzapiAPIError
-from .resources import ContactsResource, DevicesResource, GroupsResource, MessagesResource, TemplatesResource
+from .resources import (
+    CampaignsResource,
+    ContactsResource,
+    ConversationsResource,
+    DevicesResource,
+    GroupsResource,
+    MessagesResource,
+    TemplatesResource,
+    WebhookSubscriptionsResource,
+)
 
 DEFAULT_BASE_URL = "https://api.wazzapi.com"
 
@@ -38,11 +47,14 @@ class WazzapiClient:
             transport=transport,
         )
 
+        self.campaigns = CampaignsResource(self)
         self.contacts = ContactsResource(self)
+        self.conversations = ConversationsResource(self)
         self.devices = DevicesResource(self)
         self.groups = GroupsResource(self)
         self.messages = MessagesResource(self)
         self.templates = TemplatesResource(self)
+        self.webhook_subscriptions = WebhookSubscriptionsResource(self)
 
     @staticmethod
     def _build_headers(
@@ -107,6 +119,37 @@ class WazzapiClient:
         payload = response.json()
         return TypeAdapter(response_model).validate_python(payload)
 
+    def _request_bytes(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        response_model: Any | None = None,
+    ) -> Any:
+        """Issue a request and return binary content (follows redirects)."""
+
+        response = self._client.request(
+            method,
+            path,
+            params=self._filter_none(params),
+            follow_redirects=True,
+        )
+
+        if response.status_code >= 400:
+            raise WazzapiAPIError.from_response(response)
+
+        payload = {
+            "content": response.content,
+            "content_type": response.headers.get("content-type"),
+            "final_url": str(response.url) if response.url else None,
+        }
+
+        if response_model is None:
+            return payload
+
+        return TypeAdapter(response_model).validate_python(payload)
+
     @staticmethod
     def _filter_none(data: Mapping[str, Any] | None) -> dict[str, Any] | None:
         if data is None:

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/models/__init__.py

@@ -1,6 +1,10 @@
 from .base import WazzapiModel
+from .campaigns import *
+from .campaigns import __all__ as campaigns_all
 from .contacts import *
 from .contacts import __all__ as contacts_all
+from .conversations import *
+from .conversations import __all__ as conversations_all
 from .devices import *
 from .devices import __all__ as devices_all
 from .groups import *
@@ -11,16 +15,21 @@ from .messages import *
 from .messages import __all__ as messages_all
 from .templates import *
 from .templates import __all__ as templates_all
+from .webhook_subscriptions import *
+from .webhook_subscriptions import __all__ as webhook_subscriptions_all
 from .webhooks import *
 from .webhooks import __all__ as webhooks_all
 
 __all__ = [
 	"WazzapiModel",
+	*campaigns_all,
 	*contacts_all,
+	*conversations_all,
 	*devices_all,
 	*groups_all,
 	*media_all,
 	*messages_all,
 	*templates_all,
+	*webhook_subscriptions_all,
 	*webhooks_all,
 ]

wazzapi-0.5.0/wazzapi/models/campaigns.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from .base import WazzapiModel
+
+
+class CampaignCreateRequest(WazzapiModel):
+    name: str
+    whatsapp_account_id: str
+    recipient_type: str
+    description: str | None = None
+    template_id: str | None = None
+    message_type: str = "text"
+    custom_message: str | None = None
+    message_payload: dict[str, Any] | None = None
+    recipient_group_ids: list[str] | None = None
+    recipient_contact_ids: list[str] | None = None
+    scheduled_for: datetime | None = None
+
+
+class CampaignUpdateRequest(WazzapiModel):
+    name: str | None = None
+    description: str | None = None
+    template_id: str | None = None
+    message_type: str | None = None
+    custom_message: str | None = None
+    message_payload: dict[str, Any] | None = None
+    recipient_type: str | None = None
+    recipient_group_ids: list[str] | None = None
+    recipient_contact_ids: list[str] | None = None
+    scheduled_for: datetime | None = None
+
+
+class CampaignItem(WazzapiModel):
+    id: str
+    name: str
+    status: str
+    recipient_type: str
+    total_recipients: int
+    messages_sent: int
+    messages_delivered: int
+    messages_failed: int
+    whatsapp_account_id: str
+    message_type: str = "text"
+    recipient_contact_ids: list[str] | None = None
+    scheduled_for: str | None = None
+    created_at: str
+
+
+class CampaignListResponse(WazzapiModel):
+    items: list[CampaignItem]
+    total: int
+    limit: int
+    offset: int
+
+
+class CampaignResponse(WazzapiModel):
+    id: str
+    name: str
+    status: str
+    description: str | None = None
+    whatsapp_account_id: str
+    template_id: str | None = None
+    message_type: str = "text"
+    custom_message: str | None = None
+    message_payload: dict[str, Any] | None = None
+    recipient_type: str
+    recipient_group_ids: list[str] | None = None
+    recipient_contact_ids: list[str] | None = None
+    total_recipients: int = 0
+    messages_sent: int = 0
+    messages_delivered: int = 0
+    messages_failed: int = 0
+    scheduled_for: str | None = None
+    created_at: str | None = None
+    updated_at: str | None = None
+
+
+class CampaignActionResponse(WazzapiModel):
+    success: bool
+    campaign_id: str
+    status: str
+
+
+class CampaignExecuteResponse(WazzapiModel):
+    success: bool
+    campaign_id: str
+    status: str
+    total_recipients: int
+    job_id: str | None = None
+
+
+__all__ = [
+    "CampaignActionResponse",
+    "CampaignCreateRequest",
+    "CampaignExecuteResponse",
+    "CampaignItem",
+    "CampaignListResponse",
+    "CampaignResponse",
+    "CampaignUpdateRequest",
+]

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/models/contacts.py

@@ -173,6 +173,27 @@ class ContactUpdateRequest(WazzapiModel):
     is_opted_out: bool | None = None
 
 
+class ContactProfilePictureResponse(WazzapiModel):
+    """Ephemeral WhatsApp profile picture metadata for a contact."""
+
+    contact_id: str
+    phone_number: str
+    url: str
+    picture_id: str | None = None
+    picture_type: str | None = None
+    preview: bool
+    whatsapp_account_id: str
+    cached: bool = False
+
+
+class ContactProfilePictureImageResult(WazzapiModel):
+    """Raw image bytes returned by the profile-picture image endpoint."""
+
+    content: bytes
+    content_type: str | None = None
+    final_url: str | None = None
+
+
 class RemoveFromGroupRequest(WazzapiModel):
     contact_ids: list[str]
 
@@ -193,6 +214,8 @@ __all__ = [
     "ContactGroupUpdateRequest",
     "ContactItem",
     "ContactListResponse",
+    "ContactProfilePictureImageResult",
+    "ContactProfilePictureResponse",
     "ContactResponse",
     "ContactSyncHistoryItem",
     "ContactSyncHistoryResponse",

wazzapi-0.5.0/wazzapi/models/conversations.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from .base import WazzapiModel
+
+
+class ConversationItem(WazzapiModel):
+    id: str
+    whatsapp_account_id: str
+    contact_id: str | None = None
+    phone_number: str
+    status: str
+    assignee_user_id: str | None = None
+    subject: str | None = None
+    last_message_preview: str | None = None
+    last_message_at: datetime | None = None
+    last_inbound_at: datetime | None = None
+    last_outbound_at: datetime | None = None
+    unread_count: int
+    created_at: datetime
+    updated_at: datetime
+
+
+class ConversationListResponse(WazzapiModel):
+    conversations: list[ConversationItem]
+    total: int
+    limit: int
+    offset: int
+
+
+class ConversationUpdateRequest(WazzapiModel):
+    status: str | None = None
+    assignee_user_id: str | None = None
+    clear_assignee: bool = False
+    mark_read: bool = False
+
+
+class ConversationMessageItem(WazzapiModel):
+    id: str
+    direction: str
+    content: str
+    status: str
+    message_type: str
+    phone_number: str
+    whatsapp_message_id: str | None = None
+    created_at: datetime
+    sent_at: datetime | None = None
+    delivered_at: datetime | None = None
+    read_at: datetime | None = None
+
+
+class ConversationMessageListResponse(WazzapiModel):
+    messages: list[ConversationMessageItem]
+    total: int
+    limit: int
+    offset: int
+
+
+class ConversationReplyRequest(WazzapiModel):
+    content: str
+    whatsapp_account_id: str | None = None
+
+
+class ConversationReplyResponse(WazzapiModel):
+    success: bool
+    message_id: str
+    conversation_id: str
+    status: str
+
+
+__all__ = [
+    "ConversationItem",
+    "ConversationListResponse",
+    "ConversationMessageItem",
+    "ConversationMessageListResponse",
+    "ConversationReplyRequest",
+    "ConversationReplyResponse",
+    "ConversationUpdateRequest",
+]

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/models/messages.py

@@ -136,6 +136,9 @@ class SendMessageRequest(WazzapiModel):
     message_type: str = "text"
     media_type: str | None = None
     media_url: str | None = None
+    media_base64: str | None = None
+    filename: str | None = None
+    mimetype: str | None = None
     caption: str | None = None
     latitude: float | None = None
     longitude: float | None = None

wazzapi-0.5.0/wazzapi/models/webhook_subscriptions.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from .base import WazzapiModel
+
+
+class WebhookCreateRequest(WazzapiModel):
+    url: str
+    subscribed_events: list[str]
+    secret: str | None = None
+    description: str | None = None
+
+
+class WebhookUpdateRequest(WazzapiModel):
+    url: str | None = None
+    subscribed_events: list[str] | None = None
+    is_active: bool | None = None
+    description: str | None = None
+
+
+class WebhookResponse(WazzapiModel):
+    id: str
+    url: str
+    secret_prefix: str
+    subscribed_events: list[str]
+    is_active: bool
+    status: str
+    failure_count: int
+    last_success_at: datetime | None = None
+    last_failure_at: datetime | None = None
+    description: str | None = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class WebhookListItem(WazzapiModel):
+    id: str
+    url: str
+    subscribed_events: list[str]
+    is_active: bool
+    status: str
+    failure_count: int
+    last_success_at: datetime | None = None
+    last_failure_at: datetime | None = None
+    description: str | None = None
+    created_at: datetime
+
+
+class WebhookListResponse(WazzapiModel):
+    webhooks: list[WebhookListItem]
+    total: int
+
+
+class WebhookEventListItem(WazzapiModel):
+    id: str
+    event_type: str
+    status: str
+    retry_count: int
+    response_code: int | None = None
+    error_message: str | None = None
+    created_at: datetime
+    delivered_at: datetime | None = None
+
+
+class WebhookEventListResponse(WazzapiModel):
+    events: list[WebhookEventListItem]
+    total: int
+
+
+class PingWebhookResponse(WazzapiModel):
+    success: bool
+    status_code: int | None = None
+    response_time_ms: int | None = None
+    error: str | None = None
+
+
+__all__ = [
+    "PingWebhookResponse",
+    "WebhookCreateRequest",
+    "WebhookEventListItem",
+    "WebhookEventListResponse",
+    "WebhookListItem",
+    "WebhookListResponse",
+    "WebhookResponse",
+    "WebhookUpdateRequest",
+]

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/resources/__init__.py

@@ -1,13 +1,19 @@
+from .campaigns import CampaignsResource
 from .contacts import ContactsResource
+from .conversations import ConversationsResource
 from .devices import DevicesResource
 from .groups import GroupsResource
 from .messages import MessagesResource
 from .templates import TemplatesResource
+from .webhook_subscriptions import WebhookSubscriptionsResource
 
 __all__ = [
+	"CampaignsResource",
 	"ContactsResource",
+	"ConversationsResource",
 	"DevicesResource",
 	"GroupsResource",
 	"MessagesResource",
 	"TemplatesResource",
+	"WebhookSubscriptionsResource",
 ]

wazzapi-0.5.0/wazzapi/resources/campaigns.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .. import models
+from .base import BaseResource
+
+
+class CampaignsResource(BaseResource):
+    def list(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        status: str | None = None,
+    ) -> models.CampaignListResponse:
+        return self._client._request(
+            "GET",
+            "/api/v1/campaigns",
+            params={"limit": limit, "offset": offset, "status": status},
+            response_model=models.CampaignListResponse,
+        )
+
+    def create(
+        self,
+        payload: models.CampaignCreateRequest | dict[str, Any],
+    ) -> models.CampaignResponse:
+        return self._client._request(
+            "POST",
+            "/api/v1/campaigns",
+            json_body=payload,
+            response_model=models.CampaignResponse,
+        )
+
+    def get(self, campaign_id: str) -> models.CampaignResponse:
+        return self._client._request(
+            "GET",
+            f"/api/v1/campaigns/{campaign_id}",
+            response_model=models.CampaignResponse,
+        )
+
+    def update(
+        self,
+        campaign_id: str,
+        payload: models.CampaignUpdateRequest | dict[str, Any],
+    ) -> models.CampaignResponse:
+        return self._client._request(
+            "PATCH",
+            f"/api/v1/campaigns/{campaign_id}",
+            json_body=payload,
+            response_model=models.CampaignResponse,
+        )
+
+    def delete(self, campaign_id: str) -> None:
+        self._client._request("DELETE", f"/api/v1/campaigns/{campaign_id}")
+        return None
+
+    def execute(self, campaign_id: str) -> models.CampaignExecuteResponse:
+        return self._client._request(
+            "POST",
+            f"/api/v1/campaigns/{campaign_id}/execute",
+            response_model=models.CampaignExecuteResponse,
+        )
+
+    def pause(self, campaign_id: str) -> models.CampaignActionResponse:
+        return self._client._request(
+            "POST",
+            f"/api/v1/campaigns/{campaign_id}/pause",
+            response_model=models.CampaignActionResponse,
+        )
+
+    def resume(self, campaign_id: str) -> models.CampaignActionResponse:
+        return self._client._request(
+            "POST",
+            f"/api/v1/campaigns/{campaign_id}/resume",
+            response_model=models.CampaignActionResponse,
+        )
+
+    def cancel(self, campaign_id: str) -> models.CampaignActionResponse:
+        return self._client._request(
+            "POST",
+            f"/api/v1/campaigns/{campaign_id}/cancel",
+            response_model=models.CampaignActionResponse,
+        )
+
+
+__all__ = ["CampaignsResource"]

{wazzapi-0.3.0 → wazzapi-0.5.0}/wazzapi/resources/contacts.py

@@ -218,5 +218,41 @@ class ContactsResource(BaseResource):
         self._client._request("DELETE", f"/api/v1/contacts/{contact_id}")
         return None
 
+    def get_profile_picture(
+        self,
+        contact_id: str,
+        *,
+        whatsapp_account_id: str | None = None,
+        preview: bool | None = None,
+    ) -> models.ContactProfilePictureResponse:
+        return self._client._request(
+            "GET",
+            f"/api/v1/contacts/{contact_id}/profile-picture",
+            params={
+                "whatsapp_account_id": whatsapp_account_id,
+                "preview": preview,
+            },
+            response_model=models.ContactProfilePictureResponse,
+        )
+
+    def get_profile_picture_image(
+        self,
+        contact_id: str,
+        *,
+        whatsapp_account_id: str | None = None,
+        preview: bool | None = None,
+        proxy: bool | None = None,
+    ) -> models.ContactProfilePictureImageResult:
+        return self._client._request_bytes(
+            "GET",
+            f"/api/v1/contacts/{contact_id}/profile-picture/image",
+            params={
+                "whatsapp_account_id": whatsapp_account_id,
+                "preview": preview,
+                "proxy": proxy,
+            },
+            response_model=models.ContactProfilePictureImageResult,
+        )
+
 
 __all__ = ["ContactsResource"]

wazzapi-0.5.0/wazzapi/resources/conversations.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .. import models
+from .base import BaseResource
+
+
+class ConversationsResource(BaseResource):
+    def list(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        status: str | None = None,
+        whatsapp_account_id: str | None = None,
+        assignee_user_id: str | None = None,
+        search: str | None = None,
+    ) -> models.ConversationListResponse:
+        return self._client._request(
+            "GET",
+            "/api/v1/conversations",
+            params={
+                "limit": limit,
+                "offset": offset,
+                "status": status,
+                "whatsapp_account_id": whatsapp_account_id,
+                "assignee_user_id": assignee_user_id,
+                "search": search,
+            },
+            response_model=models.ConversationListResponse,
+        )
+
+    def get(self, conversation_id: str) -> models.ConversationItem:
+        return self._client._request(
+            "GET",
+            f"/api/v1/conversations/{conversation_id}",
+            response_model=models.ConversationItem,
+        )
+
+    def update(
+        self,
+        conversation_id: str,
+        payload: models.ConversationUpdateRequest | dict[str, Any],
+    ) -> models.ConversationItem:
+        return self._client._request(
+            "PATCH",
+            f"/api/v1/conversations/{conversation_id}",
+            json_body=payload,
+            response_model=models.ConversationItem,
+        )
+
+    def list_messages(
+        self,
+        conversation_id: str,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> models.ConversationMessageListResponse:
+        return self._client._request(
+            "GET",
+            f"/api/v1/conversations/{conversation_id}/messages",
+            params={"limit": limit, "offset": offset},
+            response_model=models.ConversationMessageListResponse,
+        )
+
+    def reply(
+        self,
+        conversation_id: str,
+        payload: models.ConversationReplyRequest | dict[str, Any],
+    ) -> models.ConversationReplyResponse:
+        return self._client._request(
+            "POST",
+            f"/api/v1/conversations/{conversation_id}/reply",
+            json_body=payload,
+            response_model=models.ConversationReplyResponse,
+        )
+
+
+__all__ = ["ConversationsResource"]

wazzapi-0.5.0/wazzapi/resources/devices.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from .. import models
+from .base import BaseResource
+
+
+class DevicesResource(BaseResource):
+    def list(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        status: str | None = None,
+        search: str | None = None,
+        sort_by: str | None = None,
+        sort_order: str | None = None,
+    ) -> models.DeviceListResponse:
+        return self._client._request(
+            "GET",
+            "/api/v1/devices",
+            params={
+                "limit": limit,
+                "offset": offset,
+                "status": status,
+                "search": search,
+                "sort_by": sort_by,
+                "sort_order": sort_order,
+            },
+            response_model=models.DeviceListResponse,
+        )
+
+    def get(self, device_id: str) -> models.DeviceResponse:
+        return self._client._request(
+            "GET",
+            f"/api/v1/devices/{device_id}",
+            response_model=models.DeviceResponse,
+        )
+
+    def link(self, payload: dict) -> dict:
+        return self._client._request(
+            "POST",
+            "/api/v1/devices",
+            json_body=payload,
+            response_model=dict,
+        )
+
+    def get_qr(self, device_id: str) -> dict:
+        return self._client._request(
+            "GET",
+            f"/api/v1/devices/{device_id}/qr",
+            response_model=dict,
+        )
+
+    def get_status(self, device_id: str) -> dict:
+        return self._client._request(
+            "GET",
+            f"/api/v1/devices/{device_id}/status",
+            response_model=dict,
+        )
+
+    def disconnect(self, device_id: str) -> dict:
+        return self._client._request(
+            "POST",
+            f"/api/v1/devices/{device_id}/disconnect",
+            response_model=dict,
+        )
+
+    def reconnect(self, device_id: str) -> dict:
+        return self._client._request(
+            "POST",
+            f"/api/v1/devices/{device_id}/reconnect",
+            response_model=dict,
+        )
+
+    def get_proxy(self, device_id: str) -> dict:
+        return self._client._request(
+            "GET",
+            f"/api/v1/devices/{device_id}/proxy",
+            response_model=dict,
+        )
+
+    def update_proxy(self, device_id: str, payload: dict) -> dict:
+        return self._client._request(
+            "PATCH",
+            f"/api/v1/devices/{device_id}/proxy",
+            json_body=payload,
+            response_model=dict,
+        )
+
+    def test_proxy(self, payload: dict) -> dict:
+        return self._client._request(
+            "POST",
+            "/api/v1/devices/proxy/test",
+            json_body=payload,
+            response_model=dict,
+        )
+
+
+__all__ = ["DevicesResource"]

wazzapi-0.5.0/wazzapi/resources/webhook_subscriptions.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .. import models
+from .base import BaseResource
+
+
+class WebhookSubscriptionsResource(BaseResource):
+    def list(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        active_only: bool | None = None,
+    ) -> models.WebhookListResponse:
+        return self._client._request(
+            "GET",
+            "/api/v1/webhooks/subscriptions",
+            params={"limit": limit, "offset": offset, "active_only": active_only},
+            response_model=models.WebhookListResponse,
+        )
+
+    def create(
+        self,
+        payload: models.WebhookCreateRequest | dict[str, Any],
+    ) -> models.WebhookResponse:
+        return self._client._request(
+            "POST",
+            "/api/v1/webhooks/subscriptions",
+            json_body=payload,
+            response_model=models.WebhookResponse,
+        )
+
+    def get(self, webhook_id: str) -> models.WebhookResponse:
+        return self._client._request(
+            "GET",
+            f"/api/v1/webhooks/subscriptions/{webhook_id}",
+            response_model=models.WebhookResponse,
+        )
+
+    def update(
+        self,
+        webhook_id: str,
+        payload: models.WebhookUpdateRequest | dict[str, Any],
+    ) -> models.WebhookResponse:
+        return self._client._request(
+            "PATCH",
+            f"/api/v1/webhooks/subscriptions/{webhook_id}",
+            json_body=payload,
+            response_model=models.WebhookResponse,
+        )
+
+    def delete(self, webhook_id: str) -> None:
+        self._client._request("DELETE", f"/api/v1/webhooks/subscriptions/{webhook_id}")
+        return None
+
+    def list_events(
+        self,
+        webhook_id: str,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> models.WebhookEventListResponse:
+        return self._client._request(
+            "GET",
+            f"/api/v1/webhooks/subscriptions/{webhook_id}/events",
+            params={"limit": limit, "offset": offset},
+            response_model=models.WebhookEventListResponse,
+        )
+
+    def ping(self, webhook_id: str) -> models.PingWebhookResponse:
+        return self._client._request(
+            "POST",
+            f"/api/v1/webhooks/subscriptions/{webhook_id}/ping",
+            response_model=models.PingWebhookResponse,
+        )
+
+
+__all__ = ["WebhookSubscriptionsResource"]

wazzapi-0.3.0/wazzapi/resources/devices.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from .. import models
-from .base import BaseResource
-
-
-class DevicesResource(BaseResource):
-    def list(
-        self,
-        *,
-        limit: int | None = None,
-        offset: int | None = None,
-        status: str | None = None,
-        search: str | None = None,
-        sort_by: str | None = None,
-        sort_order: str | None = None,
-    ) -> models.DeviceListResponse:
-        return self._client._request(
-            "GET",
-            "/api/v1/devices",
-            params={
-                "limit": limit,
-                "offset": offset,
-                "status": status,
-                "search": search,
-                "sort_by": sort_by,
-                "sort_order": sort_order,
-            },
-            response_model=models.DeviceListResponse,
-        )
-
-    def get(self, device_id: str) -> models.DeviceResponse:
-        return self._client._request(
-            "GET",
-            f"/api/v1/devices/{device_id}",
-            response_model=models.DeviceResponse,
-        )
-
-
-__all__ = ["DevicesResource"]