unitpost 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e92552a542bfa040de967b8d88af9aba31d6edbd0001768633793263a0728bc2
-  data.tar.gz: 7b49579c2d34abdb8efb2d9b01382edb1b1f646467b1c7fe33573c65ce89176a
+  metadata.gz: 9e9a3528c250381235631c5bb39f42374542bcccd093cdfda7fe1ea53a6f8173
+  data.tar.gz: b59b18ef0a50321e22ede9e3e090e1d4e92389f7abd38a1de37cd47797c5723b
 SHA512:
-  metadata.gz: f35532690b25c113997d1b594db3bf849dc4f60853f2c290eadb95940958b3c5084c59ef71320486728a9a97f666b21a1541599a972edc5e670a609dc640fddf
-  data.tar.gz: d8d884f80928d12d3023886986c641de6221886a1b0bcde7ab9005a9971f48257aa8df58e8bc7ea5126d3213231dd08cb7ef6dbd41312489bf07127f08b947b9
+  metadata.gz: 9a3479a052e24411e80050aa8ca471ba06d61f26d2620ffe789c6257a039f6698fd17e2a43bb62adfd63802ab2c7691f2f99bed5301d8191ed99e59b2a2d7aaf
+  data.tar.gz: 822df4364aef7e1ffc2aec4bbdda76f6e07645ddcd6092b6e09f196a636a127e1b46ae4b81c317429a792c4d68ff90c4a4e4282162a5d956cca3239510f2a9ab

data/README.md

@@ -51,15 +51,16 @@ key at [unitpost.com → Settings → API keys](https://www.unitpost.com).
 
 | Accessor | Covers |
 | --- | --- |
-| `emails` | Send, batch, list, get, update, stats, inbound (`received_*`) |
+| `email` | Send, batch, list, get, update, stats, inbound (`received_*`) |
+| `email.topics` | Topics + contact topic prefs |
+| `email.campaigns` | Draft, schedule, send, pause/resume |
+| `email.templates` | Template CRUD |
+| `email.domains` | Domains + verify |
+| `sms` | Send, get, list, `brands`, `numbers`, contact SMS consent. Available on paid plans: on the free plan `send` returns a `403` with code `limit_reached`, while the reads keep working. |
 | `contacts` | CRUD, import jobs |
 | `contact_fields` | Custom field definitions |
 | `segments` | Segments + membership |
-| `topics` | Topics + contact topic prefs |
-| `campaigns` | Draft, schedule, send, pause/resume |
-| `templates` | Template CRUD |
 | `brand_kits` | Brand kit |
-| `domains` | Domains + verify |
 | `webhooks` | Endpoints + `verify` |
 | `api_keys` | API key management |
 | `suppressions` | Suppression list |
@@ -84,7 +85,7 @@ complaints are added automatically; you can also add your own:
 unitpost.suppressions.create({ email: "bounced@example.com", reason: "manual" })
 unitpost.suppressions.create({ emails: ["a@example.com", "b@example.com"] })
 
-# Look one up by id or email; list (optionally filter scope); un-suppress.
+# Look one up by id or email; list your own; un-suppress.
 unitpost.suppressions.get("bounced@example.com")
 unitpost.suppressions.list_all.each { |s| puts "#{s["email"]} #{s["reason"]}" }
 unitpost.suppressions.delete("bounced@example.com")
@@ -110,9 +111,44 @@ Or from the client (Resend-style alias):
 event = client.webhooks.verify(payload: raw_body, secret: secret, headers: request.headers)
 ```
 
+## Receive a text and answer it
+
+US toll-free, 10DLC and Canadian numbers take replies (`two_way` is true on
+`sms.numbers`). Subscribe a webhook to `sms.received`, skip STOP and texts
+Unitpost already answered, read the conversation with `participant`, and answer
+without `from` so the reply leaves from the number they texted.
+
+```ruby
+require "unitpost"
+
+unitpost = Unitpost::Client.new # reads UNITPOST_API_KEY
+
+# Your webhook endpoint, subscribed to sms.received. Pass the RAW body.
+def on_webhook(unitpost, raw_body, headers)
+  event = Unitpost.verify_webhook(
+    payload: raw_body,
+    secret: ENV.fetch("UNITPOST_WEBHOOK_SECRET"), # whsec_…
+    headers: headers
+  )
+  return unless event["type"] == "sms.received"
+
+  reply = event["data"]
+  return if reply["keyword"] == "OPT_OUT" || reply["auto_replied"] # STOP, or already answered
+
+  # The whole conversation with this person, both directions, newest first.
+  # Other filters: direction, status, from, to, contact_id, campaign_id,
+  # created_after, created_before.
+  history = unitpost.sms.list(participant: reply["from"], limit: 20)
+  answer = your_agent(history.data, reply["body"].to_s)
+
+  # No :from: the answer goes out from the number they texted.
+  unitpost.sms.send({ to: reply["from"], body: answer })
+end
+```
+
 ## Idempotency
 
-`emails.send` and `emails.batch` are safe to retry by default — when you don't
+`email.send` and `email.batch` are safe to retry by default — when you don't
 pass `idempotency_key:`, the SDK generates one so an automatic retry can't
 double-send. Pass your own to dedupe across separate calls:
 
@@ -132,7 +168,7 @@ Transient failures are retried automatically: `429`, `5xx`, and transport errors
 `Retry-After` is honored; otherwise exponential backoff with full jitter is used.
 Client errors (`401`/`403`/`404`/`409`/`422`) are never retried. Only requests
 safe to replay are retried: `GET`s and writes carrying an idempotency key (which
-`emails.send` and `emails.batch` always do); any other keyless write is never
+`email.send` and `email.batch` always do); any other keyless write is never
 auto-retried.
 
 ```ruby
@@ -145,7 +181,8 @@ unitpost = Unitpost::Client.new(max_retries: 2, retry_base_delay: 0.5, max_retry
 | | |
 | --- | --- |
 | Docs + API reference | https://www.unitpost.com/docs |
-| Product / SMTP / MCP guides | https://www.unitpost.com/guides |
+| Product guides | https://www.unitpost.com/guides |
+| SMTP | https://www.unitpost.com/docs/smtp |
 | OpenAPI JSON | https://www.unitpost.com/api/v1/openapi.json |
 | LLM index | https://www.unitpost.com/llms.txt |
 | Dashboard / API keys | https://www.unitpost.com |
@@ -153,7 +190,7 @@ unitpost = Unitpost::Client.new(max_retries: 2, retry_base_delay: 0.5, max_retry
 | Template gallery | https://www.unitpost.com/templates/gallery |
 | Playground | https://www.unitpost.com/playground |
 | Migration Assistant | https://www.unitpost.com/migration |
-| MCP + Agent Skills | https://www.unitpost.com/guides#ai-mcp · https://www.unitpost.com/guides#ai-skills |
+| MCP + Agent Skills | https://www.unitpost.com/docs/ai/mcp · https://www.unitpost.com/docs/ai/skills |
 | Support | support@unitpost.com |
 
 ## License

data/lib/unitpost/client.rb

@@ -15,9 +15,9 @@ module Unitpost
   #     puts result.data["id"]
   #   end
   class Client
-    attr_reader :email, :contacts, :contact_fields, :segments,
+    attr_reader :email, :sms, :contacts, :contact_fields, :segments,
                 :brand_kits, :webhooks, :api_keys, :suppressions,
-                :usage
+                :jobs, :usage
 
     def initialize(api_key: nil, base_url: nil, timeout: 30, headers: {}, adapter: nil, stubs: nil,
                    max_retries: 2, retry_base_delay: 0.5, max_retry_delay: 20.0, sleeper: nil)
@@ -34,6 +34,9 @@ module Unitpost
         sleeper: sleeper
       )
       @email = Resources::Email.new(http)
+      # SMS channel. Available on paid plans: on the free plan `send` returns
+      # a 403 with code `limit_reached`; reads keep working.
+      @sms = Resources::Sms.new(http)
       @contacts = Resources::Contacts.new(http)
       @contact_fields = Resources::ContactFields.new(http)
       @segments = Resources::Segments.new(http)
@@ -43,6 +46,7 @@ module Unitpost
       @suppressions = Resources::Suppressions.new(http)
       # NOTE (pre-launch): `events` is intentionally absent while the
       # custom-events surface is behind the launch gate.
+      @jobs = Resources::Jobs.new(http)
       @usage = Resources::Usage.new(http)
     end
   end

data/lib/unitpost/generated/operations.rb

@@ -104,7 +104,7 @@ module Unitpost
       query_params: [],
       has_body: false,
       request_schema: nil,
-      response_schema: nil,
+      response_schema: "Job",
       is_list: false,
       list_item_schema: nil
     },
@@ -164,6 +164,20 @@ module Unitpost
       is_list: false,
       list_item_schema: nil
     },
