posthawk 0.1.0__tar.gz

posthawk-0.1.0/.gitignore

@@ -0,0 +1,51 @@
+# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Testing
+coverage/
+
+# Next.js
+.next/
+out/
+
+# Production
+dist/
+build/
+
+# Misc
+.DS_Store
+*.pem
+.env
+.env.local
+.env.*.local
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Turbo
+.turbo/
+
+# Supabase
+.supabase/
+
+# Wrangler (Cloudflare)
+.wrangler/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs
+*.log
+/logs/
+
+# OS
+Thumbs.db

posthawk-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: posthawk
+Version: 0.1.0
+Summary: Official Posthawk SDK for sending emails
+Project-URL: Homepage, https://posthawk.dev
+Project-URL: Documentation, https://docs.posthawk.dev/sdk-python
+Project-URL: Repository, https://github.com/endibuka/posthawk-python
+License-Expression: MIT
+Keywords: email,posthawk,sdk,transactional-email
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Email
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Description-Content-Type: text/markdown
+
+# Posthawk Python SDK
+
+The official Python SDK for [Posthawk](https://posthawk.dev) — send transactional emails, schedule deliveries, and manage email jobs.
+
+## Install
+
+```bash
+pip install posthawk
+```
+
+## Quick Start
+
+```python
+from posthawk import Posthawk
+
+client = Posthawk("ck_live_...")
+
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to="user@example.com",
+    subject="Hello from Posthawk",
+    html="<h1>Welcome!</h1><p>Your account is ready.</p>",
+)
+
+if result.error:
+    print(result.error.message)
+else:
+    print(f"Sent! Job ID: {result.data.job_id}")
+```
+
+## Send Email
+
+```python
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to=["alice@example.com", "bob@example.com"],
+    cc="manager@example.com",
+    subject="Weekly Report",
+    html="<h1>Report</h1>",
+    text="Plain text fallback",
+    headers={"X-Custom": "value"},
+    metadata={"campaign": "onboarding"},
+    tags={"type": "transactional"},
+)
+```
+
+## Schedule Emails
+
+```python
+from datetime import datetime, timedelta, timezone
+
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to="user@example.com",
+    subject="Reminder",
+    text="Don't forget your appointment tomorrow!",
+    scheduled_for=datetime.now(timezone.utc) + timedelta(hours=24),
+)
+
+print(f"Scheduled for: {result.data.scheduled_for}")
+```
+
+## Check Delivery Status
+
+```python
+result = client.emails.get("job-id-here")
+
+if not result.error:
+    print(f"Status: {result.data.status}")
+    # pending | processing | completed | failed
+```
+
+## Manage Scheduled Emails
+
+```python
+# List all scheduled emails
+result = client.scheduled.list(status="scheduled", limit=10)
+for email in result.data.data:
+    print(f"{email.subject} → {email.scheduled_for}")
+
+# Get a specific scheduled email
+result = client.scheduled.get("scheduled-email-id")
+
+# Cancel before it sends
+result = client.scheduled.cancel("scheduled-email-id")
+
+# Reschedule to a new time
+result = client.scheduled.reschedule(
+    "scheduled-email-id",
+    scheduled_for="2026-04-01T10:00:00Z",
+)
+```
+
+## Self-Hosted
+
+Point the SDK at your own Posthawk instance:
+
+```python
+client = Posthawk("ck_live_...", base_url="https://api.yourdomain.com")
+```
+
+## Error Handling
+
+SDK methods never raise exceptions for API errors. Every method returns a `PosthawkResponse` with `.data` and `.error`:
+
+```python
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to="user@example.com",
+    subject="Test",
+    html="<p>Hello</p>",
+)
+
+if result.error:
+    print(f"Error {result.error.status_code}: {result.error.message}")
+else:
+    print(f"Success: {result.data.job_id}")
+```
+
+## Context Manager
+
+Use a context manager to automatically close the HTTP connection pool:
+
+```python
+with Posthawk("ck_live_...") as client:
+    result = client.emails.send(
+        from_email="hi@yourdomain.com",
+        to="user@example.com",
+        subject="Hello",
+        html="<h1>Hi</h1>",
+    )
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `client.emails.send(...)` | Send an email or schedule one |
+| `client.emails.get(job_id)` | Check delivery status |
+| `client.scheduled.list(...)` | List scheduled emails |
+| `client.scheduled.get(id)` | Get a scheduled email |
+| `client.scheduled.cancel(id)` | Cancel a scheduled email |
+| `client.scheduled.reschedule(id, ...)` | Reschedule an email |
+
+## License
+
+MIT

posthawk-0.1.0/README.md

@@ -0,0 +1,147 @@
+# Posthawk Python SDK
+
+The official Python SDK for [Posthawk](https://posthawk.dev) — send transactional emails, schedule deliveries, and manage email jobs.
+
+## Install
+
+```bash
+pip install posthawk
+```
+
+## Quick Start
+
+```python
+from posthawk import Posthawk
+
+client = Posthawk("ck_live_...")
+
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to="user@example.com",
+    subject="Hello from Posthawk",
+    html="<h1>Welcome!</h1><p>Your account is ready.</p>",
+)
+
+if result.error:
+    print(result.error.message)
+else:
+    print(f"Sent! Job ID: {result.data.job_id}")
+```
+
+## Send Email
+
+```python
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to=["alice@example.com", "bob@example.com"],
+    cc="manager@example.com",
+    subject="Weekly Report",
+    html="<h1>Report</h1>",
+    text="Plain text fallback",
+    headers={"X-Custom": "value"},
+    metadata={"campaign": "onboarding"},
+    tags={"type": "transactional"},
+)
+```
+
+## Schedule Emails
+
+```python
+from datetime import datetime, timedelta, timezone
+
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to="user@example.com",
+    subject="Reminder",
+    text="Don't forget your appointment tomorrow!",
+    scheduled_for=datetime.now(timezone.utc) + timedelta(hours=24),
+)
+
+print(f"Scheduled for: {result.data.scheduled_for}")
+```
+
+## Check Delivery Status
+
+```python
+result = client.emails.get("job-id-here")
+
+if not result.error:
+    print(f"Status: {result.data.status}")
+    # pending | processing | completed | failed
+```
+
+## Manage Scheduled Emails
+
+```python
+# List all scheduled emails
+result = client.scheduled.list(status="scheduled", limit=10)
+for email in result.data.data:
+    print(f"{email.subject} → {email.scheduled_for}")
+
+# Get a specific scheduled email
+result = client.scheduled.get("scheduled-email-id")
+
+# Cancel before it sends
+result = client.scheduled.cancel("scheduled-email-id")
+
+# Reschedule to a new time
+result = client.scheduled.reschedule(
+    "scheduled-email-id",
+    scheduled_for="2026-04-01T10:00:00Z",
+)
+```
+
+## Self-Hosted
+
+Point the SDK at your own Posthawk instance:
+
+```python
+client = Posthawk("ck_live_...", base_url="https://api.yourdomain.com")
+```
+
+## Error Handling
+
+SDK methods never raise exceptions for API errors. Every method returns a `PosthawkResponse` with `.data` and `.error`:
+
+```python
+result = client.emails.send(
+    from_email="hi@yourdomain.com",
+    to="user@example.com",
+    subject="Test",
+    html="<p>Hello</p>",
+)
+
+if result.error:
+    print(f"Error {result.error.status_code}: {result.error.message}")
+else:
+    print(f"Success: {result.data.job_id}")
+```
+
+## Context Manager
+
+Use a context manager to automatically close the HTTP connection pool:
+
+```python
+with Posthawk("ck_live_...") as client:
+    result = client.emails.send(
+        from_email="hi@yourdomain.com",
+        to="user@example.com",
+        subject="Hello",
+        html="<h1>Hi</h1>",
+    )
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `client.emails.send(...)` | Send an email or schedule one |
+| `client.emails.get(job_id)` | Check delivery status |
+| `client.scheduled.list(...)` | List scheduled emails |
+| `client.scheduled.get(id)` | Get a scheduled email |
+| `client.scheduled.cancel(id)` | Cancel a scheduled email |
+| `client.scheduled.reschedule(id, ...)` | Reschedule an email |
+
+## License
+
+MIT

