hookbridge 1.2.0__tar.gz → 1.4.0__tar.gz

hookbridge-1.4.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mypy hookbridge:*)",
+      "Bash(ruff check:*)"
+    ]
+  }
+}

{hookbridge-1.2.0 → hookbridge-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hookbridge
-Version: 1.2.0
+Version: 1.4.0
 Summary: Official HookBridge SDK for Python
 Project-URL: Homepage, https://hookbridge.io
 Project-URL: Documentation, https://hookbridge.io/docs/sdks/python
@@ -188,6 +188,73 @@ print("Save this key:", new_key.key)  # Only shown once!
 client.delete_api_key("key_abc123")
 ```
 
+### Inbound Webhooks
+
+```python
+# Create an inbound endpoint
+inbound = client.create_inbound_endpoint(
+    url="https://myapp.com/webhooks/inbound",
+    name="Stripe inbound",
+    description="Receives Stripe events through HookBridge",
+    verify_static_token=True,
+    token_header_name="X-Webhook-Token",
+    token_value="my-shared-secret",
+    signing_enabled=True,
+    idempotency_header_names=["X-Idempotency-Key"],
+    ingest_response_code=202,
+)
+
+print("Inbound endpoint ID:", inbound.id)
+print("Send webhooks here:", inbound.ingest_url)   # Save this
+print("Secret token:", inbound.secret_token)       # Only shown once
+
+# Inspect and manage the inbound endpoint
+details = client.get_inbound_endpoint(inbound.id)
+client.pause_inbound_endpoint(inbound.id)
+client.resume_inbound_endpoint(inbound.id)
+
+# Update verification settings later if needed
+client.update_inbound_endpoint(
+    inbound.id,
+    verify_hmac=True,
+    hmac_header_name="X-Signature",
+    hmac_secret="whsec_inbound_secret",
+)
+```
+
+### Inbound Observability
+
+```python
+# List inbound endpoints
+inbound_endpoints = client.list_inbound_endpoints(limit=50)
+
+# Query inbound delivery logs
+logs = client.get_inbound_logs(
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+    limit=50,
+)
+for entry in logs.entries:
+    print(entry.message_id, entry.status, entry.total_delivery_ms)
+
+# Get inbound metrics and time series
+metrics = client.get_inbound_metrics(
+    "24h",
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+)
+timeseries = client.get_inbound_timeseries_metrics(
+    "24h",
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+)
+
+# Review rejected inbound requests
+rejections = client.list_inbound_rejections(
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+    limit=25,
+)
+for rejection in rejections.entries:
+    print(rejection.reason_code, rejection.reason_detail)
+```
+
 ## Async Usage
 
 ```python

{hookbridge-1.2.0 → hookbridge-1.4.0}/PUBLISHING.md

@@ -11,20 +11,31 @@
    - Create account at https://pypi.org/account/register/
    - Generate API token at https://pypi.org/manage/account/token/
 
-3. Configure credentials in `~/.pypirc`:
+3. Recommended authentication: configure the API token in `~/.pypirc`:
    ```ini
    [pypi]
    username = __token__
    password = pypi-xxxxxxxxxxxxx
    ```
+4. Work from a clean local checkout. You do not need to create a GitHub release before uploading to PyPI, but you should avoid publishing uncommitted local changes by accident.
 
 ## Publishing Steps
 
 ### 1. Update Version
 
-Update version in both files:
-- `hookbridge/__init__.py` - `__version__ = "X.Y.Z"`
-- `pyproject.toml` - `version = "X.Y.Z"`
+Update the version in both files to the exact same value:
+- `hookbridge/__init__.py`
+- `pyproject.toml`
+
+Example change:
+
+```python
+__version__ = "1.3.1"
+```
+
+```toml
+version = "1.3.1"
+```
 
 ### 2. Run Tests
 
@@ -67,6 +78,18 @@ pip install --index-url https://test.pypi.org/simple/ hookbridge
 twine upload dist/*
 ```
 
+If you use multiple PyPI accounts on the same machine, verify the active credentials in `~/.pypirc` before uploading.
+
+Typical release order:
+
+1. bump the version in `hookbridge/__init__.py` and `pyproject.toml`
+2. run tests and checks
+3. build the distributions
+4. optionally upload to TestPyPI first
+5. run `twine upload dist/*`
+6. verify install from PyPI
+7. commit/tag/push if you have not already
+
 ### 6. Verify
 
 ```bash

{hookbridge-1.2.0 → hookbridge-1.4.0}/README.md

@@ -154,6 +154,73 @@ print("Save this key:", new_key.key)  # Only shown once!
 client.delete_api_key("key_abc123")
 ```
 
+### Inbound Webhooks
+
+```python
+# Create an inbound endpoint
+inbound = client.create_inbound_endpoint(
+    url="https://myapp.com/webhooks/inbound",
+    name="Stripe inbound",
+    description="Receives Stripe events through HookBridge",
+    verify_static_token=True,
+    token_header_name="X-Webhook-Token",
+    token_value="my-shared-secret",
+    signing_enabled=True,
+    idempotency_header_names=["X-Idempotency-Key"],
+    ingest_response_code=202,
+)
+
+print("Inbound endpoint ID:", inbound.id)
+print("Send webhooks here:", inbound.ingest_url)   # Save this
+print("Secret token:", inbound.secret_token)       # Only shown once
+
+# Inspect and manage the inbound endpoint
+details = client.get_inbound_endpoint(inbound.id)
+client.pause_inbound_endpoint(inbound.id)
+client.resume_inbound_endpoint(inbound.id)
+
+# Update verification settings later if needed
+client.update_inbound_endpoint(
+    inbound.id,
+    verify_hmac=True,
+    hmac_header_name="X-Signature",
+    hmac_secret="whsec_inbound_secret",
+)
+```
+
+### Inbound Observability
+
+```python
+# List inbound endpoints
+inbound_endpoints = client.list_inbound_endpoints(limit=50)
+
+# Query inbound delivery logs
+logs = client.get_inbound_logs(
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+    limit=50,
+)
+for entry in logs.entries:
+    print(entry.message_id, entry.status, entry.total_delivery_ms)
+
+# Get inbound metrics and time series
+metrics = client.get_inbound_metrics(
+    "24h",
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+)
+timeseries = client.get_inbound_timeseries_metrics(
+    "24h",
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+)
+
+# Review rejected inbound requests
+rejections = client.list_inbound_rejections(
+    inbound_endpoint_id="01935abc-def0-7123-4567-890abcdef012",
+    limit=25,
+)
+for rejection in rejections.entries:
+    print(rejection.reason_code, rejection.reason_detail)
+```
+
 ## Async Usage
 
 ```python

{hookbridge-1.2.0 → hookbridge-1.4.0}/hookbridge/__init__.py

@@ -44,16 +44,14 @@ from hookbridge.types import (
     MessageSummary,
     Metrics,
     MetricsWindow,
-    NotificationPreferences,
     PauseState,
-    Personalization,
     PortalSession,
     Project,
+    ReplayableMessageStatus,
     ReplayAllMessagesResponse,
     ReplayBatchMessagesResponse,
     ReplayBatchResult,
     ReplayMessageResponse,
-    ReplayableMessageStatus,
     RotateSecretResponse,
     SendWebhookResponse,
     SigningKey,
@@ -67,7 +65,7 @@ from hookbridge.types import (
     UsageHistoryRow,
 )
 
-__version__ = "1.2.0"
+__version__ = "1.4.0"
 
 __all__ = [
     "HookBridge",
@@ -101,9 +99,7 @@ __all__ = [
     "MessageSummary",
     "Metrics",
     "MetricsWindow",
-    "NotificationPreferences",
     "PauseState",
-    "Personalization",
     "PortalSession",
     "Project",
     "ReplayAllMessagesResponse",

{hookbridge-1.2.0 → hookbridge-1.4.0}/hookbridge/client.py

@@ -51,16 +51,14 @@ from hookbridge.types import (
     MessageSummary,
     Metrics,
     MetricsWindow,
-    NotificationPreferences,
     PauseState,
-    Personalization,
     PortalSession,
     Project,
+    ReplayableMessageStatus,
     ReplayAllMessagesResponse,
     ReplayBatchMessagesResponse,
     ReplayBatchResult,
     ReplayMessageResponse,
-    ReplayableMessageStatus,
     RotateSecretResponse,
     SendWebhookResponse,
     SigningKey,
@@ -95,9 +93,7 @@ def _query_string(params: dict[str, Any]) -> str:
     for key, value in params.items():
         if value is None:
             continue
-        if isinstance(value, datetime):
-            encoded[key] = value.isoformat()
-        elif isinstance(value, date):
+        if isinstance(value, (datetime, date)):
             encoded[key] = value.isoformat()
         else:
             encoded[key] = str(value)
@@ -111,6 +107,14 @@ def _with_query(path: str, params: dict[str, Any]) -> str:
     return f"{path}?{query}"
 
 
+def _json_value(value: Any) -> Any:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if isinstance(value, date):
+        return value.isoformat()
+    return value
+
+
 def _parse_message(data: dict[str, Any]) -> Message:
     return Message(
         id=data["id"],
@@ -224,6 +228,7 @@ def _parse_endpoint(data: dict[str, Any]) -> Endpoint:
         url=data["url"],
         created_at=_parse_datetime(data["created_at"]),
         updated_at=_parse_datetime(data["updated_at"]),
+        paused=data["paused"],
         description=data.get("description"),
         rate_limit_rps=data.get("rate_limit_rps"),
         burst=data.get("burst"),
@@ -236,6 +241,7 @@ def _parse_endpoint_summary(data: dict[str, Any]) -> EndpointSummary:
         id=data["id"],
         url=data["url"],
         created_at=_parse_datetime(data["created_at"]),
+        paused=data["paused"],
         description=data.get("description"),
     )
 
@@ -294,31 +300,6 @@ def _parse_rotate_secret(data: dict[str, Any]) -> RotateSecretResponse:
     )
 
 
-def _parse_personalization(data: dict[str, Any]) -> Personalization:
-    return Personalization(
-        id=data["id"],
-        user_id=data["user_id"],
-        timezone=data["timezone"],
-        date_format=data["date_format"],
-        locale=data["locale"],
-        created_at=_parse_datetime(data["created_at"]),
-        updated_at=_parse_datetime(data["updated_at"]),
-    )
-
-
-def _parse_notification_preferences(data: dict[str, Any]) -> NotificationPreferences:
-    return NotificationPreferences(
-        id=data["id"],
-        user_id=data["user_id"],
-        enabled_alert_types=data["enabled_alert_types"],
-        delivery_channels=data["delivery_channels"],
-        failure_rate_threshold=data["failure_rate_threshold"],
-        pending_backlog_threshold=data["pending_backlog_threshold"],
-        created_at=_parse_datetime(data["created_at"]),
-        updated_at=_parse_datetime(data["updated_at"]),
-    )
-
-
 def _parse_usage_history_row(data: dict[str, Any]) -> UsageHistoryRow:
     return UsageHistoryRow(
         period_start=_parse_date(data["period_start"]),
@@ -558,7 +539,9 @@ class HookBridge:
         return _parse_replay_all_messages(self._request("POST", path)["data"])
 
     def replay_batch_messages(self, message_ids: list[str]) -> ReplayBatchMessagesResponse:
-        response = self._request("POST", "/v1/messages/replay-batch", json={"message_ids": message_ids})
+        response = self._request(
+            "POST", "/v1/messages/replay-batch", json={"message_ids": message_ids}
+        )
         return _parse_replay_batch_messages(response["data"])
 
     def get_logs(
@@ -605,7 +588,8 @@ class HookBridge:
     def get_dlq_messages(
         self, *, limit: Optional[int] = None, cursor: Optional[str] = None
     ) -> DLQMessagesResponse:
-        response = self._request("GET", _with_query("/v1/dlq/messages", {"limit": limit, "cursor": cursor}))
+        path = _with_query("/v1/dlq/messages", {"limit": limit, "cursor": cursor})
+        response = self._request("GET", path)
         data = response["data"]
         return DLQMessagesResponse(
             messages=[_parse_message_summary(item) for item in data.get("messages", [])],
@@ -650,7 +634,11 @@ class HookBridge:
         return _parse_project(self._request("GET", f"/v1/projects/{project_id}")["data"])
 
     def update_project(
-        self, project_id: str, *, name: Optional[str] = None, rate_limit_default: Optional[int] = None
+        self,
+        project_id: str,
+        *,
+        name: Optional[str] = None,
+        rate_limit_default: Optional[int] = None,
     ) -> Project:
         body: dict[str, Any] = {}
         if name is not None:
@@ -697,7 +685,8 @@ class HookBridge:
     def list_endpoints(
         self, *, limit: Optional[int] = None, cursor: Optional[str] = None
     ) -> ListEndpointsResponse:
-        response = self._request("GET", _with_query("/v1/endpoints", {"limit": limit, "cursor": cursor}))
+        path = _with_query("/v1/endpoints", {"limit": limit, "cursor": cursor})
+        response = self._request("GET", path)
         meta = response.get("meta", {})
         next_cursor = meta.get("next_cursor")
         return ListEndpointsResponse(
@@ -732,6 +721,18 @@ class HookBridge:
     def delete_endpoint(self, endpoint_id: str) -> None:
         self._request("DELETE", f"/v1/endpoints/{endpoint_id}")
 
+    def pause_endpoint(self, endpoint_id: str) -> PauseState:
+        data = self._request("POST", f"/v1/endpoints/{endpoint_id}/pause")["data"]
+        return PauseState(id=data["id"], paused=data["paused"])
+
+    def resume_endpoint(self, endpoint_id: str) -> PauseState:
+        data = self._request("POST", f"/v1/endpoints/{endpoint_id}/resume")["data"]
+        return PauseState(
+            id=data["id"],
+            paused=data["paused"],
+            messages_requeued=data.get("messages_requeued"),
+        )
+
     def create_endpoint_signing_key(self, endpoint_id: str) -> RotateSecretResponse:
         data = self._request("POST", f"/v1/endpoints/{endpoint_id}/signing-keys")["data"]
         return _parse_rotate_secret(data)
@@ -746,55 +747,6 @@ class HookBridge:
     def rotate_endpoint_secret(self, endpoint_id: str) -> RotateSecretResponse:
         return self.create_endpoint_signing_key(endpoint_id)
 
-    def get_personalization(self) -> Personalization:
-        return _parse_personalization(
-            self._request("GET", "/v1/settings/personalization")["data"]
-        )
-
-    def update_personalization(
-        self,
-        *,
-        timezone: Optional[str] = None,
-        date_format: Optional[str] = None,
-        locale: Optional[str] = None,
-    ) -> Personalization:
-        body: dict[str, Any] = {}
-        if timezone is not None:
-            body["timezone"] = timezone
-        if date_format is not None:
-            body["date_format"] = date_format
-        if locale is not None:
-            body["locale"] = locale
-        return _parse_personalization(
-            self._request("PUT", "/v1/settings/personalization", json=body)["data"]
-        )
-
-    def get_notification_preferences(self) -> NotificationPreferences:
-        return _parse_notification_preferences(
-            self._request("GET", "/v1/settings/notifications")["data"]
-        )
-
-    def update_notification_preferences(
-        self,
-        *,
-        enabled_alert_types: Optional[list[str]] = None,
-        delivery_channels: Optional[list[str]] = None,
-        failure_rate_threshold: Optional[int] = None,
-        pending_backlog_threshold: Optional[int] = None,
-    ) -> NotificationPreferences:
-        body: dict[str, Any] = {}
-        if enabled_alert_types is not None:
-            body["enabled_alert_types"] = enabled_alert_types
-        if delivery_channels is not None:
-            body["delivery_channels"] = delivery_channels
-        if failure_rate_threshold is not None:
-            body["failure_rate_threshold"] = failure_rate_threshold
-        if pending_backlog_threshold is not None:
-            body["pending_backlog_threshold"] = pending_backlog_threshold
-        return _parse_notification_preferences(
-            self._request("PUT", "/v1/settings/notifications", json=body)["data"]
-        )
-
     def create_checkout(self, *, plan: str, interval: str) -> CheckoutSession:
         data = self._request(
             "POST", "/v1/billing/checkout", json={"plan": plan, "interval": interval}
@@ -1038,7 +990,10 @@ class HookBridge:
         status: Optional[MessageStatus] = None,
         endpoint_id: Optional[str] = None,
     ) -> ExportRecord:
-        body: dict[str, Any] = {"start_time": start_time, "end_time": end_time}
+        body: dict[str, Any] = {
+            "start_time": _json_value(start_time),
+            "end_time": _json_value(end_time),
+        }
         if status is not None:
             body["status"] = status
         if endpoint_id is not None:
@@ -1243,7 +1198,8 @@ class AsyncHookBridge:
         await self._request("POST", f"/v1/dlq/replay/{message_id}")
 
     async def list_api_keys(self) -> list[APIKeyInfo]:
-        return [_parse_api_key_info(item) for item in (await self._request("GET", "/v1/api-keys"))["data"]]
+        response = await self._request("GET", "/v1/api-keys")
+        return [_parse_api_key_info(item) for item in response["data"]]
 
     async def create_api_key(
         self, mode: APIKeyMode, *, label: Optional[str] = None
@@ -1264,9 +1220,12 @@ class AsyncHookBridge:
         await self._request("DELETE", f"/v1/api-keys/{key_id}")
 
     async def list_projects(self) -> list[Project]:
-        return [_parse_project(item) for item in (await self._request("GET", "/v1/projects"))["data"]]
+        response = await self._request("GET", "/v1/projects")
+        return [_parse_project(item) for item in response["data"]]
 
-    async def create_project(self, name: str, *, rate_limit_default: Optional[int] = None) -> Project:
+    async def create_project(
+        self, name: str, *, rate_limit_default: Optional[int] = None
+    ) -> Project:
         body: dict[str, Any] = {"name": name}
         if rate_limit_default is not None:
             body["rate_limit_default"] = rate_limit_default
@@ -1276,14 +1235,19 @@ class AsyncHookBridge:
         return _parse_project((await self._request("GET", f"/v1/projects/{project_id}"))["data"])
 
     async def update_project(
-        self, project_id: str, *, name: Optional[str] = None, rate_limit_default: Optional[int] = None
+        self,
+        project_id: str,
+        *,
+        name: Optional[str] = None,
+        rate_limit_default: Optional[int] = None,
     ) -> Project:
         body: dict[str, Any] = {}
         if name is not None:
             body["name"] = name
         if rate_limit_default is not None:
             body["rate_limit_default"] = rate_limit_default
-        return _parse_project((await self._request("PUT", f"/v1/projects/{project_id}", json=body))["data"])
+        response = await self._request("PUT", f"/v1/projects/{project_id}", json=body)
+        return _parse_project(response["data"])
 
     async def delete_project(self, project_id: str) -> None:
         await self._request("DELETE", f"/v1/projects/{project_id}")
@@ -1360,6 +1324,18 @@ class AsyncHookBridge:
     async def delete_endpoint(self, endpoint_id: str) -> None:
         await self._request("DELETE", f"/v1/endpoints/{endpoint_id}")
 
+    async def pause_endpoint(self, endpoint_id: str) -> PauseState:
+        data = (await self._request("POST", f"/v1/endpoints/{endpoint_id}/pause"))["data"]
+        return PauseState(id=data["id"], paused=data["paused"])
+
+    async def resume_endpoint(self, endpoint_id: str) -> PauseState:
+        data = (await self._request("POST", f"/v1/endpoints/{endpoint_id}/resume"))["data"]
+        return PauseState(
+            id=data["id"],
+            paused=data["paused"],
+            messages_requeued=data.get("messages_requeued"),
+        )
+
     async def create_endpoint_signing_key(self, endpoint_id: str) -> RotateSecretResponse:
         data = (await self._request("POST", f"/v1/endpoints/{endpoint_id}/signing-keys"))["data"]
         return _parse_rotate_secret(data)
@@ -1374,55 +1350,6 @@ class AsyncHookBridge:
     async def rotate_endpoint_secret(self, endpoint_id: str) -> RotateSecretResponse:
         return await self.create_endpoint_signing_key(endpoint_id)
 
-    async def get_personalization(self) -> Personalization:
-        return _parse_personalization(
-            (await self._request("GET", "/v1/settings/personalization"))["data"]
-        )
-
-    async def update_personalization(
-        self,
-        *,
-        timezone: Optional[str] = None,
-        date_format: Optional[str] = None,
-        locale: Optional[str] = None,
-    ) -> Personalization:
-        body: dict[str, Any] = {}
-        if timezone is not None:
-            body["timezone"] = timezone
-        if date_format is not None:
-            body["date_format"] = date_format
-        if locale is not None:
-            body["locale"] = locale
-        return _parse_personalization(
-            (await self._request("PUT", "/v1/settings/personalization", json=body))["data"]
-        )
-
-    async def get_notification_preferences(self) -> NotificationPreferences:
-        return _parse_notification_preferences(
-            (await self._request("GET", "/v1/settings/notifications"))["data"]
-        )
-
-    async def update_notification_preferences(
-        self,
-        *,
-        enabled_alert_types: Optional[list[str]] = None,
-        delivery_channels: Optional[list[str]] = None,
-        failure_rate_threshold: Optional[int] = None,
-        pending_backlog_threshold: Optional[int] = None,
-    ) -> NotificationPreferences:
-        body: dict[str, Any] = {}
-        if enabled_alert_types is not None:
-            body["enabled_alert_types"] = enabled_alert_types
-        if delivery_channels is not None:
-            body["delivery_channels"] = delivery_channels
-        if failure_rate_threshold is not None:
-            body["failure_rate_threshold"] = failure_rate_threshold
-        if pending_backlog_threshold is not None:
-            body["pending_backlog_threshold"] = pending_backlog_threshold
-        return _parse_notification_preferences(
-            (await self._request("PUT", "/v1/settings/notifications", json=body))["data"]
-        )
-
     async def create_checkout(self, *, plan: str, interval: str) -> CheckoutSession:
         data = (
             await self._request(
@@ -1674,7 +1601,10 @@ class AsyncHookBridge:
         status: Optional[MessageStatus] = None,
         endpoint_id: Optional[str] = None,
     ) -> ExportRecord:
-        body: dict[str, Any] = {"start_time": start_time, "end_time": end_time}
+        body: dict[str, Any] = {
+            "start_time": _json_value(start_time),
+            "end_time": _json_value(end_time),
+        }
         if status is not None:
             body["status"] = status
         if endpoint_id is not None:
@@ -1682,10 +1612,12 @@ class AsyncHookBridge:
         return _parse_export_record((await self._request("POST", "/v1/exports", json=body))["data"])
 
     async def list_exports(self) -> list[ExportRecord]:
-        return [_parse_export_record(item) for item in (await self._request("GET", "/v1/exports"))["data"]]
+        response = await self._request("GET", "/v1/exports")
+        return [_parse_export_record(item) for item in response["data"]]
 
     async def get_export(self, export_id: str) -> ExportRecord:
-        return _parse_export_record((await self._request("GET", f"/v1/exports/{export_id}"))["data"])
+        response = await self._request("GET", f"/v1/exports/{export_id}")
+        return _parse_export_record(response["data"])
 
     async def download_export(self, export_id: str) -> str:
         response = await self._request(

{hookbridge-1.2.0 → hookbridge-1.4.0}/hookbridge/types.py

@@ -126,6 +126,7 @@ class Endpoint:
     url: str
     created_at: datetime
     updated_at: datetime
+    paused: bool
     description: Optional[str] = None
     rate_limit_rps: Optional[int] = None
     burst: Optional[int] = None
@@ -137,6 +138,7 @@ class EndpointSummary:
     id: str
     url: str
     created_at: datetime
+    paused: bool
     description: Optional[str] = None
 
 
@@ -243,29 +245,6 @@ class Project:
     created_at: datetime
 
 
-@dataclass(frozen=True)
-class Personalization:
-    id: str
-    user_id: str
-    timezone: str
-    date_format: str
-    locale: str
-    created_at: datetime
-    updated_at: datetime
-
-
-@dataclass(frozen=True)
-class NotificationPreferences:
-    id: str
-    user_id: str
-    enabled_alert_types: list[str]
-    delivery_channels: list[str]
-    failure_rate_threshold: int
-    pending_backlog_threshold: int
-    created_at: datetime
-    updated_at: datetime
-
-
 @dataclass(frozen=True)
 class CheckoutSession:
     session_id: str
@@ -384,6 +363,7 @@ class DeleteResult:
 class PauseState:
     id: str
     paused: bool
+    messages_requeued: Optional[int] = None
 
 
 @dataclass(frozen=True)

{hookbridge-1.2.0 → hookbridge-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hookbridge"
-version = "1.2.0"
+version = "1.4.0"
 description = "Official HookBridge SDK for Python"
 readme = "README.md"
 license = "MIT"

{hookbridge-1.2.0 → hookbridge-1.4.0}/tests/conftest.py

@@ -186,6 +186,7 @@ MOCK_RESPONSES = {
             "url": "https://example.com/webhook",
             "created_at": "2025-01-01T00:00:00Z",
             "updated_at": "2025-01-01T00:00:00Z",
+            "paused": False,
             "description": "Test endpoint",
             "rate_limit_rps": 10,
             "burst": 20,
@@ -198,6 +199,7 @@ MOCK_RESPONSES = {
                 "id": "ep_550e8400e29b41d4a716446655440000",
                 "url": "https://example.com/webhook",
                 "created_at": "2025-01-01T00:00:00Z",
+                "paused": False,
                 "description": "Test endpoint",
             }
         ],

{hookbridge-1.2.0 → hookbridge-1.4.0}/tests/test_async_client.py

@@ -2,6 +2,9 @@
 Tests for the asynchronous HookBridge client.
 """
 
+import json
+from datetime import UTC, datetime
+
 import pytest
 from pytest_httpx import HTTPXMock
 
@@ -303,8 +306,45 @@ class TestAsyncEndpoints:
         result = await async_client.get_endpoint(endpoint_id)
 
         assert result.id == endpoint_id
+        assert result.paused is False
         assert result.rate_limit_rps == 10
 
+
+class TestAsyncExports:
+    """Tests for async export operations."""
+
+    @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
+    async def test_create_export_serializes_datetimes(
+        self, async_client: AsyncHookBridge, httpx_mock: HTTPXMock
+    ) -> None:
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{async_client._base_url}/v1/exports",
+            json={
+                "data": {
+                    "id": "01935abc-def0-7123-4567-890abcdef077",
+                    "project_id": "proj_abc123",
+                    "status": "pending",
+                    "filter_start_time": "2025-12-01T00:00:00+00:00",
+                    "filter_end_time": "2025-12-06T23:59:59+00:00",
+                    "created_at": "2025-12-06T12:00:00Z",
+                },
+                "meta": {"request_id": "req-12345"},
+            },
+        )
+
+        start = datetime(2025, 12, 1, 0, 0, 0, tzinfo=UTC)
+        end = datetime(2025, 12, 6, 23, 59, 59, tzinfo=UTC)
+        await async_client.create_export(start_time=start, end_time=end, endpoint_id="ep_123")
+
+        request = httpx_mock.get_request()
+        assert request is not None
+        assert json.loads(request.content) == {
+            "start_time": "2025-12-01T00:00:00+00:00",
+            "end_time": "2025-12-06T23:59:59+00:00",
+            "endpoint_id": "ep_123",
+        }
+
     @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
     async def test_list_endpoints(
         self, async_client: AsyncHookBridge, httpx_mock: HTTPXMock
@@ -319,8 +359,36 @@ class TestAsyncEndpoints:
         result = await async_client.list_endpoints()
 
         assert len(result.endpoints) == 1
+        assert result.endpoints[0].paused is False
         assert result.has_more is False
 
+    @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
+    async def test_pause_and_resume_endpoint(
+        self, async_client: AsyncHookBridge, httpx_mock: HTTPXMock
+    ) -> None:
+        """Pause and resume an outbound endpoint."""
+        endpoint_id = "ep_550e8400e29b41d4a716446655440000"
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{async_client._base_url}/v1/endpoints/{endpoint_id}/pause",
+            json={"data": {"id": endpoint_id, "paused": True}, "meta": {"request_id": "req-12345"}},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{async_client._base_url}/v1/endpoints/{endpoint_id}/resume",
+            json={
+                "data": {"id": endpoint_id, "paused": False, "messages_requeued": 2},
+                "meta": {"request_id": "req-12345"},
+            },
+        )
+
+        paused = await async_client.pause_endpoint(endpoint_id)
+        resumed = await async_client.resume_endpoint(endpoint_id)
+
+        assert paused.paused is True
+        assert resumed.paused is False
+        assert resumed.messages_requeued == 2
+
     @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
     async def test_rotate_endpoint_secret(
         self, async_client: AsyncHookBridge, httpx_mock: HTTPXMock

{hookbridge-1.2.0 → hookbridge-1.4.0}/tests/test_client.py

@@ -398,6 +398,7 @@ class TestEndpoints:
 
         assert result.id == endpoint_id
         assert result.url == "https://example.com/webhook"
+        assert result.paused is False
         assert result.rate_limit_rps == 10
 
     @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
@@ -413,8 +414,34 @@ class TestEndpoints:
 
         assert len(result.endpoints) == 1
         assert result.endpoints[0].id == "ep_550e8400e29b41d4a716446655440000"
+        assert result.endpoints[0].paused is False
         assert result.has_more is False
 
+    @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
+    def test_pause_and_resume_endpoint(self, client: HookBridge, httpx_mock: HTTPXMock) -> None:
+        """Pause and resume an outbound endpoint."""
+        endpoint_id = "ep_550e8400e29b41d4a716446655440000"
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{client._base_url}/v1/endpoints/{endpoint_id}/pause",
+            json={"data": {"id": endpoint_id, "paused": True}, "meta": {"request_id": "req-12345"}},
+        )
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{client._base_url}/v1/endpoints/{endpoint_id}/resume",
+            json={
+                "data": {"id": endpoint_id, "paused": False, "messages_requeued": 2},
+                "meta": {"request_id": "req-12345"},
+            },
+        )
+
+        paused = client.pause_endpoint(endpoint_id)
+        resumed = client.resume_endpoint(endpoint_id)
+
+        assert paused.paused is True
+        assert resumed.paused is False
+        assert resumed.messages_requeued == 2
+
     @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
     def test_update_endpoint(self, client: HookBridge, httpx_mock: HTTPXMock) -> None:
         """Update an endpoint."""

{hookbridge-1.2.0 → hookbridge-1.4.0}/tests/test_client_spec_parity.py

@@ -3,6 +3,7 @@ Spec parity tests for the synchronous HookBridge client.
 """
 
 import json
+from datetime import UTC, datetime
 
 import pytest
 from pytest_httpx import HTTPXMock
@@ -11,7 +12,6 @@ from hookbridge import HookBridge
 
 from .conftest import LIVE_MODE
 
-
 PROJECT_ID = "01935abc-def0-7123-4567-890abcdef012"
 INBOUND_ENDPOINT_ID = "01935abc-def0-7123-4567-890abcdef099"
 MESSAGE_ID = "01935abc-def0-7123-4567-890abcdef013"
@@ -236,69 +236,68 @@ class TestSigningKeyParity:
         client.delete_endpoint_signing_key(ENDPOINT_ID, SIGNING_KEY_ID)
 
 
-class TestSettingsParity:
+class TestEndpointPauseParity:
     @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
-    def test_personalization_settings(self, client: HookBridge, httpx_mock: HTTPXMock) -> None:
-        payload = {
-            "data": {
-                "id": "550e8400-e29b-41d4-a716-446655440000",
-                "user_id": "user_abc123",
-                "timezone": "America/New_York",
-                "date_format": "MM/DD/YYYY",
-                "locale": "en-US",
-                "created_at": "2025-12-01T10:00:00Z",
-                "updated_at": "2025-12-06T12:00:00Z",
-            },
-            "meta": {"request_id": "req-12345"},
-        }
+    def test_get_list_pause_resume_endpoint(
+        self, client: HookBridge, httpx_mock: HTTPXMock
+    ) -> None:
         httpx_mock.add_response(
             method="GET",
-            url=f"{client._base_url}/v1/settings/personalization",
-            json=payload,
+            url=f"{client._base_url}/v1/endpoints/{ENDPOINT_ID}",
+            json={
+                "data": {
+                    "id": ENDPOINT_ID,
+                    "url": "https://customer.app/webhooks",
+                    "description": "Main production webhook",
+                    "paused": False,
+                    "rate_limit_rps": 10,
+                    "burst": 20,
+                    "created_at": "2025-12-01T10:00:00Z",
+                    "updated_at": "2025-12-06T12:00:00Z",
+                },
+                "meta": {"request_id": "req-12345"},
+            },
         )
         httpx_mock.add_response(
-            method="PUT",
-            url=f"{client._base_url}/v1/settings/personalization",
-            json=payload,
-        )
-
-        current = client.get_personalization()
-        updated = client.update_personalization(timezone="America/New_York")
-
-        assert current.locale == "en-US"
-        assert updated.timezone == "America/New_York"
-
-    @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
-    def test_notification_settings(self, client: HookBridge, httpx_mock: HTTPXMock) -> None:
-        payload = {
-            "data": {
-                "id": "550e8400-e29b-41d4-a716-446655440001",
-                "user_id": "user_abc123",
-                "enabled_alert_types": ["high_failure_rate"],
-                "delivery_channels": ["email"],
-                "failure_rate_threshold": 10,
-                "pending_backlog_threshold": 100,
-                "created_at": "2025-12-01T10:00:00Z",
-                "updated_at": "2025-12-06T12:00:00Z",
+            method="GET",
+            url=f"{client._base_url}/v1/endpoints",
+            json={
+                "data": [
+                    {
+                        "id": ENDPOINT_ID,
+                        "url": "https://customer.app/webhooks",
+                        "description": "Main production webhook",
+                        "paused": False,
+                        "created_at": "2025-12-01T10:00:00Z",
+                    }
+                ],
+                "meta": {"request_id": "req-12345", "next_cursor": None},
             },
-            "meta": {"request_id": "req-12345"},
-        }
+        )
         httpx_mock.add_response(
-            method="GET",
-            url=f"{client._base_url}/v1/settings/notifications",
-            json=payload,
+            method="POST",
+            url=f"{client._base_url}/v1/endpoints/{ENDPOINT_ID}/pause",
+            json={"data": {"id": ENDPOINT_ID, "paused": True}, "meta": {"request_id": "req-12345"}},
         )
         httpx_mock.add_response(
-            method="PUT",
-            url=f"{client._base_url}/v1/settings/notifications",
-            json=payload,
+            method="POST",
+            url=f"{client._base_url}/v1/endpoints/{ENDPOINT_ID}/resume",
+            json={
+                "data": {"id": ENDPOINT_ID, "paused": False, "messages_requeued": 4},
+                "meta": {"request_id": "req-12345"},
+            },
         )
 
-        current = client.get_notification_preferences()
-        updated = client.update_notification_preferences(delivery_channels=["email"])
+        fetched = client.get_endpoint(ENDPOINT_ID)
+        listed = client.list_endpoints()
+        paused = client.pause_endpoint(ENDPOINT_ID)
+        resumed = client.resume_endpoint(ENDPOINT_ID)
 
-        assert current.enabled_alert_types == ["high_failure_rate"]
-        assert updated.pending_backlog_threshold == 100
+        assert fetched.paused is False
+        assert listed.endpoints[0].paused is False
+        assert paused.paused is True
+        assert resumed.paused is False
+        assert resumed.messages_requeued == 4
 
 
 class TestBillingParity:
@@ -700,3 +699,35 @@ class TestExportParity:
         assert listed[0].row_count == 5000
         assert fetched.status == "completed"
         assert download_url == "https://downloads.example.com/export.csv"
+
+    @pytest.mark.skipif(LIVE_MODE, reason="Mock test only")
+    def test_create_export_serializes_datetimes(
+        self, client: HookBridge, httpx_mock: HTTPXMock
+    ) -> None:
+        httpx_mock.add_response(
+            method="POST",
+            url=f"{client._base_url}/v1/exports",
+            json={
+                "data": {
+                    "id": EXPORT_ID,
+                    "project_id": "proj_abc123",
+                    "status": "pending",
+                    "filter_start_time": "2025-12-01T00:00:00+00:00",
+                    "filter_end_time": "2025-12-06T23:59:59+00:00",
+                    "created_at": "2025-12-06T12:00:00Z",
+                },
+                "meta": {"request_id": "req-12345"},
+            },
+        )
+
+        start = datetime(2025, 12, 1, 0, 0, 0, tzinfo=UTC)
+        end = datetime(2025, 12, 6, 23, 59, 59, tzinfo=UTC)
+        client.create_export(start_time=start, end_time=end, endpoint_id=ENDPOINT_ID)
+
+        request = httpx_mock.get_request()
+        assert request is not None
+        assert json.loads(request.content) == {
+            "start_time": "2025-12-01T00:00:00+00:00",
+            "end_time": "2025-12-06T23:59:59+00:00",
+            "endpoint_id": ENDPOINT_ID,
+        }

hookbridge-1.2.0/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(mypy hookbridge:*)"
-    ]
-  }
-}