+    {
+      operation_id: "contacts.cancelImport",
+      resource: "contacts",
+      method_name: "cancelImport",
+      http_method: "POST",
+      path: "/contacts/imports/{id}/cancel",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "ContactImport",
+      is_list: false,
+      list_item_schema: nil
+    },
     {
       operation_id: "contacts.create",
       resource: "contacts",
@@ -410,8 +424,8 @@ module Unitpost
       path: "/email/campaigns/{id}/send",
       path_params: ["id"],
       query_params: [],
-      has_body: false,
-      request_schema: nil,
+      has_body: true,
+      request_schema: "CampaignSend",
       response_schema: "Campaign",
       is_list: false,
       list_item_schema: nil
@@ -486,6 +500,20 @@ module Unitpost
       is_list: false,
       list_item_schema: nil
     },
+    {
+      operation_id: "email.domains.diagnose",
+      resource: "email.domains",
+      method_name: "diagnose",
+      http_method: "GET",
+      path: "/email/domains/{id}/diagnose",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "DomainDiagnosis",
+      is_list: false,
+      list_item_schema: nil
+    },
     {
       operation_id: "email.domains.get",
       resource: "email.domains",
@@ -710,6 +738,20 @@ module Unitpost
       is_list: true,
       list_item_schema: "Template"
     },