posthawk-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "posthawk"
+version = "0.1.0"
+description = "Official Posthawk SDK for sending emails"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dependencies = ["httpx>=0.24.0"]
+keywords = ["email", "posthawk", "sdk", "transactional-email"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Communications :: Email",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://posthawk.dev"
+Documentation = "https://docs.posthawk.dev/sdk-python"
+Repository = "https://github.com/endibuka/posthawk-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/posthawk"]

posthawk-0.1.0/src/posthawk/__init__.py

@@ -0,0 +1,29 @@
+from ._version import __version__
+from .client import Posthawk
+from .error import PosthawkError
+from .types import (
+    CancelResponse,
+    EmailJobResult,
+    EmailJobStatus,
+    PosthawkResponse,
+    RescheduleResponse,
+    ScheduledEmail,
+    ScheduledGetResponse,
+    ScheduledListResponse,
+    SendEmailResponse,
+)
+
+__all__ = [
+    "__version__",
+    "CancelResponse",
+    "EmailJobResult",
+    "EmailJobStatus",
+    "Posthawk",
+    "PosthawkError",
+    "PosthawkResponse",
+    "RescheduleResponse",
+    "ScheduledEmail",
+    "ScheduledGetResponse",
+    "ScheduledListResponse",
+    "SendEmailResponse",
+]

