feat(notifications): add directories, footers and webhooks services

The /public/v1/notifications/directories, /public/v1/notifications/footers
and /public/v1/notifications/webhooks collection endpoints had no service
class, so they were unreachable from MPTClient and AsyncMPTClient. Add sync
and async services for all three and register them as properties on the
Notifications group.

Mixins follow what the OpenAPI spec documents per endpoint: directories are
read-only (GET collection and GET by id), footers are fully managed, and
webhooks are managed with enable/disable actions.

Adding any service to Notifications pushes the group class past
wemake-python-styleguide's max_methods default of 7, which it was sitting
exactly on, so mpt_api_client/resources/notifications/*.py needs a
per-file-ignores entry for WPS214, as every other group at 8+ methods
already has. The entry also repeats WPS215 (previously inherited from the
broader mpt_api_client/resources/* pattern, which a more specific entry
replaces rather than extends) and adds WPS110 for the API-mandated
Footer.content field name.

Streaming support for these endpoints is out of scope and tracked
separately in MPT-24241.

MPT-24265

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: jentyk

mpt_api_client/resources/notifications/directories.py

@@ -0,0 +1,53 @@
+from mpt_api_client.http import AsyncService, Service
+from mpt_api_client.http.mixins import (
+    AsyncCollectionMixin,
+    AsyncGetMixin,
+    CollectionMixin,
+    GetMixin,
+)
+from mpt_api_client.models import Model
+from mpt_api_client.models.model import BaseModel
+
+
+class Directory(Model):
+    """Notifications Directory resource.
+
+    Attributes:
+        account: Reference to the account owning the directory.
+        origin: Reference to the account the directory originates from.
+        type: Directory type.
+        contacts: References to the contacts belonging to the directory.
+        audit: Audit information (created, updated events).
+    """
+
+    account: BaseModel | None
+    origin: BaseModel | None
+    type: str | None
+    contacts: list[BaseModel] | None
+    audit: BaseModel | None
+
+
+class DirectoriesServiceConfig:
+    """Notifications Directories service configuration."""
+
+    _endpoint = "/public/v1/notifications/directories"
+    _model_class = Directory
+    _collection_key = "data"
+
+
+class DirectoriesService(
+    GetMixin[Directory],
+    CollectionMixin[Directory],
+    Service[Directory],
+    DirectoriesServiceConfig,
+):
+    """Notifications Directories service."""
+
+
+class AsyncDirectoriesService(
+    AsyncGetMixin[Directory],
+    AsyncCollectionMixin[Directory],
+    AsyncService[Directory],
+    DirectoriesServiceConfig,
+):
+    """Async Notifications Directories service."""

mpt_api_client/resources/notifications/footers.py

@@ -0,0 +1,53 @@
+from mpt_api_client.http import AsyncService, Service
+from mpt_api_client.http.mixins import (
+    AsyncCollectionMixin,
+    AsyncManagedResourceMixin,
+    CollectionMixin,
+    ManagedResourceMixin,
+)
+from mpt_api_client.models import Model
+from mpt_api_client.models.model import BaseModel
+
+
+class Footer(Model):
+    """Notifications Footer resource.
+
+    Attributes:
+        language_code: Language code of the footer.
+        content: Content of the footer.
+        is_default: Whether this footer is the default one.
+        status: Footer status.
+        audit: Audit information (created, updated events).
+    """
+
+    language_code: str | None
+    content: str | None
+    is_default: bool | None
+    status: str | None
+    audit: BaseModel | None
+
+
+class FootersServiceConfig:
+    """Notifications Footers service configuration."""
+
+    _endpoint = "/public/v1/notifications/footers"
+    _model_class = Footer
+    _collection_key = "data"
+
+
+class FootersService(
+    ManagedResourceMixin[Footer],
+    CollectionMixin[Footer],
+    Service[Footer],
+    FootersServiceConfig,
+):
+    """Notifications Footers service."""
+
+
+class AsyncFootersService(
+    AsyncManagedResourceMixin[Footer],
+    AsyncCollectionMixin[Footer],
+    AsyncService[Footer],
+    FootersServiceConfig,
+):
+    """Async Notifications Footers service."""

mpt_api_client/resources/notifications/notifications.py

@@ -6,11 +6,20 @@
     CategoriesService,
 )
 from mpt_api_client.resources.notifications.contacts import AsyncContactsService, ContactsService
+from mpt_api_client.resources.notifications.directories import (
+    AsyncDirectoriesService,
+    DirectoriesService,
+)
+from mpt_api_client.resources.notifications.footers import AsyncFootersService, FootersService
 from mpt_api_client.resources.notifications.messages import AsyncMessagesService, MessagesService
 from mpt_api_client.resources.notifications.subscribers import (
     AsyncSubscribersService,
     SubscribersService,
 )
+from mpt_api_client.resources.notifications.webhooks import (
+    AsyncWebhooksService,
+    WebhooksService,
+)
 
 
 class Notifications:
@@ -51,6 +60,16 @@ def contacts(self) -> ContactsService:
         """Contacts service."""
         return ContactsService(http_client=self.http_client)
 
+    @property
+    def directories(self) -> DirectoriesService:
+        """Directories service."""
+        return DirectoriesService(http_client=self.http_client)
+
+    @property
+    def footers(self) -> FootersService:
+        """Footers service."""
+        return FootersService(http_client=self.http_client)
+
     @property
     def messages(self) -> MessagesService:
         """Messages service."""
@@ -61,6 +80,11 @@ def subscribers(self) -> SubscribersService:
         """Subscriptions service."""
         return SubscribersService(http_client=self.http_client)
 
+    @property
+    def webhooks(self) -> WebhooksService:
+        """Webhooks service."""
+        return WebhooksService(http_client=self.http_client)
+
 
 class AsyncNotifications:
     """Notifications MPT API Module."""
@@ -100,6 +124,16 @@ def contacts(self) -> AsyncContactsService:
         """Async Contacts service."""
         return AsyncContactsService(http_client=self.http_client)
 
+    @property
+    def directories(self) -> AsyncDirectoriesService:
+        """Async Directories service."""
+        return AsyncDirectoriesService(http_client=self.http_client)
+
+    @property
+    def footers(self) -> AsyncFootersService:
+        """Async Footers service."""
+        return AsyncFootersService(http_client=self.http_client)
+
     @property
     def messages(self) -> AsyncMessagesService:
         """Async Messages service."""
@@ -109,3 +143,8 @@ def messages(self) -> AsyncMessagesService:
     def subscribers(self) -> AsyncSubscribersService:
         """Subscriptions service."""
         return AsyncSubscribersService(http_client=self.http_client)
+
+    @property
+    def webhooks(self) -> AsyncWebhooksService:
+        """Async Webhooks service."""
+        return AsyncWebhooksService(http_client=self.http_client)

mpt_api_client/resources/notifications/webhooks.py

@@ -0,0 +1,81 @@
+from mpt_api_client.http import AsyncService, Service
+from mpt_api_client.http.mixins import (
+    AsyncCollectionMixin,
+    AsyncDisableMixin,
+    AsyncEnableMixin,
+    AsyncManagedResourceMixin,
+    CollectionMixin,
+    DisableMixin,
+    EnableMixin,
+    ManagedResourceMixin,
+)
+from mpt_api_client.models import Model
+from mpt_api_client.models.model import BaseModel
+
+
+class Webhook(Model):
+    """Notifications Webhook resource.
+
+    Attributes:
+        name: Webhook name.
+        url: Endpoint the webhook calls.
+        description: Webhook description.
+        status: Webhook status.
+        type: Webhook type.
+        secret: Shared secret used to sign webhook calls.
+        statistics: Call statistics of the webhook.
+        object_type: Type of the object the webhook is bound to.
+        account: Reference to the account owning the webhook.
+        object: Reference to the object the webhook is bound to.
+        criteria: Key/value criteria narrowing when the webhook fires.
+        last_success: Last successful call.
+        last_failure: Last failed call.
+        last_call: Last call regardless of its outcome.
+        audit: Audit information (created, updated events).
+    """
+
+    name: str | None
+    url: str | None
+    description: str | None
+    status: str | None
+    type: str | None
+    secret: str | None
+    statistics: BaseModel | None
+    object_type: str | None
+    account: BaseModel | None
+    object: BaseModel | None
+    criteria: list[BaseModel] | None
+    last_success: BaseModel | None
+    last_failure: BaseModel | None
+    last_call: BaseModel | None
+    audit: BaseModel | None
+
+
+class WebhooksServiceConfig:
+    """Notifications Webhooks service configuration."""
+
+    _endpoint = "/public/v1/notifications/webhooks"
+    _model_class = Webhook
+    _collection_key = "data"
+
+
+class WebhooksService(
+    EnableMixin[Webhook],
+    DisableMixin[Webhook],
+    ManagedResourceMixin[Webhook],
+    CollectionMixin[Webhook],
+    Service[Webhook],
+    WebhooksServiceConfig,
+):
+    """Notifications Webhooks service."""
+
+
+class AsyncWebhooksService(
+    AsyncEnableMixin[Webhook],
+    AsyncDisableMixin[Webhook],
+    AsyncManagedResourceMixin[Webhook],
+    AsyncCollectionMixin[Webhook],
+    AsyncService[Webhook],
+    WebhooksServiceConfig,
+):
+    """Async Notifications Webhooks service."""

pyproject.toml

@@ -133,6 +133,11 @@ per-file-ignores = [
   "mpt_api_client/resources/commerce/*.py: WPS235 WPS215",
   "mpt_api_client/resources/exchange/*.py: WPS235 WPS215",
   "mpt_api_client/resources/integration/*.py: WPS204 WPS214 WPS215 WPS235",
+  # notifications: footers.py carries the API-mandated `content` field (WPS110) and, like every
+  # service module, stacks more than three mixins (WPS215, restated because this entry shadows
+  # the resources/* one); notifications.py exposes more than seven services (WPS214).
+  "mpt_api_client/resources/notifications/footers.py: WPS110 WPS215",
+  "mpt_api_client/resources/notifications/notifications.py: WPS214",
   "mpt_api_client/resources/helpdesk/*.py: WPS204 WPS215 WPS214",
   "mpt_api_client/resources/program/*.py: WPS204 WPS215 WPS235",
   "mpt_api_client/rql/query_builder.py: WPS110 WPS115 WPS210 WPS214",

tests/unit/resources/notifications/test_directories.py

@@ -0,0 +1,90 @@
+import httpx
+import pytest
+import respx
+
+from mpt_api_client.resources.notifications.directories import (
+    AsyncDirectoriesService,
+    DirectoriesService,
+)
+
+
+@pytest.fixture
+def directories_service(http_client):
+    return DirectoriesService(http_client=http_client)
+
+
+@pytest.fixture
+def async_directories_service(async_http_client):
+    return AsyncDirectoriesService(http_client=async_http_client)
+
+
+@pytest.fixture
+def directory_data():
+    return {
+        "id": "NDR-1234",
+        "type": "Vendor",
+        "account": {"id": "ACC-1234", "name": "Account"},
+        "origin": {"id": "ACC-5678", "name": "Origin account"},
+        "contacts": [{"id": "CON-1234", "email": "contact@example.com"}],
+        "audit": {"created": {"at": "2024-01-01T00:00:00Z"}},
+    }
+
+
+def test_endpoint(directories_service):
+    result = directories_service.build_path()
+
+    assert result == "/public/v1/notifications/directories"
+
+
+def test_async_endpoint(async_directories_service):
+    result = async_directories_service.build_path()
+
+    assert result == "/public/v1/notifications/directories"
+
+
+@pytest.mark.parametrize("method", ["get", "iterate", "fetch_page"])
+def test_mixins_present(directories_service, method):
+    result = hasattr(directories_service, method)
+
+    assert result is True
+
+
+@pytest.mark.parametrize("method", ["get", "iterate", "fetch_page"])
+def test_async_mixins_present(async_directories_service, method):
+    result = hasattr(async_directories_service, method)
+
+    assert result is True
+
+
+@pytest.mark.parametrize("method", ["create", "update", "delete"])
+def test_write_mixins_absent(directories_service, method):
+    result = hasattr(directories_service, method)
+
+    assert result is False
+
+
+@pytest.mark.parametrize("method", ["create", "update", "delete"])
+def test_async_write_mixins_absent(async_directories_service, method):
+    result = hasattr(async_directories_service, method)
+
+    assert result is False
+
+
+def test_get_directory(directories_service, directory_data):
+    with respx.mock:
+        mock_route = respx.get(
+            "https://api.example.com/public/v1/notifications/directories/NDR-1234"
+        ).mock(
+            return_value=httpx.Response(
+                status_code=200,
+                headers={"content-type": "application/json"},
+                json=directory_data,
+            )
+        )
+
+        result = directories_service.get("NDR-1234")
+
+        assert mock_route.call_count == 1
+        assert result.to_dict() == directory_data
+        assert result.account.id == "ACC-1234"
+        assert result.contacts[0].id == "CON-1234"