sendly-python 0.2.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sendly/__init__.py

@@ -3,9 +3,11 @@
 Example:
     >>> from sendly import Sendly
     >>> sendly = Sendly()  # reads SENDLY_API_KEY
-    >>> sendly.emails.send(
+    >>> receipt = sendly.emails.send(
     ...     {"from": "a@b.com", "to": "c@d.com", "subject": "hi", "body": "<p>hi</p>"}
     ... )
+    >>> receipt["status"]  # a real delivery state; poll emails.get(receipt["id"])
+    'PENDING'
 
 The same client also speaks the ``/api/v1`` surface — campaigns, segments,
 workflows, analytics, usage, and the v1 event methods:
@@ -35,6 +37,8 @@ from sendly.resources.domains import DomainsResource
 from sendly.resources.emails import EmailsResource
 from sendly.resources.events import EventsResource
 from sendly.resources.lists import ListsResource
+from sendly.resources.mailboxes import MailboxesResource
+from sendly.resources.projects import ProjectsResource
 from sendly.resources.segments import SegmentsResource
 from sendly.resources.suppression import SuppressionResource
 from sendly.resources.templates import TemplatesResource
@@ -57,6 +61,8 @@ __all__ = [
     "EmailsResource",
     "EventsResource",
     "ListsResource",
+    "MailboxesResource",
+    "ProjectsResource",
     "SegmentsResource",
     "Sendly",
     "SendlyAuthenticationError",

sendly/client.py

@@ -40,6 +40,8 @@ from sendly.resources.domains import DomainsResource
 from sendly.resources.emails import EmailsResource
 from sendly.resources.events import EventsResource
 from sendly.resources.lists import ListsResource
+from sendly.resources.mailboxes import MailboxesResource
+from sendly.resources.projects import ProjectsResource
 from sendly.resources.segments import SegmentsResource
 from sendly.resources.suppression import SuppressionResource
 from sendly.resources.templates import TemplatesResource
@@ -57,7 +59,7 @@ if TYPE_CHECKING:
 __all__ = ["DEFAULT_BASE_URL", "SDK_VERSION", "Sendly"]
 
 #: Package version. Kept in sync with ``pyproject.toml``.
-SDK_VERSION = "0.2.0"
+SDK_VERSION = "1.0.0"
 
 #: Default production API base. Override via ``base_url`` for staging/self-hosted.
 DEFAULT_BASE_URL = "https://api.sendly.now"
@@ -135,6 +137,8 @@ class Sendly:
         self.webhooks = WebhooksResource(self)
         self.suppression = SuppressionResource(self)
         self.lists = ListsResource(self)
+        # Reads only -- the mailbox writes need a user, which an API key is not.
+        self.mailboxes = MailboxesResource(self)
         # /api/v1 surface. Same client, same auth; bare resource bodies instead
         # of the legacy {success, data} envelope, and RFC 9457 problem errors.
         self.campaigns = CampaignsResource(self)
@@ -142,6 +146,7 @@ class Sendly:
         self.workflows = WorkflowsResource(self)
         self.analytics = AnalyticsResource(self)
         self.usage = UsageResource(self)
+        self.projects = ProjectsResource(self)
 
     def request(
         self,

sendly/resources/domains.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
         Body,
         DomainListResponse,
         DomainRecord,
+        DomainSetupSession,
         DomainVerificationStatus,
     )
 
@@ -62,6 +63,21 @@ class DomainsResource:
         status: DomainVerificationStatus = self._client.unwrap(envelope)
         return status
 
+    def start_setup(self, id: str) -> DomainSetupSession:
+        """Start the guided DNS setup hand-off for a domain.
+
+        Returns the session as the route returns it: a ``connectUrl`` to open in
+        a browser, the ``token`` that url carries, and ``expiresAt``. Nothing is
+        derived or reshaped -- finishing setup means a person visiting that url
+        and authorising the change at their registrar, so the SDK's job is to
+        hand back the link, not to model the flow behind it.
+        """
+        envelope = self._client.request(
+            method="POST", path=f"/api/domains/{encode_path_segment(id)}/dodomain-session"
+        )
+        session: DomainSetupSession = self._client.unwrap(envelope)
+        return session
+
     def delete(self, id: str) -> None:
         """Delete a domain."""
         self._client.request(method="DELETE", path=f"/api/domains/{encode_path_segment(id)}")

sendly/resources/emails.py

@@ -13,6 +13,8 @@ if TYPE_CHECKING:
         Body,
         EmailGetResponse,
         EmailListResponse,
+        EmailTestV1,
+        EmailV1,
         Query,
         SendEmailData,
         SuccessEmpty,
@@ -25,12 +27,42 @@ class EmailsResource:
     def __init__(self, client: Sendly) -> None:
         self._client = client
 
-    def send(
+    def send(self, body: Body, *, idempotency_key: str | None = None) -> EmailV1:
+        """Send one transactional email.
+
+        Posts to the versioned ``POST /api/v1/emails`` and returns the bare
+        receipt it answers 202 with: ``{id, status, to, from}``. ``status`` is a
+        real delivery state -- poll ``emails.get(id)`` for the events behind
+        it. Takes a single recipient; use ``cc``/``bcc`` to copy others.
+
+        Pass ``idempotency_key`` (1-255 chars) to dedupe replays for 24h.
+
+        Before 1.0 this posted to the legacy ``POST /api/emails``, which
+        answered with row ids and no delivery status and fanned an array
+        ``to`` out to several recipients. That behaviour is
+        :meth:`send_legacy`, unchanged.
+        """
+        response: EmailV1 = self._client.request(
+            method="POST",
+            path="/api/v1/emails",
+            body=body,
+            headers=idempotency_headers(idempotency_key),
+        )
+        return response
+
+    def send_legacy(
         self, body: Body, *, idempotency_key: str | None = None
     ) -> SendEmailData | list[SendEmailData]:
-        """Send a single transactional email.
+        """The pre-1.0 :meth:`send`: the legacy ``POST /api/emails``.
 
-        Pass ``idempotency_key`` (1-255 chars) to dedupe replays for 24h.
+        Returns the envelope's ``data``, ``{emails, timestamp}``, where
+        ``emails`` has one entry per recipient (an array ``to`` fans out to
+        several). Each entry is ``{contact: {id, email}, email}`` -- ``email``
+        being the id of the queued email record for that recipient. Reports no
+        delivery status of its own.
+
+        Kept as the escape hatch for a caller that depends on the fan-out or on
+        the envelope shape. New code should use :meth:`send`.
         """
         envelope = self._client.request(
             method="POST",
@@ -41,6 +73,21 @@ class EmailsResource:
         data: SendEmailData | list[SendEmailData] = self._client.unwrap(envelope)
         return data
 
+    def send_test(self, body: Body) -> EmailTestV1:
+        """Send a test email from the project's sandbox address.
+
+        Goes nowhere real: the sandbox address is the SENDER, resolved
+        server-side (naming a ``from`` is refused), and the mail lands in the
+        project owner's own verified inbox. This exercises rendering and the
+        send path without touching a live recipient or a sending reputation.
+        Read ``projects.get()["sandbox_address"]`` to know what it sends from
+        -- the response's ``sandbox: true`` says only that it was one.
+        """
+        response: EmailTestV1 = self._client.request(
+            method="POST", path="/api/v1/emails/test", body=body
+        )
+        return response
+
     def batch(self, body: Body, *, idempotency_key: str | None = None) -> BatchSendResponse:
         """Send a batch (up to 100) of transactional emails in one call."""
         response: BatchSendResponse = self._client.request(

sendly/resources/mailboxes.py

@@ -0,0 +1,75 @@
+"""Mailboxes resource."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sendly.resources._helpers import encode_path_segment
+
+if TYPE_CHECKING:
+    from sendly.client import Sendly
+    from sendly.types import AppPasswordList, MailboxDetail, MailboxList
+
+
+class MailboxesResource:
+    """Receiving mailboxes on the project's verified domains.
+
+    Read only, and deliberately so. Creating or deleting a mailbox, and minting
+    or revoking an app password, all resolve the acting project admin from the
+    session user. An API-key context carries no user, so those routes answer
+    401 to any key however broad its scopes -- the contract records this by
+    publishing ``SessionAuth`` without ``ApiKeyAuth`` on them. This SDK
+    authenticates only with API keys, so such methods could never succeed; they
+    are listed in ``tests/test_contract.py``'s ``NOT_SDK_CALLABLE`` instead.
+
+    The three reads below are the opposite case: their membership check is
+    conditional, so a key really can call them.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def list(self) -> MailboxList:
+        """Every mailbox on the project's domains, newest first.
+
+        Not paginated. A project is capped at 10 mailboxes, but the cap counts
+        only those holding (or mid-way to holding) a real account --
+        ``PROVISIONING``, ``ACTIVE`` and ``SUSPENDED``. ``FAILED`` rows are
+        excluded from it deliberately, so that a Stalwart outage cannot spend a
+        project's whole allowance, and they are still returned here: a project
+        with a run of failed provisions can therefore list more than 10.
+
+        This lists the mailboxes themselves, never their contents: received
+        messages are not part of the public API.
+        """
+        envelope = self._client.request(method="GET", path="/api/mailboxes")
+        records: MailboxList = self._client.unwrap(envelope)
+        return records
+
+    def get(self, id: str) -> MailboxDetail:
+        """One mailbox, with the IMAP/SMTP host, port and username to connect with.
+
+        The password is not included and is never returned here -- mailbox
+        credentials are app passwords, created from the dashboard and shown once.
+        """
+        envelope = self._client.request(
+            method="GET", path=f"/api/mailboxes/{encode_path_segment(id)}"
+        )
+        detail: MailboxDetail = self._client.unwrap(envelope)
+        return detail
+
+    def list_app_passwords(self, id: str) -> AppPasswordList:
+        """The app passwords still active on a mailbox -- metadata only.
+
+        Revoked ones are not returned: the route filters on ``revokedAt: null``,
+        so this is the set that can currently authenticate, not an audit
+        history.
+
+        ``lastFour`` is the only fragment of the secret that survives creation,
+        so this identifies a credential without being able to reconstruct it.
+        """
+        envelope = self._client.request(
+            method="GET", path=f"/api/mailboxes/{encode_path_segment(id)}/app-passwords"
+        )
+        records: AppPasswordList = self._client.unwrap(envelope)
+        return records

sendly/resources/projects.py

@@ -0,0 +1,33 @@
+"""Projects resource (``/api/v1``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sendly.client import Sendly
+    from sendly.types import ProjectRecordV1
+
+
+class ProjectsResource:
+    """The project the credential resolves to.
+
+    There is no ``create`` here. Creating a project resolves the owner from the
+    session user and refuses an API key with 401, so it is recorded in
+    ``tests/test_contract.py``'s ``NOT_SDK_CALLABLE`` rather than shipped as a
+    method that cannot work.
+    """
+
+    def __init__(self, client: Sendly) -> None:
+        self._client = client
+
+    def get(self) -> ProjectRecordV1:
+        """Read the current project.
+
+        Takes no id: the project is whichever one the API key belongs to.
+        Carries ``sandbox_address``, which is where a test send arrives --
+        without it a test send is undiscoverable, since the caller cannot say
+        where to look for it.
+        """
+        response: ProjectRecordV1 = self._client.request(method="GET", path="/api/v1/projects")
+        return response

sendly/types.py

@@ -42,6 +42,11 @@ EmailRecord = JSONDict
 EmailListResponse = JSONDict
 EmailGetResponse = JSONDict
 
+# The versioned send. Distinct from the legacy aliases above, which post to
+# ``/api/emails`` and answer with row ids and no delivery status.
+EmailV1 = JSONDict
+EmailTestV1 = JSONDict
+
 # ---------- Contacts ----------
 
 ContactRecord = JSONDict
@@ -52,6 +57,25 @@ ContactListResponse = JSONDict
 DomainRecord = JSONDict
 DomainListResponse = JSONDict
 DomainVerificationStatus = JSONDict
+#: ``{token, connectUrl, expiresAt}`` -- the link a person opens to finish setup.
+DomainSetupSession = JSONDict
+
+# ---------- Mailboxes ----------
+
+MailboxRecord = JSONDict
+#: A mailbox plus the IMAP/SMTP host, port and username a mail client needs.
+MailboxDetail = JSONDict
+AppPasswordRecord = JSONDict
+#: The list aliases are not decoration: inside ``MailboxesResource`` the name
+#: ``list`` is the resource's own method, so a bare ``list[MailboxRecord]``
+#: annotation resolves to that method and fails type checking. Naming the list
+#: types here sidesteps the shadowing and keeps the annotations readable.
+MailboxList = list[JSONDict]
+AppPasswordList = list[JSONDict]
+
+# ---------- Projects (v1) ----------
+
+ProjectRecordV1 = JSONDict
 
 # ---------- Templates ----------
 

{sendly_python-0.2.0.dist-info → sendly_python-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sendly-python
-Version: 0.2.0
+Version: 1.0.0
 Summary: Official Sendly Python SDK
 Project-URL: Homepage, https://sendly.now
 Project-URL: Documentation, https://docs.sendly.now
@@ -33,8 +33,8 @@ Description-Content-Type: text/markdown
 # Sendly Python SDK
 
 Official Python SDK for the [Sendly](https://sendly.now) REST API — transactional
-email, contacts, events, domains, templates, email verification, webhooks, and
-suppression.
+email, contacts, events, domains, templates, email verification, webhooks,
+suppression, and mailbox and project reads.
 
 [![CI](https://github.com/DevinoSolutions/sendly-python/actions/workflows/ci.yml/badge.svg)](https://github.com/DevinoSolutions/sendly-python/actions/workflows/ci.yml)
 
@@ -90,7 +90,7 @@ from sendly import Sendly
 
 sendly = Sendly()  # reads SENDLY_API_KEY
 
-result = sendly.emails.send(
+receipt = sendly.emails.send(
     {
         "from": "hello@yourdomain.com",
         "to": "customer@example.com",
@@ -98,9 +98,35 @@ result = sendly.emails.send(
         "body": "<h1>Thanks for signing up!</h1>",
     }
 )
-print(result["id"])
+
+# `status` is a real delivery state; poll `emails.get(receipt["id"])` for the
+# events behind it.
+print(receipt["id"], receipt["status"])
 ```
 
+### Upgrading from 0.x
+
+**1.0 repoints `emails.send` to the versioned `POST /api/v1/emails`.** It now
+takes one recipient (`cc`/`bcc` copy others) and returns the `202` receipt
+`{id, status, to, from}`, where `status` is a real delivery state. Before 1.0 it
+posted to the legacy `POST /api/emails`, fanned an array `to` out to several
+recipients, and returned `{emails, timestamp}` with no delivery status.
+
+The old behaviour is kept, unchanged, as `emails.send_legacy`. Two ways to
+upgrade:
+
+- **Keep the old shapes:** rename the call. `send(...)` → `send_legacy(...)`.
+  Done.
+- **Take the new default:** read the receipt instead of the envelope
+  (`receipt["id"]` / `receipt["status"]` in place of
+  `result["emails"][0]["email"]`), send to one recipient per call, and note that
+  failures now carry the v1 error fields (`err.error_code` is lowercase,
+  `err.request_id` and `err.field_errors` are set) — the exception classes are
+  the same, so `except` blocks stand.
+
+Nothing else changed shape. See [CHANGELOG.md](./CHANGELOG.md) for the full
+1.0.0 entry.
+
 Or pass the key explicitly:
 
 ```python
@@ -134,9 +160,15 @@ with Sendly() as sendly:
 ### Emails
 
 ```python
-# Single send (pass idempotency_key to dedupe replays for 24h)
-sendly.emails.send({"from": "a@you.com", "to": "b@them.com", "subject": "Hi", "body": "<p>Hi</p>"},
-                   idempotency_key="order-42-receipt")
+# Single send on /api/v1 (pass idempotency_key to dedupe replays for 24h).
+# One recipient in `to`; `cc` / `bcc` copy others. Returns {id, status, to, from}.
+receipt = sendly.emails.send({"from": "a@you.com", "to": "b@them.com", "subject": "Hi", "body": "<p>Hi</p>"},
+                             idempotency_key="order-42-receipt")
+
+# The pre-1.0 send: legacy /api/emails, an array `to` fans out, answers
+# {emails, timestamp} with no delivery status.
+sendly.emails.send_legacy({"from": "a@you.com", "to": ["b@them.com", "c@them.com"],
+                           "subject": "Hi", "body": "<p>Hi</p>"})
 
 # Batch send (up to 100)
 sendly.emails.batch({"emails": [{"from": "a@you.com", "to": "b@them.com", "subject": "Hi", "body": "<p>Hi</p>"}]})
@@ -180,9 +212,45 @@ sendly.domains.list()
 sendly.domains.get("d_123")
 sendly.domains.verify("d_123")
 sendly.domains.get_verification("d_123")
+sendly.domains.start_setup("d_123")  # -> {"token", "connectUrl", "expiresAt"}
 sendly.domains.delete("d_123")
 ```
 
+`start_setup` returns the hand-off as the API returns it. Open `connectUrl` in a
+browser to finish DNS setup at the registrar.
+
+### Mailboxes
+
+Reads only — see [What the SDK does not expose](#what-the-sdk-does-not-expose).
+
+```python
+sendly.mailboxes.list()          # -> [mailbox, ...], not paginated
+detail = sendly.mailboxes.get("mb_123")
+
+# `settings` carries the IMAP and SMTP host, port, security and username.
+print(detail["settings"]["imap"]["host"], detail["settings"]["imap"]["port"])
+
+# Metadata only — `lastFour` is the one fragment of the secret that survives
+# creation, so a credential can be identified but not rebuilt.
+for pw in sendly.mailboxes.list_app_passwords("mb_123"):
+    print(pw["name"], pw["lastFour"], pw["lastUsedAt"])
+```
+
+This lists the mailboxes themselves, never their contents — received messages
+are not part of the public API. The mailbox **password** is never returned by
+any of these reads; mailbox credentials are app passwords, created from the
+dashboard and shown once. `list_app_passwords` returns only the passwords that
+are still active — a revoked one drops out, so this is not an audit history.
+
+**The per-project cap is 10 mailboxes.** It counts only those holding, or
+mid-way to holding, a real account — `PROVISIONING`, `ACTIVE` and `SUSPENDED`.
+`FAILED` rows are excluded on purpose, so that a burst of failed provisions
+cannot eat a project's allowance and turn an outage into "you have reached your
+mailbox limit"; they are still returned by `list()`, so a project that has had
+failures can list more than 10. Exceeding the cap is a `409`
+(`SendlyConflictError`) from whatever creates the mailbox — which is not this
+SDK, since mailbox creation needs a signed-in user.
+
 ### Templates
 
 ```python
@@ -316,7 +384,7 @@ Available on the six cursor-paginated listings: `campaigns.iter_list`,
 `events.list_names` / `events.stats` return a bounded aggregate rather than a
 cursor, so they have no iterator.
 
-### Segments, workflows, events, analytics, usage
+### Segments, workflows, events, analytics, usage, projects
 
 ```python
 segment = sendly.segments.create({"name": "Power users", "type": "DYNAMIC",
@@ -343,8 +411,71 @@ sendly.analytics.top_campaigns({"limit": 5})
 
 usage = sendly.usage.get()
 print(usage["plan"], usage["monthly"])
+
+project = sendly.projects.get()
+print(project["sandbox_address"])
+```
+
+### Emails: `send` vs `send_legacy`
+
+The same split as `events.track` / `events.record`, resolved the other way
+round: since 1.0, `emails.send` IS the versioned send. It posts to
+`/api/v1/emails` and answers `202` with `{id, status, to, from}`, where `status`
+is a real delivery state you can poll on. It takes one recipient — use
+`cc`/`bcc` to copy others — instead of fanning an array out.
+`emails.send_legacy` is the pre-1.0 send on `POST /api/emails`, unchanged: row
+ids, **no delivery status**, array `to` fanned out. See
+[Upgrading from 0.x](#upgrading-from-0x).
+
+```python
+receipt = sendly.emails.send(
+    {"to": "user@example.com", "subject": "hi", "body": "<p>hi</p>"},
+    idempotency_key="order-42",
+)
+print(receipt["status"])
 ```
 
+### Test sends
+
+`emails.send_test` proves the send path works without touching a live
+recipient. Two things about it are easy to get backwards:
+
+- **The sandbox address is the *sender*, not the destination.** It is resolved
+  server-side, and naming a `from` yourself is **refused** rather than ignored —
+  so a request expecting a different sender never gets a success it would
+  misread. `projects.get()["sandbox_address"]` tells you what it sends *from*;
+  the response's `from` says the same thing.
+- **It lands in the project owner's own inbox.** `to` is optional and defaults
+  to the project owner's verified account email, which is the only address a
+  sandbox send may reach — any other value is refused.
+
+```python
+test = sendly.emails.send_test({"subject": "hi", "body": "<p>hi</p>"})
+print(test["to"], test["from"], test["sandbox"])  # sandbox is always True here
+```
+
+Everything else applies unchanged: the same rendering, the same content scan,
+and the same daily and trust-tier caps as a real send. It takes no
+`idempotency_key` — the recipient is the caller's own inbox, a daily cap already
+bounds it, and "send me another one" is the normal second call rather than a
+mistake worth deduplicating.
+
+### What the SDK does not expose
+
+An API key resolves no user, and a handful of routes resolve the acting project
+admin from the session before reading any scope — so they answer `401` to any
+key, however broad its scopes. The contract states this: those operations publish
+`SessionAuth` without `ApiKeyAuth`.
+
+Rather than ship methods that could never succeed, they are listed in
+`tests/test_contract.py`'s `NOT_SDK_CALLABLE` and checked against the spec's own
+declarations, in both directions. They are: creating and deleting a mailbox,
+creating and revoking an app password, all four API-key operations, and creating
+a project. Use the dashboard or an OAuth connection for those.
+
+Mailbox **reads** are exposed — their membership check is conditional, so a key
+really can call them.
+
 ## Error handling
 
 Every non-2xx response raises a `SendlyError` subclass carrying `status_code`,
@@ -456,7 +587,7 @@ comparison and reject a stale or non-numeric timestamp.
 
 ## Async
 
-Only a synchronous client ships in v0.1. An `httpx.AsyncClient`-backed async
+Only a synchronous client ships today. An `httpx.AsyncClient`-backed async
 variant is planned.
 
 ## Development
@@ -474,6 +605,45 @@ pytest
 
 Tests are fully hermetic (httpx `MockTransport`) and hit no network.
 
+### Refreshing the vendored OpenAPI spec
+
+`tests/fixtures/openapi.json` is a committed snapshot of Sendly's OpenAPI
+contract; the contract suite (`tests/test_contract.py`) verifies the SDK surface
+against it and never touches the network.
+
+`scripts/sync_spec.py` requires `SENDLY_OPENAPI_URL`. There is **no default**,
+and in particular it does not default to production:
+
+```bash
+SENDLY_OPENAPI_URL=/path/to/sendly/apps/web/openapi/openapi.json \
+    python scripts/sync_spec.py
+
+SENDLY_OPENAPI_URL=... python scripts/sync_spec.py --check   # is the copy stale?
+```
+
+`SENDLY_OPENAPI_URL` accepts a filesystem path (the normal case — the committed
+contract in the Sendly platform monorepo at `apps/web/openapi/openapi.json`) or
+an `http(s)://` URL of a local or staging API. Running the script with it unset
+exits non-zero and prints what to set.
+
+**Do not point it at `https://api.sendly.now`.** Vendoring the spec from the
+deployed API makes the SDK mirror what is *running* rather than what the repo
+*declares*, so any drift between the platform's code and its committed contract
+is laundered into "correct" on the way in — the SDK re-vendors to match the
+deployment and the mismatch vanishes silently. That destroys the vendored spec's
+only job: it is the fixed reference `tests/test_contract.py` compares against, so
+an SDK synced from production can no longer detect the very drift it exists to
+catch. It is also unreproducible and unreviewable.
+
+This is not hard-blocked — "what does production actually serve?" is a legitimate
+one-off. Doing it prints an unmissable warning (and a CI annotation), because
+*quiet* is what made the old default dangerous, not the host. Never commit the
+result, and never wire that host into CI or any unattended job.
+
+`--check` is the exception to the fail-loud rule: it never runs unattended
+against an unknown source, so with `SENDLY_OPENAPI_URL` unset it skips with a
+notice and exits 0, keeping CI and fork pull requests green.
+
 ## Documentation
 
 Full API reference: <https://docs.sendly.now>

{sendly_python-0.2.0.dist-info → sendly_python-1.0.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-sendly/__init__.py,sha256=AQ1Yu-7DFJ9LQz_-w6RSk_u25U-oITJGwRwJ1M9v-9s,2487
-sendly/client.py,sha256=GRII4hPJwBNPDPL9i84y3YwtPvRgT5CVXGkBgL1r7IY,11356
+sendly/__init__.py,sha256=BVroJYUG_CgQ3NB1fpDsUQsRP9i37q2bwYgv0jsYM2E,2755
+sendly/client.py,sha256=zrN7isw153Adh2GPKx3CAA6AMkXhlai5p5i4uD3FO0I,11645
 sendly/errors.py,sha256=urF33X-d39OEiasLh6C7PlrrUmmrS3XIMvFYj20rUy8,7002
 sendly/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sendly/types.py,sha256=ggxBcjjkdgmJEPNk04tFdrLoTggOFZuj2kcqsvBPIXk,3140
+sendly/types.py,sha256=mnuTukJ6O31qCeD46EHzgATY7BQK2PX_ZMNPFGrQkP8,4065
 sendly/webhook_utils.py,sha256=epmK860gLknaElxfXdVD3h_9ASkjWQsyl1exUC8qBL4,4762
 sendly/resources/__init__.py,sha256=Nf7zjcFjsztXsGtrvxq3KGacX7SwDgSf3r0nAVHLvPY,73
 sendly/resources/_helpers.py,sha256=W6AlzXuqH53Vk1dIxuQm_-Vpq9gmZvLzKPRionjH9wQ,550
@@ -10,10 +10,12 @@ sendly/resources/_pagination.py,sha256=dp0rNKruPBtCgPZT8ZPzmGGVpbFN2SCQdV4m9-qlL
 sendly/resources/analytics.py,sha256=7w4A-w-dXZkgLi2j1dO6X88V-T9itlF0rWjdLiFAStc,1770
 sendly/resources/campaigns.py,sha256=vcpwNa51ncSuieGYUhwcMLpzB-cRrf6qZ1RXB0iVmo8,5293
 sendly/resources/contacts.py,sha256=7DwbGXvwUw8Tf5WfIUU0ZEvJs3ZBIqulkbN_Ke0-ilc,3274
-sendly/resources/domains.py,sha256=m69uHKGhmtVlzo3QAmMmMHvmpc0T3JAv5izTWxDpxhc,2368
-sendly/resources/emails.py,sha256=3LHxre7lJfa_6z1F9Rzmdh5QDwhYpwTWaAJZGVCLsY8,2390
+sendly/resources/domains.py,sha256=2vf5hibDvL_1nCIrS17NWXFRpinTroRf4xbFMHYnx6E,3143
+sendly/resources/emails.py,sha256=KDipwAqMJVWl52w8JjbHrLL4AFCgphOoZdG_tHrtufo,4599
 sendly/resources/events.py,sha256=8aFUPa1iTVqEUnhwnpcsfE7_JyirtBw7POgadk4hhMs,3926
 sendly/resources/lists.py,sha256=KXHOW_UQMEdXoat9mHJ4mJKmvrzk0AVQ3k8273GRIH4,2189
+sendly/resources/mailboxes.py,sha256=tlXyrnsx6xpyAb3oyt2qbpK1Ri5nE4kG0AQMia4loHE,3200
+sendly/resources/projects.py,sha256=g694LMqh7cI2qCD1nZ6QQEfOvT42A8EBltbEJawc2P8,1096
 sendly/resources/segments.py,sha256=dc4KzorLRSfkZe63J144wm6W5bjVaDA4U8ID7HyyK_U,3944
 sendly/resources/suppression.py,sha256=NNIhmkq1bC2qe1i4nSGZDCvuGBT7JddIrkXlVP1qASU,1716
 sendly/resources/templates.py,sha256=DhewoFRqxGfjo0brAtG9rI6GHTCWNv4J01TylB4luXI,2104
@@ -21,7 +23,7 @@ sendly/resources/usage.py,sha256=kMcoAeGAnCilLyNihKBFcfFf-CVoSlpKUmTtlfDWAMA,879
 sendly/resources/verify.py,sha256=QyVNmrzZ4Nj87YWxMPt9wlovcCyZutV9eGmn49c0EEg,818
 sendly/resources/webhooks.py,sha256=rooES4-HMy7mhC9D1bzVDUpJ34cf1yZkVilkoWEIBEQ,2763
 sendly/resources/workflows.py,sha256=42j-227rFUkWjA6DYmKYxqc6Bfdpxy5IHDuDgZrUO5k,5381
-sendly_python-0.2.0.dist-info/METADATA,sha256=qP01SKUw9EeFuqAMVvnnyPTMLrgs-nwZZJlU9lbAn2w,16456
-sendly_python-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sendly_python-0.2.0.dist-info/licenses/LICENSE,sha256=TZHT_f_vV-xujWjSy7EkTybNT6iivrfGHLd-rR1Xl7c,1073
-sendly_python-0.2.0.dist-info/RECORD,,
+sendly_python-1.0.0.dist-info/METADATA,sha256=Nlcp2a2JuMjgQAOjCpvOLWpshDXBZdfwQEgxiwN4DfI,24681
+sendly_python-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sendly_python-1.0.0.dist-info/licenses/LICENSE,sha256=TZHT_f_vV-xujWjSy7EkTybNT6iivrfGHLd-rR1Xl7c,1073
+sendly_python-1.0.0.dist-info/RECORD,,