+    {
+      operation_id: "email.templates.testSend",
+      resource: "email.templates",
+      method_name: "testSend",
+      http_method: "POST",
+      path: "/email/templates/{id}/test-send",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "TemplateTestSend",
+      response_schema: "TemplateTestSendResult",
+      is_list: false,
+      list_item_schema: nil
+    },
     {
       operation_id: "email.templates.update",
       resource: "email.templates",
@@ -773,7 +815,7 @@ module Unitpost
       http_method: "GET",
       path: "/email/topics",
       path_params: [],
-      query_params: ["limit", "after", "before"],
+      query_params: ["limit", "after", "before", "archived"],
       has_body: false,
       request_schema: nil,
       response_schema: nil,
@@ -808,20 +850,6 @@ module Unitpost
       is_list: false,
       list_item_schema: nil
     },
-    {
-      operation_id: "email.topics.setTopic",
-      resource: "email.topics",
-      method_name: "setTopic",
-      http_method: "PUT",
-      path: "/contacts/{id}/topics",
-      path_params: ["id"],
-      query_params: [],
-      has_body: true,
-      request_schema: "ContactTopicSet",
-      response_schema: "ContactTopic",
-      is_list: false,
-      list_item_schema: nil
-    },
     {
       operation_id: "email.topics.update",
       resource: "email.topics",
@@ -850,6 +878,20 @@ module Unitpost
       is_list: false,
       list_item_schema: nil
     },
+    {
+      operation_id: "jobs.get",
+      resource: "jobs",
+      method_name: "get",
+      http_method: "GET",
+      path: "/jobs/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "Job",
+      is_list: false,
+      list_item_schema: nil
+    },
     {
       operation_id: "segments.addMember",
       resource: "segments",
@@ -962,6 +1004,426 @@ module Unitpost
       is_list: false,
       list_item_schema: nil
     },