posthawk-0.1.0/src/posthawk/_http.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ._version import __version__
+from .error import PosthawkError
+from .types import PosthawkResponse
+
+
+def _camel_to_snake(name: str) -> str:
+    s1 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+
+def _convert_keys(obj: Any) -> Any:
+    """Recursively convert dict keys from camelCase to snake_case."""
+    if isinstance(obj, dict):
+        return {_camel_to_snake(k): _convert_keys(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_convert_keys(item) for item in obj]
+    return obj
+
+
+class HttpClient:
+    def __init__(self, base_url: str, api_key: str) -> None:
+        self._client = httpx.Client(
+            base_url=base_url,
+            headers={
+                "x-api-key": api_key,
+                "Content-Type": "application/json",
+                "User-Agent": f"posthawk-python/{__version__}",
+            },
+            timeout=30.0,
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> PosthawkResponse[Any]:
+        try:
+            response = self._client.request(method, path, json=json, params=params)
+
+            data = response.json() if response.content else None
+
+            if not response.is_success:
+                message = f"Request failed with status {response.status_code}"
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or message
+                return PosthawkResponse(
+                    data=None,
+                    error=PosthawkError(message, response.status_code),
+                )
+
+            converted = _convert_keys(data) if data is not None else data
+            return PosthawkResponse(data=converted, error=None)
+
+        except httpx.HTTPError as exc:
+            return PosthawkResponse(
+                data=None,
+                error=PosthawkError(str(exc), 0),
+            )
+
+    def close(self) -> None:
+        self._client.close()

posthawk-0.1.0/src/posthawk/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

posthawk-0.1.0/src/posthawk/client.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ._http import HttpClient
+from .emails import Emails
+from .error import PosthawkError
+from .scheduled import Scheduled
+
+_DEFAULT_BASE_URL = "https://api.posthawk.dev"
+
+
+class Posthawk:
+    """Posthawk SDK client.
+
+    Usage::
+
+        client = Posthawk("ck_live_...")
+
+        result = client.emails.send(
+            from_email="hi@example.com",
+            to="user@example.com",
+            subject="Hello",
+            html="<h1>Hi!</h1>",
+        )
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+    ) -> None:
+        if not api_key:
+            raise PosthawkError(
+                'Missing API key. Pass your key as the first argument: '
+                'Posthawk("ck_live_...")',
+                401,
+            )
+
+        resolved_url = (base_url or _DEFAULT_BASE_URL).rstrip("/")
+
+        self._http = HttpClient(resolved_url, api_key)
+        self.emails = Emails(self._http)
+        self.scheduled = Scheduled(self._http)
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._http.close()
+
+    def __enter__(self) -> Posthawk:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()

posthawk-0.1.0/src/posthawk/emails.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import quote
+
+from ._http import HttpClient
+from .types import (
+    EmailJobResult,
+    EmailJobStatus,
+    PosthawkResponse,
+    SendEmailResponse,
+)
+
+
+def _to_list(value: Optional[Union[str, List[str]]]) -> Optional[List[str]]:
+    if value is None:
+        return None
+    return value if isinstance(value, list) else [value]
+
+
+def _to_iso(value: Optional[Union[str, datetime]]) -> Optional[str]:
+    if value is None:
+        return None
+    return value.isoformat() if isinstance(value, datetime) else value
+
+
+class Emails:
+    """Email sending and status checking."""
+
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def send(
+        self,
+        *,
+        from_email: str,
+        to: Union[str, List[str]],
+        subject: str,
+        cc: Optional[Union[str, List[str]]] = None,
+        bcc: Optional[Union[str, List[str]]] = None,
+        html: Optional[str] = None,
+        text: Optional[str] = None,
+        template_id: Optional[str] = None,
+        variables: Optional[Dict[str, str]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        scheduled_for: Optional[Union[str, datetime]] = None,
+        timezone: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[Dict[str, Any]] = None,
+        reply_to: Optional[str] = None,
+    ) -> PosthawkResponse[SendEmailResponse]:
+        """Send an email immediately or schedule it for later."""
+        body: Dict[str, Any] = {
+            "from": from_email,
+            "to": _to_list(to),
+            "subject": subject,
+        }
+
+        optionals: Dict[str, Any] = {
+            "cc": _to_list(cc),
+            "bcc": _to_list(bcc),
+            "html": html,
+            "text": text,
+            "templateId": template_id,
+            "variables": variables,
+            "headers": headers,
+            "scheduledFor": _to_iso(scheduled_for),
+            "timezone": timezone,
+            "metadata": metadata,
+            "tags": tags,
+            "replyTo": reply_to,
+        }
+        body.update({k: v for k, v in optionals.items() if v is not None})
+
+        resp = self._http.request("POST", "/v1/send", json=body)
+        if resp.error:
+            return PosthawkResponse(data=None, error=resp.error)
+
+        return PosthawkResponse(
+            data=SendEmailResponse(**resp.data),
+            error=None,
+        )
+
+    def get(self, job_id: str) -> PosthawkResponse[EmailJobStatus]:
+        """Check the status of a previously queued email job."""
+        resp = self._http.request("GET", f"/v1/send/{quote(job_id, safe='')}")
+        if resp.error:
+            return PosthawkResponse(data=None, error=resp.error)
+
+        raw = dict(resp.data)
+        result_data = raw.pop("result", None)
+        result = EmailJobResult(**result_data) if result_data else None
+
+        return PosthawkResponse(
+            data=EmailJobStatus(**raw, result=result),
+            error=None,
+        )

posthawk-0.1.0/src/posthawk/error.py

@@ -0,0 +1,16 @@
+class PosthawkError(Exception):
+    """Error returned by the Posthawk API.
+
+    SDK methods never raise this for API errors — they return
+    PosthawkResponse(data=None, error=PosthawkError(...)) instead.
+
+    Only the Posthawk constructor raises this directly (e.g. missing API key).
+    """
+
+    def __init__(self, message: str, status_code: int = 500):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+    def __repr__(self) -> str:
+        return f"PosthawkError(message={self.message!r}, status_code={self.status_code})"

posthawk-0.1.0/src/posthawk/scheduled.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, Optional, Union
+from urllib.parse import quote
+
+from ._http import HttpClient
+from .types import (
+    CancelResponse,
+    PosthawkResponse,
+    RescheduleResponse,
+    ScheduledEmail,
+    ScheduledGetResponse,
+    ScheduledListResponse,
+)
+
+
+class Scheduled:
+    """Manage scheduled emails."""
+
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def list(
+        self,
+        *,
+        status: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> PosthawkResponse[ScheduledListResponse]:
+        """List scheduled emails with optional filtering."""
+        params: Dict[str, Any] = {}
+        if status is not None:
+            params["status"] = status
+        if limit is not None:
+            params["limit"] = str(limit)
+        if offset is not None:
+            params["offset"] = str(offset)
+
+        resp = self._http.request("GET", "/scheduled", params=params or None)
+        if resp.error:
+            return PosthawkResponse(data=None, error=resp.error)
+
+        raw = resp.data
+        emails = [ScheduledEmail(**e) for e in raw.get("data", [])]
+
+        return PosthawkResponse(
+            data=ScheduledListResponse(
+                success=raw.get("success", True),
+                data=emails,
+                total=raw.get("total", 0),
+            ),
+            error=None,
+        )
+
+    def get(self, id: str) -> PosthawkResponse[ScheduledGetResponse]:
+        """Get a specific scheduled email by ID."""
+        resp = self._http.request("GET", f"/scheduled/{quote(id, safe='')}")
+        if resp.error:
+            return PosthawkResponse(data=None, error=resp.error)
+
+        raw = resp.data
+        return PosthawkResponse(
+            data=ScheduledGetResponse(
+                success=raw.get("success", True),
+                data=ScheduledEmail(**raw["data"]),
+            ),
+            error=None,
+        )
+
+    def cancel(self, id: str) -> PosthawkResponse[CancelResponse]:
+        """Cancel a scheduled email before it sends."""
+        resp = self._http.request("DELETE", f"/scheduled/{quote(id, safe='')}")
+        if resp.error:
+            return PosthawkResponse(data=None, error=resp.error)
+
+        raw = resp.data
+        return PosthawkResponse(
+            data=CancelResponse(
+                success=raw.get("success", True),
+                message=raw.get("message", ""),
+            ),
+            error=None,
+        )
+
+    def reschedule(
+        self,
+        id: str,
+        *,
+        scheduled_for: Union[str, datetime],
+    ) -> PosthawkResponse[RescheduleResponse]:
+        """Reschedule an email to a new send time."""
+        iso = (
+            scheduled_for.isoformat()
+            if isinstance(scheduled_for, datetime)
+            else scheduled_for
+        )
+
+        resp = self._http.request(
+            "PATCH",
+            f"/scheduled/{quote(id, safe='')}/reschedule",
+            json={"scheduledFor": iso},
+        )
+        if resp.error:
+            return PosthawkResponse(data=None, error=resp.error)
+
+        raw = resp.data
+        return PosthawkResponse(
+            data=RescheduleResponse(
+                success=raw.get("success", True),
+                data=ScheduledEmail(**raw["data"]),
+            ),
+            error=None,
+        )

posthawk-0.1.0/src/posthawk/types.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Generic, List, Optional, TypeVar
+
+from .error import PosthawkError
+
+T = TypeVar("T")
+
+
+@dataclass
+class PosthawkResponse(Generic[T]):
+    """Every SDK method returns this. Check .error first."""
+
+    data: Optional[T]
+    error: Optional[PosthawkError]
+
+
+# -- Email responses --
+
+
+@dataclass
+class SendEmailResponse:
+    success: bool
+    scheduled: bool
+    message: str
+    status_url: str
+    job_id: Optional[str] = None
+    id: Optional[str] = None
+    scheduled_for: Optional[str] = None
+
+
+@dataclass
+class EmailJobResult:
+    success: Optional[bool] = None
+    message_id: Optional[str] = None
+    email_log_id: Optional[str] = None
+
+
+@dataclass
+class EmailJobStatus:
+    job_id: str
+    status: str  # pending | processing | completed | failed
+    created_at: str
+    progress: Optional[float] = None
+    result: Optional[EmailJobResult] = None
+    error: Optional[str] = None
+    processed_at: Optional[str] = None
+
+
+# -- Scheduled responses --
+
+
+@dataclass
+class ScheduledEmail:
+    id: str
+    from_email: str
+    to_emails: List[str]
+    subject: str
+    scheduled_for: str
+    status: str  # scheduled | sent | cancelled | failed
+    created_at: str
+    cc_emails: Optional[List[str]] = None
+    bcc_emails: Optional[List[str]] = None
+    timezone: Optional[str] = None
+
+
+@dataclass
+class ScheduledListResponse:
+    success: bool
+    data: List[ScheduledEmail]
+    total: int
+
+
+@dataclass
+class ScheduledGetResponse:
+    success: bool
+    data: ScheduledEmail
+
+
+@dataclass
+class CancelResponse:
+    success: bool
+    message: str
+
+
+@dataclass
+class RescheduleResponse:
+    success: bool
+    data: ScheduledEmail