+    {
+      operation_id: "sms.brands",
+      resource: "sms",
+      method_name: "brands",
+      http_method: "GET",
+      path: "/sms/brands",
+      path_params: [],
+      query_params: ["limit", "after", "before"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "SmsBrand"
+    },
+    {
+      operation_id: "sms.campaigns.cancel",
+      resource: "sms.campaigns",
+      method_name: "cancel",
+      http_method: "POST",
+      path: "/sms/campaigns/{id}/cancel",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.create",
+      resource: "sms.campaigns",
+      method_name: "create",
+      http_method: "POST",
+      path: "/sms/campaigns",
+      path_params: [],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsCampaignCreate",
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.delete",
+      resource: "sms.campaigns",
+      method_name: "delete",
+      http_method: "DELETE",
+      path: "/sms/campaigns/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.get",
+      resource: "sms.campaigns",
+      method_name: "get",
+      http_method: "GET",
+      path: "/sms/campaigns/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.list",
+      resource: "sms.campaigns",
+      method_name: "list",
+      http_method: "GET",
+      path: "/sms/campaigns",
+      path_params: [],
+      query_params: ["limit", "after", "before", "archived"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "SmsCampaign"
+    },
+    {
+      operation_id: "sms.campaigns.pause",
+      resource: "sms.campaigns",
+      method_name: "pause",
+      http_method: "POST",
+      path: "/sms/campaigns/{id}/pause",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.reschedule",
+      resource: "sms.campaigns",
+      method_name: "reschedule",
+      http_method: "POST",
+      path: "/sms/campaigns/{id}/reschedule",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsCampaignReschedule",
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.resume",
+      resource: "sms.campaigns",
+      method_name: "resume",
+      http_method: "POST",
+      path: "/sms/campaigns/{id}/resume",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.send",
+      resource: "sms.campaigns",
+      method_name: "send",
+      http_method: "POST",
+      path: "/sms/campaigns/{id}/send",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsCampaignSend",
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.update",
+      resource: "sms.campaigns",
+      method_name: "update",
+      http_method: "PATCH",
+      path: "/sms/campaigns/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsCampaignUpdate",
+      response_schema: "SmsCampaign",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.campaigns.validate",
+      resource: "sms.campaigns",
+      method_name: "validate",
+      http_method: "GET",
+      path: "/sms/campaigns/{id}/validate",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsCampaignValidation",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.get",
+      resource: "sms",
+      method_name: "get",
+      http_method: "GET",
+      path: "/sms/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "Sms",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.list",
+      resource: "sms",
+      method_name: "list",
+      http_method: "GET",
+      path: "/sms",
+      path_params: [],
+      query_params: ["limit", "after", "before", "direction", "status", "from", "to", "participant", "contact_id", "campaign_id", "created_after", "created_before"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "Sms"
+    },
+    {
+      operation_id: "sms.numbers",
+      resource: "sms",
+      method_name: "numbers",
+      http_method: "GET",
+      path: "/sms/numbers",
+      path_params: [],
+      query_params: ["limit", "after", "before"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "SmsNumber"
+    },
+    {
+      operation_id: "sms.recordSmsConsent",
+      resource: "sms",
+      method_name: "recordSmsConsent",
+      http_method: "POST",
+      path: "/contacts/{id}/sms-consent",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsConsentRecord",
+      response_schema: "SmsConsentRecorded",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.send",
+      resource: "sms",
+      method_name: "send",
+      http_method: "POST",
+      path: "/sms",
+      path_params: [],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsSend",
+      response_schema: "Sms",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.smsConsent",
+      resource: "sms",
+      method_name: "smsConsent",
+      http_method: "GET",
+      path: "/contacts/{id}/sms-consent",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsConsent",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.stats",
+      resource: "sms",
+      method_name: "stats",
+      http_method: "GET",
+      path: "/sms/stats",
+      path_params: [],
+      query_params: ["days"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsStats",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.templates.create",
+      resource: "sms.templates",
+      method_name: "create",
+      http_method: "POST",
+      path: "/sms/templates",
+      path_params: [],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsTemplateCreate",
+      response_schema: "SmsTemplate",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.templates.delete",
+      resource: "sms.templates",
+      method_name: "delete",
+      http_method: "DELETE",
+      path: "/sms/templates/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.templates.get",
+      resource: "sms.templates",
+      method_name: "get",
+      http_method: "GET",
+      path: "/sms/templates/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "SmsTemplate",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.templates.list",
+      resource: "sms.templates",
+      method_name: "list",
+      http_method: "GET",
+      path: "/sms/templates",
+      path_params: [],
+      query_params: ["limit", "after", "before"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "SmsTemplate"
+    },
+    {
+      operation_id: "sms.templates.update",
+      resource: "sms.templates",
+      method_name: "update",
+      http_method: "PATCH",
+      path: "/sms/templates/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsTemplateUpdate",
+      response_schema: "SmsTemplate",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.topics.create",
+      resource: "sms.topics",
+      method_name: "create",
+      http_method: "POST",
+      path: "/sms/topics",
+      path_params: [],
+      query_params: [],
+      has_body: true,
+      request_schema: "TopicCreate",
+      response_schema: "Topic",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.topics.delete",
+      resource: "sms.topics",
+      method_name: "delete",
+      http_method: "DELETE",
+      path: "/sms/topics/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.topics.get",
+      resource: "sms.topics",
+      method_name: "get",
+      http_method: "GET",
+      path: "/sms/topics/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "Topic",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.topics.list",
+      resource: "sms.topics",
+      method_name: "list",
+      http_method: "GET",
+      path: "/sms/topics",
+      path_params: [],
+      query_params: ["limit", "after", "before", "archived"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "Topic"
+    },
+    {
+      operation_id: "sms.topics.update",
+      resource: "sms.topics",
+      method_name: "update",
+      http_method: "PATCH",
+      path: "/sms/topics/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "TopicUpdate",
+      response_schema: "Topic",
+      is_list: false,
+      list_item_schema: nil
+    },
+    {
+      operation_id: "sms.update",
+      resource: "sms",
+      method_name: "update",
+      http_method: "PATCH",
+      path: "/sms/{id}",
+      path_params: ["id"],
+      query_params: [],
+      has_body: true,
+      request_schema: "SmsPatch",
+      response_schema: "Sms",
+      is_list: false,
+      list_item_schema: nil
+    },
     {
       operation_id: "suppressions.create",
       resource: "suppressions",
@@ -1088,6 +1550,34 @@ module Unitpost
       is_list: true,
       list_item_schema: "Webhook"
     },
+    {
+      operation_id: "webhooks.listDeliveries",
+      resource: "webhooks",
+      method_name: "listDeliveries",
+      http_method: "GET",
+      path: "/webhooks/{id}/deliveries",
+      path_params: ["id"],
+      query_params: ["limit", "after", "before"],
+      has_body: false,
+      request_schema: nil,
+      response_schema: nil,
+      is_list: true,
+      list_item_schema: "WebhookDelivery"
+    },
+    {
+      operation_id: "webhooks.rotateSecret",
+      resource: "webhooks",
+      method_name: "rotateSecret",
+      http_method: "POST",
+      path: "/webhooks/{id}/rotate-secret",
+      path_params: ["id"],
+      query_params: [],
+      has_body: false,
+      request_schema: nil,
+      response_schema: "WebhookSecretRotated",
+      is_list: false,
+      list_item_schema: nil
+    },
     {
       operation_id: "webhooks.test",
       resource: "webhooks",

data/lib/unitpost/generated/sms_models.rb

@@ -0,0 +1,222 @@
+# Code generated by @unitpost/sdk-codegen from the public OpenAPI spec.
+# DO NOT EDIT BY HAND. Run `npm run sdk:generate` to regenerate.
+# Source of truth: apps/web/docs/openapi.json (itself derived from the API's
+# Zod schemas and CI-gated for drift).
+
+# frozen_string_literal: true
+
+module Unitpost
+  module Generated
+    # Why a message was skipped before reaching the carrier. `out_of_reach`: no
+    # sender covers the recipient's country; `unsupported_country`: no
+    # compliance rule for the country yet, or SMS to that country is paused for
+    # now (every message, transactional included, until it resumes); `no_phone`:
+    # the contact has no SMS handle; `opted_out`: STOP / suppression /
+    # unreachable; `no_marketing_consent`: marketing without express consent;
+    # `quiet_hours_deferred`: delayed to the recipient's local window;
+    # `sender_not_active`: the sender lost approval.
+    module SmsSkipReason
+      OUT_OF_REACH = "out_of_reach"
+      UNSUPPORTED_COUNTRY = "unsupported_country"
+      NO_PHONE = "no_phone"
+      OPTED_OUT = "opted_out"
+      NO_MARKETING_CONSENT = "no_marketing_consent"
+      QUIET_HOURS_DEFERRED = "quiet_hours_deferred"
+      SENDER_NOT_ACTIVE = "sender_not_active"
+      ALL = [OUT_OF_REACH, UNSUPPORTED_COUNTRY, NO_PHONE, OPTED_OUT, NO_MARKETING_CONSENT, QUIET_HOURS_DEFERRED, SENDER_NOT_ACTIVE].freeze
+    end
+
+    # The `SmsError` object from the public API.
+    # @!attribute code Why a message was skipped before reaching the carrier. `out_of_reach`: no sender covers the recipient's country; `unsupported_country`: no compliance rule for the country yet, or SMS to that country is paused for now (every message, transactional included, until it resumes); `no_phone`: the contact has no SMS handle; `opted_out`: STOP / suppression / unreachable; `no_marketing_consent`: marketing without express consent; `quiet_hours_deferred`: delayed to the recipient's local window; `sender_not_active`: the sender lost approval.
+    # @!attribute message Human-readable sentence for `code`.
+    SmsError = Struct.new(:code, :message, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [SmsError, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          code: h["code"],
+          message: h["message"]
+        )
+      end
+    end
+
+    # The `SmsNumberUseCase` object from the public API.
+    # @!attribute name
+    # @!attribute category
+    SmsNumberUseCase = Struct.new(:name, :category, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [SmsNumberUseCase, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          name: h["name"],
+          category: h["category"]
+        )
+      end
+    end
+
+    # The `SmsNumberSenderIdGroupCountriesItem` object from the public API.
+    # @!attribute country ISO-3166 alpha-2.
+    # @!attribute status One of: pending, action_required, active, rejected, released.
+    SmsNumberSenderIdGroupCountriesItem = Struct.new(:country, :status, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [SmsNumberSenderIdGroupCountriesItem, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          country: h["country"],
+          status: h["status"]
+        )
+      end
+    end
+
+    # The `SmsNumberSenderIdGroup` object from the public API.
+    # @!attribute name The Sender ID string recipients see.
+    # @!attribute brand_id The brand that owns this Sender ID.
+    # @!attribute countries Every country this Sender ID is enabled for, with each country's own status.
+    SmsNumberSenderIdGroup = Struct.new(:name, :brand_id, :countries, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [SmsNumberSenderIdGroup, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          name: h["name"],
+          brand_id: h["brand_id"],
+          countries: (h["countries"] || []).map { |x| SmsNumberSenderIdGroupCountriesItem.from_hash(x) }
+        )
+      end
+    end
+
+    # The `Sms` object from the public API.
+    # @!attribute object Always "sms".
+    # @!attribute id
+    # @!attribute to
+    # @!attribute from
+    # @!attribute direction One of: outbound, inbound.
+    # @!attribute status One of: queued, scheduled, sending, sent, delivered, failed, suppressed, canceled, received.
+    # @!attribute type One of: transactional, marketing.
+    # @!attribute body
+    # @!attribute segments Billed units. Outbound: segments. Inbound: 1 when the received text was charged (1¢ in the US and Canada), else 0.
+    # @!attribute in_reply_to Inbound only: your text this reply answers (`sms_…`), when the carrier says which. Null otherwise.
+    # @!attribute received_at Inbound only: when the reply reached Unitpost. Order a conversation by this; carriers don't guarantee order. Null on outbound.
+    # @!attribute looks_like_opt_out Inbound only: the text reads like a request to stop texting ("please stop texting me") but was not an opt-out keyword, so no opt-out was recorded. Decide whether to record one (POST /v1/contacts/{id}/sms-consent, action opt_out). False for an exact keyword such as STOP (already recorded) and on outbound.
+    # @!attribute country
+    # @!attribute scheduled_at
+    # @!attribute last_error Legacy free-text error. Prefer `error.code`.
+    # @!attribute error Set on `suppressed` messages: the stable skip reason and its sentence. Null otherwise.
+    # @!attribute created_at
+    Sms = Struct.new(:object, :id, :to, :from, :direction, :status, :type, :body, :segments, :in_reply_to, :received_at, :looks_like_opt_out, :country, :scheduled_at, :last_error, :error, :created_at, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [Sms, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          object: h["object"],
+          id: h["id"],
+          to: h["to"],
+          from: h["from"],
+          direction: h["direction"],
+          status: h["status"],
+          type: h["type"],
+          body: h["body"],
+          segments: h["segments"],
+          in_reply_to: h["in_reply_to"],
+          received_at: h["received_at"],
+          looks_like_opt_out: h["looks_like_opt_out"],
+          country: h["country"],
+          scheduled_at: h["scheduled_at"],
+          last_error: h["last_error"],
+          error: SmsError.from_hash(h["error"]),
+          created_at: h["created_at"]
+        )
+      end
+    end
+
+    # The `SmsBrand` object from the public API.
+    # @!attribute object Always "sms_brand".
+    # @!attribute id Prefixed brand id, e.g. `sbrand_…`.
+    # @!attribute name Public-facing brand name.
+    # @!attribute legal_name Registered legal entity name.
+    # @!attribute website Brand website URL.
+    # @!attribute domain Registrable domain derived from the website. The brand contact email must be on this domain.
+    # @!attribute contact_email
+    # @!attribute status `incomplete` and `action_required` need the customer to act in the dashboard; `pending` is waiting on the carrier. One of: incomplete, ready, pending, action_required, verified, rejected, archived.
+    # @!attribute missing Human-readable list of what is still required before this brand can back a number. Empty when nothing is missing.
+    # @!attribute ten_dlc_verified True when the 10DLC brand registration is approved.
+    # @!attribute tax_id_on_file
+    # @!attribute number_count Non-released senders on this brand (phone numbers and Sender ID countries, any status).
+    # @!attribute editable False once the brand is locked: carriers approved or are reviewing its 10DLC registration, or senders are registered with its details. Locked brands are corrected only when carriers ask.
+    # @!attribute created_at
+    SmsBrand = Struct.new(:object, :id, :name, :legal_name, :website, :domain, :contact_email, :status, :missing, :ten_dlc_verified, :tax_id_on_file, :number_count, :editable, :created_at, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [SmsBrand, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          object: h["object"],
+          id: h["id"],
+          name: h["name"],
+          legal_name: h["legal_name"],
+          website: h["website"],
+          domain: h["domain"],
+          contact_email: h["contact_email"],
+          status: h["status"],
+          missing: h["missing"],
+          ten_dlc_verified: h["ten_dlc_verified"],
+          tax_id_on_file: h["tax_id_on_file"],
+          number_count: h["number_count"],
+          editable: h["editable"],
+          created_at: h["created_at"]
+        )
+      end
+    end
+
+    # The `SmsNumber` object from the public API.
+    # @!attribute object Always "sms_number".
+    # @!attribute id Prefixed number id, e.g. `snum_…`.
+    # @!attribute phone_number E.164 number. Null while a 10DLC registration is still in review; the number is assigned on approval.
+    # @!attribute type `long_code` is a local number issued outside the US (today: Canada, `country: "CA"`, reach `["CA"]`; instant, no carrier registration). `sender_id` is an alphanumeric Sender ID (one entry per enabled country; see `sender_id_group`). `simulator` only delivers to verified test destinations; it is not a production sender. One of: toll_free, ten_dlc, long_code, sender_id, simulator.
+    # @!attribute status Only `active` numbers can send. One of: pending, action_required, active, rejected, released.
+    # @!attribute is_default Informational: the workspace's first or primary number. Sends route by the recipient's country, not by this flag.
+    # @!attribute country ISO-3166 alpha-2 country the number was issued in (`US` for toll-free and 10DLC, `CA` for a Canadian long code). Null until recorded.
+    # @!attribute two_way Whether people can text this number: once it is active, a text to it fires the `sms.received` webhook and costs 1¢. True for US toll-free and 10DLC numbers and Canadian long codes (two-way is offered in the US and Canada only); false for Sender IDs, which are one-way, and for the simulator.
+    # @!attribute reach ISO-3166 alpha-2 countries this number can deliver to. US toll-free and 10DLC numbers reach `["US"]` only; a Canadian long code reaches `["CA"]` only. A recipient outside this list is skipped before send (status `suppressed`, not billed) rather than forwarded best-effort from a shared identity. Empty while the country is unknown.
+    # @!attribute brand_id The brand this number is registered under.
+    # @!attribute use_case What carriers approved this number to send. Required for approval; submitted with the number.
+    # @!attribute action_required_reason Set when status is `action_required` (what to fix: carrier feedback, why a submission failed, or a request that never reached the registry) or `rejected`.
+    # @!attribute sender_id_group Present on `sender_id` entries only. A Sender ID is ONE identity per brand enabled per country: the list still returns one entry per (Sender ID, country) so existing integrations keep working, and every entry of the same identity carries the same `sender_id_group` describing the whole set.
+    # @!attribute created_at
+    SmsNumber = Struct.new(:object, :id, :phone_number, :type, :status, :is_default, :country, :two_way, :reach, :brand_id, :use_case, :action_required_reason, :sender_id_group, :created_at, keyword_init: true) do
+      # @param h [Hash, nil] the decoded API object (string keys)
+      # @return [SmsNumber, nil]
+      def self.from_hash(h)
+        return nil if h.nil?
+        h = h.transform_keys(&:to_s)
+        new(
+          object: h["object"],
+          id: h["id"],
+          phone_number: h["phone_number"],
+          type: h["type"],
+          status: h["status"],
+          is_default: h["is_default"],
+          country: h["country"],
+          two_way: h["two_way"],
+          reach: h["reach"],
+          brand_id: h["brand_id"],
+          use_case: SmsNumberUseCase.from_hash(h["use_case"]),
+          action_required_reason: h["action_required_reason"],
+          sender_id_group: SmsNumberSenderIdGroup.from_hash(h["sender_id_group"]),
+          created_at: h["created_at"]
+        )
+      end
+    end
+
+  end
+end

data/lib/unitpost/resources.rb

@@ -27,7 +27,14 @@ module Unitpost
         { limit: limit, after: after, before: before }.merge(extra)
       end
 
+      FORWARD_ONLY_MESSAGE = "list_all pages forward only: `before` is not supported (use list to page backward)."
+
+      # Forward only, refused up front: a `before` cursor used to ride along
+      # with the moving `after` and 422 on the second page.
       def paginate(path, params)
+        before = params[:before] || params["before"]
+        raise ArgumentError, FORWARD_ONLY_MESSAGE if before && !before.to_s.empty?
+
         Enumerator.new do |yielder|
           after = params[:after]
           loop do
@@ -46,6 +53,193 @@ module Unitpost
       end
     end
 
+    class Sms < Base
+      attr_reader :templates, :campaigns, :topics
+
+      def initialize(http)
+        super(http)
+        @templates = SmsTemplates.new(http)
+        @campaigns = SmsCampaigns.new(http)
+        @topics = SmsTopics.new(http)
+      end
+
+      # SMS channel (paid plans). Recipient must be E.164; marketing sends require
+      # prior express consent on record and honor recipient-local quiet hours.
+      # Billing is per segment. When no idempotency_key is given one is
+      # generated so a transient retry can't double-send.
+      def send(body, idempotency_key: nil)
+        @http.request("POST", "/sms", body: body, idempotency_key: idempotency_key || SecureRandom.uuid)
+      end
+
+      def get(id)
+        @http.request("GET", "/sms/#{enc(id)}")
+      end
+
+      # Cancel a queued/scheduled SMS ({ cancel: true }, credit refunded) or
+      # move a scheduled one ({ scheduled_at: "<ISO 8601>" }).
+      def update(id, body)
+        @http.request("PATCH", "/sms/#{enc(id)}", body: body)
+      end
+
+      def list(params = {})
+        @http.request("GET", "/sms", query: params)
+      end
+
+      def list_all(params = {})
+        paginate("/sms", params)
+      end
+
+      # List SMS brands and their setup status.
+      #
+      # A brand is the business identity carriers register before they approve a
+      # phone number, so this is what to poll to answer "is SMS ready yet?":
+      # +status+ says whether you or the carrier is the blocker, and +missing+
+      # lists exactly what is still required.
+      #
+      # Read-only — creating a brand is a paid carrier submission and is only
+      # available in the dashboard.
+      def brands(params = {})
+        @http.request("GET", "/sms/brands", query: params)
+      end
+
+      # List SMS phone numbers.
+      #
+      # Only numbers with +status+ of "active" can send. A +ten_dlc+ number has
+      # no +phone_number+ until carriers approve it, and a +simulator+ number
+      # only reaches verified test destinations.
+      #
+      # Read-only — requesting or releasing a number is only available in the
+      # dashboard.
+      def numbers(params = {})
+        @http.request("GET", "/sms/numbers", query: params)
+      end
+
+      # SMS delivery stats over a rolling window (days: 1–365, defaults to 30
+      # server-side): queued, sent, delivered, failed, suppressed, canceled,
+      # inbound and segments billed, with delivery, failure and suppression
+      # rates. No opens or clicks on SMS.
+      def stats(days: nil)
+        @http.request("GET", "/sms/stats", query: { days: days })
+      end
+
+      # Read a contact's SMS consent state and immutable consent history.
+      def sms_consent(contact_id)
+        @http.request("GET", "/contacts/#{enc(contact_id)}/sms-consent")
+      end
+
+      # Record an SMS consent change (opt-in or opt-out) for a contact.
+      def record_sms_consent(contact_id, body)
+        @http.request("POST", "/contacts/#{enc(contact_id)}/sms-consent", body: body)
+      end
+    end
+
+    # SMS templates: plain-text bodies with {{variable}} placeholders.
+    class SmsTemplates < Base
+      def list(limit: nil, after: nil, before: nil)
+        @http.request("GET", "/sms/templates", query: list_params(limit: limit, after: after, before: before))
+      end
+
+      def list_all(**params)
+        paginate("/sms/templates", params)
+      end
+
+      def create(body)
+        @http.request("POST", "/sms/templates", body: body)
+      end
+
+      def get(id)
+        @http.request("GET", "/sms/templates/#{enc(id)}")
+      end
+
+      def update(id, body)
+        @http.request("PATCH", "/sms/templates/#{enc(id)}", body: body)
+      end
+
+      def delete(id)
+        @http.request("DELETE", "/sms/templates/#{enc(id)}")
+      end
+    end
+
+    # SMS campaigns: a published SMS template sent to a segment. create makes a
+    # draft (omit sender_id for automatic routing); send sends now or at
+    # scheduled_at; delete archives.
+    class SmsCampaigns < Base
+      def list(limit: nil, after: nil, before: nil)
+        @http.request("GET", "/sms/campaigns", query: list_params(limit: limit, after: after, before: before))
+      end
+
+      def list_all(**params)
+        paginate("/sms/campaigns", params)
+      end
+
+      def create(body)
+        @http.request("POST", "/sms/campaigns", body: body)
+      end
+
+      def get(id)
+        @http.request("GET", "/sms/campaigns/#{enc(id)}")
+      end
+
+      def update(id, body)
+        @http.request("PATCH", "/sms/campaigns/#{enc(id)}", body: body)
+      end
+
+      def delete(id)
+        @http.request("DELETE", "/sms/campaigns/#{enc(id)}")
+      end
+
+      def send(id, body = {})
+        @http.request("POST", "/sms/campaigns/#{enc(id)}/send", body: body)
+      end
+
+      def cancel(id)
+        @http.request("POST", "/sms/campaigns/#{enc(id)}/cancel")
+      end
+
+      def pause(id)
+        @http.request("POST", "/sms/campaigns/#{enc(id)}/pause")
+      end
+
+      def resume(id)
+        @http.request("POST", "/sms/campaigns/#{enc(id)}/resume")
+      end
+
+      def reschedule(id, body)
+        @http.request("POST", "/sms/campaigns/#{enc(id)}/reschedule", body: body)
+      end
+
+      def validate(id)
+        @http.request("GET", "/sms/campaigns/#{enc(id)}/validate")
+      end
+    end
+
+    # SMS subscription topics (independent from email topics); delete archives.
+    class SmsTopics < Base
+      def list(limit: nil, after: nil, before: nil)
+        @http.request("GET", "/sms/topics", query: list_params(limit: limit, after: after, before: before))
+      end
+
+      def list_all(**params)
+        paginate("/sms/topics", params)
+      end
+
+      def create(body)
+        @http.request("POST", "/sms/topics", body: body)
+      end
+
+      def get(id)
+        @http.request("GET", "/sms/topics/#{enc(id)}")
+      end
+
+      def update(id, body)
+        @http.request("PATCH", "/sms/topics/#{enc(id)}", body: body)
+      end
+
+      def delete(id)
+        @http.request("DELETE", "/sms/topics/#{enc(id)}")
+      end
+    end
+
     class Email < Base
       attr_reader :topics, :campaigns, :templates, :domains
 
@@ -152,6 +346,10 @@ module Unitpost
       def get_import(id)
         @http.request("GET", "/contacts/imports/#{enc(id)}")
       end
+
+      def cancel_import(id)
+        @http.request("POST", "/contacts/imports/#{enc(id)}/cancel")
+      end
     end
 
     class ContactFields < Base
@@ -184,6 +382,14 @@ module Unitpost
       end
     end
 
+    class Jobs < Base
+      # A background job: the 202 answer of an operation too large for one
+      # request. Poll until `status` is COMPLETED, FAILED or CANCELED.
+      def get(id)
+        @http.request("GET", "/jobs/#{enc(id)}")
+      end
+    end
+
     class Segments < Base
       def list(limit: nil, after: nil, before: nil)
         @http.request("GET", "/segments", query: list_params(limit: limit, after: after, before: before))
@@ -281,8 +487,11 @@ module Unitpost
         @http.request("DELETE", "/email/campaigns/#{enc(id)}")
       end
 
-      def send(id)
-        @http.request("POST", "/email/campaigns/#{enc(id)}/send")
+      # Send a draft. `{}` arms its saved `scheduled_at` while that is still
+      # ahead (otherwise it sends NOW); `{ scheduled_at: "<ISO 8601>" }`
+      # schedules it; `{ scheduled_at: nil }` sends now.
+      def send(id, body = {})
+        @http.request("POST", "/email/campaigns/#{enc(id)}/send", body: body)
       end
 
       def cancel(id)
@@ -330,6 +539,11 @@ module Unitpost
       def delete(id)
         @http.request("DELETE", "/email/templates/#{enc(id)}")
       end
+
+      # Send ONE test of the template to body[:to] with sample variables.
+      def test_send(id, body)
+        @http.request("POST", "/email/templates/#{enc(id)}/test-send", body: body)
+      end
     end
 
     # Read-only Brand Kit profiles (voice, colors, pinned /img/{id} graphics).
@@ -373,6 +587,11 @@ module Unitpost
       def verify(id)
         @http.request("POST", "/email/domains/#{enc(id)}/verify")
       end
+
+      # Read-only DNS diagnosis: per-record answers and ranked findings with fixes.
+      def diagnose(id)
+        @http.request("GET", "/email/domains/#{enc(id)}/diagnose")
+      end
     end
 
     class Webhooks < Base
@@ -404,6 +623,19 @@ module Unitpost
         @http.request("POST", "/webhooks/#{enc(id)}/test")
       end
 
+      # New signing secret, returned once; the old one co-signs for 24 h.
+      def rotate_secret(id)
+        @http.request("POST", "/webhooks/#{enc(id)}/rotate-secret")
+      end
+
+      def list_deliveries(id, limit: nil, after: nil, before: nil)
+        @http.request("GET", "/webhooks/#{enc(id)}/deliveries", query: list_params(limit: limit, after: after, before: before))
+      end
+
+      def list_all_deliveries(id, **params)
+        paginate("/webhooks/#{enc(id)}/deliveries", params)
+      end
+
       # Verify a delivery's signature and return the parsed event. Alias of
       # Unitpost.verify_webhook / Unitpost::Webhooks.verify for a Resend-style
       # client.webhooks.verify(...). Raises Unitpost::WebhookVerificationError on

data/lib/unitpost/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Unitpost
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unitpost
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Unitpost
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-31 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -30,6 +30,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +84,7 @@ files:
 - lib/unitpost/client.rb
 - lib/unitpost/errors.rb
 - lib/unitpost/generated/operations.rb
+- lib/unitpost/generated/sms_models.rb
 - lib/unitpost/http_client.rb
 - lib/unitpost/resources.rb
 - lib/unitpost/version.rb