camelmailer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9d144156fc057f5dede175ed29f43b9c6587a33ae84b7b25c097a814c1537b7
-  data.tar.gz: 482b37a49af5b42f3a527788a59c1dfaeb115797ed985c202deb7841c8fd8058
+  metadata.gz: 28bcdafc5b4d88c345cfdde3bcee95fef29cca02184e6585a68c792f6d1c45e6
+  data.tar.gz: ead53848baadb6a9fa379a65db5cd6c21500af8413c965832b7306a655f3a037
 SHA512:
-  metadata.gz: 865924a5a43a2087e6e73abfb70e5fbb677b7cf9d961aa893bca18eec7859320f7a879d97a4d22d16e37d1b1840f1490ea1436692a357aa74aa24302a4d29801
-  data.tar.gz: a14c759e870581dec25f9a8eb3bd1cdf2e24ba4e9a9989d9128193e45858ee1f51022dc5a7886e33f31f7d2c61d6c5b60766f42fd95a498c85e892282cfb15b3
+  metadata.gz: cf0a7c0616c7e1d846925aa7d2aabdc07b77f0991537b63a744e544dcdd1af4d17cf9fb54e16d3f1d93f375104736129eab3185fe68f2e1a1b4653b201f024e0
+  data.tar.gz: 8730ed2043e369e014e4931012db680417a2b86581a5cbabc75c65eb8ffa11e64ce84a3dafdb731917530c0ece5a3d837d976d53d7bb462daee716d5a7389bd0

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-09-14
+
+### Fixed
+
+- `Emails.send_batch` and `Emails.send_with_template_batch` wrapped the
+  entries in `{ messages: [...] }`. The endpoint reads a bare JSON array,
+  so every batch send was rejected before anything was queued. The existing
+  spec asserted the wrapper, which is why it survived. Both now send the
+  array as given.
+- `sig/camelmailer.rbs` had a syntax error (`(module)` is not a type) and
+  could not be parsed by any type checker. CI now validates it.
+
+### Added
+
+- `Campaigns`: `create_draft`, `create_and_send`, `list`, `list_for_stream`,
+  `get`, `get_for_stream`, `update`, `send`, `cancel`. The two create
+  methods hit different routes: `create_draft` writes the campaign and
+  waits, `create_and_send` expands it to the stream's subscribers before
+  the call returns.
+- `Subscribers`: `list`, `add`, `import`, `complaint`, `remove`.
+- `Layouts`: `list`, `create`, `get`, `update`, `delete`, `upload_logo`.
+- `Inbound`: `list`, `get`, `retry`, `bypass`.
+- `Logs`: `list`, `tags`.
+- `Emails.send_to_stream` for broadcasting to a stream's subscribers.
+- An optional `idempotency_key:` on every send. It travels as the
+  `Idempotency-Key` header, because the body is what the server hashes to
+  recognise a replay.
+- `SendLimitExceededError` (429) and `InvalidIdempotentRequestError` (409).
+- `Client#delete`, and request headers on `Client#post`.
+
 ## [0.1.0] - 2026-07-11
 
 ### Added
@@ -18,5 +48,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Rails integration: `:camelmailer` ActionMailer delivery method with full MIME mapping (from/to/cc/bcc/reply_to, html+text parts, attachments, custom headers, tag/stream/metadata pseudo-headers).
 - RBS type signatures.
 
-[Unreleased]: https://github.com/camelmailer/camelmailer-ruby/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/camelmailer/camelmailer-ruby/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/camelmailer/camelmailer-ruby/releases/tag/v0.2.0
 [0.1.0]: https://github.com/camelmailer/camelmailer-ruby/releases/tag/v0.1.0

data/README.md

@@ -88,6 +88,7 @@ CamelMailer::Emails.send(from:, to:, subject:, html_body:, text_body:, cc:, bcc:
 CamelMailer::Emails.send_batch([{ from:, to:, ... }, ...])
 CamelMailer::Emails.send_with_template(from:, to:, template: "welcome", template_model: { name: "Ada" })
 CamelMailer::Emails.send_with_template_batch([...])
+CamelMailer::Emails.send_to_stream("newsletter", from:, subject:, text_body:)
 CamelMailer::Emails.get(42)
 CamelMailer::Emails.list(scope: "outgoing", status: "Sent", tag: "receipt", query: "ada", page: 1, per_page: 50)
 CamelMailer::Emails.deliveries(42)  # delivery attempts
@@ -98,6 +99,20 @@ CamelMailer::Emails.raw(42)         # raw RFC 5322 source
 
 Attachments are `{ name:, content_type:, data_base64: }`; addresses are either `"a@b.com"` or `{ email: "a@b.com", name: "Ada" }`.
 
+`send_to_stream` broadcasts to everyone subscribed to a stream, up to 1000
+per call; the response counts `queued:` against `skipped:`, so a larger
+audience wants a campaign.
+
+Every send takes an optional `idempotency_key:`, which makes it replayable:
+the same key with the same body returns the first result instead of sending
+twice, and a different body under the same key raises
+`CamelMailer::InvalidIdempotentRequestError`.
+
+```ruby
+CamelMailer::Emails.send(from: "billing@acme.com", to: ["ada@example.com"],
+                         subject: "Your receipt", idempotency_key: "receipt-#{order.id}")
+```
+
 ### Templates
 
 ```ruby
@@ -119,6 +134,80 @@ CamelMailer::Streams.update("broadcasts", name: "News")
 CamelMailer::Streams.archive("broadcasts")
 ```
 
+### Campaigns
+
+A campaign is content plus an audience. The two ways to create one behave
+differently, so pick deliberately: `create_draft` writes it and waits,
+`create_and_send` expands it to the stream's subscribers before the call
+returns.
+
+```ruby
+CamelMailer::Campaigns.create_draft(stream: "newsletter", name: "September",
+                                    from: "news@acme.com", subject: "What shipped",
+                                    text_body: "Hello.")
+# scheduled_at: "2026-10-01T09:00:00Z" arms it as `scheduled`
+# send_now: true sends it on creation
+
+CamelMailer::Campaigns.create_and_send("newsletter", name: "Status update",
+                                       from: "news@acme.com", text_body: "All clear.")
+
+CamelMailer::Campaigns.list
+CamelMailer::Campaigns.list_for_stream("newsletter")
+CamelMailer::Campaigns.get(7)                      # with stats
+CamelMailer::Campaigns.get_for_stream("newsletter", 7)
+CamelMailer::Campaigns.update(7, subject: "Corrected")
+CamelMailer::Campaigns.update(7, scheduled_at: nil) # back to draft
+CamelMailer::Campaigns.send(7)                      # now, whatever the schedule said
+CamelMailer::Campaigns.cancel(7)
+```
+
+### Subscribers
+
+A broadcast send to an address that is not subscribed is refused, so this
+list is the audience.
+
+```ruby
+CamelMailer::Subscribers.list("newsletter")
+CamelMailer::Subscribers.add("newsletter", address: "ada@example.com", name: "Ada")
+CamelMailer::Subscribers.import("newsletter", ["ada@example.com", "grace@example.com"])
+CamelMailer::Subscribers.complaint("newsletter", "ada@example.com") # suppress + unsubscribe
+CamelMailer::Subscribers.remove("newsletter", "ada@example.com")
+```
+
+### Layouts
+
+A layout wraps every template that uses it. `html_wrapper` has to embed the
+body with `{{{ content }}}`.
+
+```ruby
+CamelMailer::Layouts.list
+CamelMailer::Layouts.create(name: "Default", permalink: "default",
+                            html_wrapper: "<html><body>{{{ content }}}</body></html>")
+CamelMailer::Layouts.get("default")
+CamelMailer::Layouts.update("default", name: "Main")
+CamelMailer::Layouts.upload_logo("default", "data:image/png;base64,...")
+CamelMailer::Layouts.delete("default")
+```
+
+### Inbound and held messages
+
+```ruby
+CamelMailer::Inbound.list(status: "held")
+CamelMailer::Inbound.get(55)
+CamelMailer::Inbound.retry(55)   # back on the delivery queue
+CamelMailer::Inbound.bypass(55)  # release past the hold
+```
+
+### Logs
+
+Useful when a send did not arrive and the question is whether the request
+ever reached the API.
+
+```ruby
+CamelMailer::Logs.list(per_page: 25)
+CamelMailer::Logs.tags
+```
+
 ### Stats & bounces
 
 ```ruby

data/lib/camelmailer/campaigns.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module CamelMailer
+  # Broadcast campaigns (/api/v2/server/campaigns...).
+  #
+  # A campaign is content plus an audience. There are two ways to create
+  # one and they behave differently: #create_draft writes it and waits,
+  # while #create_and_send expands it to the stream's subscribers before
+  # the call returns.
+  class Campaigns < Resource
+    expose :list, :list_for_stream, :get, :get_for_stream, :create_draft,
+           :create_and_send, :update, :send, :cancel
+
+    # Every campaign on the server, newest first.
+    def list
+      client.get("campaigns")
+    end
+
+    # The campaigns of one broadcast stream.
+    def list_for_stream(permalink)
+      client.get("streams/#{permalink}/campaigns")
+    end
+
+    # One campaign together with its statistics.
+    def get(id)
+      client.get("campaigns/#{id}")
+    end
+
+    # One campaign through its stream.
+    def get_for_stream(permalink, id)
+      client.get("streams/#{permalink}/campaigns/#{id}")
+    end
+
+    # Creates a campaign without sending it. Name the audience with
+    # stream:. Leave scheduled_at: out for a draft, set it for a
+    # scheduled send, or pass send_now: true to send on creation.
+    def create_draft(params)
+      client.post("campaigns", params)
+    end
+
+    # Creates a campaign on a broadcast stream and sends it immediately.
+    # The send starts before this call returns, so there is no draft to
+    # review and no schedule to set. Use #create_draft when the campaign
+    # should wait.
+    def create_and_send(permalink, params)
+      client.post("streams/#{permalink}/campaigns", params)
+    end
+
+    # Updates a draft or scheduled campaign. Setting scheduled_at: moves a
+    # draft to scheduled; nil clears the schedule and drops it back to a
+    # draft. A campaign that is already sending cannot be edited.
+    def update(id, params)
+      client.patch("campaigns/#{id}", params)
+    end
+
+    # Sends a campaign now, whatever its schedule said.
+    def send(id)
+      client.post("campaigns/#{id}/send")
+    end
+
+    # Cancels a scheduled or in-flight campaign. Messages already queued
+    # are not recalled.
+    def cancel(id)
+      client.post("campaigns/#{id}/cancel")
+    end
+  end
+end

data/lib/camelmailer/client.rb

@@ -34,38 +34,34 @@ module CamelMailer
       @read_timeout = read_timeout
     end
 
-    def emails
-      @emails ||= Emails.new(self)
-    end
-
-    def templates
-      @templates ||= Templates.new(self)
-    end
-
-    def streams
-      @streams ||= Streams.new(self)
-    end
-
-    def stats
-      @stats ||= Stats.new(self)
-    end
-
-    def bounces
-      @bounces ||= Bounces.new(self)
-    end
-
-    def dmarc
-      @dmarc ||= Dmarc.new(self)
+    # The resource each accessor returns, memoized per client so
+    # +client.emails+ is the same object every time. Named by constant
+    # rather than by class, because the resource files are required after
+    # this one.
+    RESOURCES = {
+      emails: :Emails, templates: :Templates, streams: :Streams,
+      stats: :Stats, bounces: :Bounces, dmarc: :Dmarc,
+      campaigns: :Campaigns, subscribers: :Subscribers, layouts: :Layouts,
+      inbound: :Inbound, logs: :Logs
+    }.freeze
+
+    RESOURCES.each do |name, const|
+      define_method(name) do
+        (@resources ||= {})[name] ||= CamelMailer.const_get(const).new(self)
+      end
     end
 
     def get(path, query = nil)
       perform(Net::HTTP::Get.new(build_uri(path, query)))
     end
 
-    def post(path, body = nil)
+    # +headers+ carries request headers such as Idempotency-Key, which
+    # belong outside the body: the body is what the server hashes to
+    # recognise the same request.
+    def post(path, body = nil, headers = {})
       req = Net::HTTP::Post.new(build_uri(path))
       attach_body(req, body)
-      perform(req)
+      perform(req, headers)
     end
 
     def patch(path, body = nil)
@@ -74,6 +70,10 @@ module CamelMailer
       perform(req)
     end
 
+    def delete(path)
+      perform(Net::HTTP::Delete.new(build_uri(path)))
+    end
+
     private
 
     def build_uri(path, query = nil)
@@ -92,10 +92,11 @@ module CamelMailer
       req.body = JSON.generate(body)
     end
 
-    def perform(req)
+    def perform(req, headers = {})
       req["X-Server-API-Key"] = api_key
       req["Accept"] = "application/json"
       req["User-Agent"] = "camelmailer-ruby/#{VERSION}"
+      headers.each { |name, value| req[name.to_s] = value.to_s }
 
       handle(transport(req.uri).request(req))
     rescue *NETWORK_ERRORS => e

data/lib/camelmailer/emails.rb

@@ -4,28 +4,51 @@ module CamelMailer
   # Send and read messages (POST/GET /api/v2/server/messages...).
   class Emails < Resource
     expose :send, :send_batch, :send_with_template, :send_with_template_batch,
-           :get, :list, :deliveries, :opens, :clicks, :raw
+           :send_to_stream, :get, :list, :deliveries, :opens, :clicks, :raw
 
     # Sends one message. Required: from:, to:. See the API docs for the
     # full SendRequest shape (html_body, text_body, cc, bcc, reply_to,
     # headers, attachments, tag, metadata, stream).
-    def send(params)
-      client.post("messages", params)
+    #
+    # Pass idempotency_key: to make the send replayable: the same key with
+    # the same body returns the first result instead of sending twice.
+    #
+    # Takes the message either as a hash or as keywords, because both read
+    # naturally and both were already in use:
+    #
+    #   emails.send(from: "a@acme.com", to: ["b@e.com"], subject: "Hi")
+    #   emails.send(params, idempotency_key: "receipt-7")
+    def send(params = {}, **fields)
+      key = fields.delete(:idempotency_key)
+      client.post("messages", params.merge(fields), idempotency_headers(key))
     end
 
     # Sends a batch of SendRequest hashes; returns one result per entry.
-    def send_batch(messages)
-      client.post("messages/batch", { messages: messages })
+    #
+    # Sent as a bare JSON array, which is what the endpoint reads.
+    def send_batch(messages, idempotency_key: nil)
+      client.post("messages/batch", messages, idempotency_headers(idempotency_key))
+    end
+
+    # Sends the same content to every subscriber of a broadcast stream.
+    # Either give subject: with a body, or a template: permalink with an
+    # optional template_model:. The response counts queued: against
+    # skipped:; recipients past the per-request cap of 1000 are skipped,
+    # so a larger audience wants a campaign.
+    def send_to_stream(permalink, params)
+      client.post("streams/#{permalink}/send", params)
     end
 
     # Renders a stored template against template_model:, then sends.
-    def send_with_template(params)
-      client.post("messages/with_template", params)
+    # Takes idempotency_key: the same way #send does.
+    def send_with_template(params = {}, **fields)
+      key = fields.delete(:idempotency_key)
+      client.post("messages/with_template", params.merge(fields), idempotency_headers(key))
     end
 
-    # Batch variant of #send_with_template.
-    def send_with_template_batch(messages)
-      client.post("messages/with_template/batch", { messages: messages })
+    # Batch variant of #send_with_template. Also a bare JSON array.
+    def send_with_template_batch(messages, idempotency_key: nil)
+      client.post("messages/with_template/batch", messages, idempotency_headers(idempotency_key))
     end
 
     # Shows one message by id.
@@ -58,5 +81,11 @@ module CamelMailer
     def raw(id)
       client.get("messages/#{id}/raw")
     end
+
+    private
+
+    def idempotency_headers(key)
+      key.nil? ? {} : { "Idempotency-Key" => key }
+    end
   end
 end

data/lib/camelmailer/errors.rb

@@ -43,6 +43,15 @@ module CamelMailer
   # 400 — a required parameter is missing.
   class ParameterMissingError < APIError; end
 
+  # 429 — the server's 30-day send allowance is used up. Answered before
+  # anything is stored, so nothing was queued and a retry once the window
+  # moves on will work.
+  class SendLimitExceededError < APIError; end
+
+  # 409 — an Idempotency-Key was reused for a different request body, or
+  # sent twice on one request.
+  class InvalidIdempotentRequestError < APIError; end
+
   # Unexpected non-envelope response (e.g. a 5xx from a proxy).
   class ServerError < APIError; end
 
@@ -51,6 +60,8 @@ module CamelMailer
     "Forbidden" => ForbiddenError,
     "NotFound" => NotFoundError,
     "ValidationError" => ValidationError,
-    "ParameterMissing" => ParameterMissingError
+    "ParameterMissing" => ParameterMissingError,
+    "SendLimitExceeded" => SendLimitExceededError,
+    "InvalidIdempotentRequest" => InvalidIdempotentRequestError
   }.freeze
 end

data/lib/camelmailer/inbound.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CamelMailer
+  # Inbound and held messages (/api/v2/server/inbound...).
+  #
+  # Covers mail arriving through an inbound route as well as outbound mail
+  # the spam filter put on hold, which is why a message here can be either
+  # retried or released past the hold.
+  class Inbound < Resource
+    expose :list, :get, :retry, :bypass
+
+    # Searches inbound and held messages, newest first.
+    def list(**filters)
+      client.get("inbound", filters)
+    end
+
+    def get(id)
+      client.get("inbound/#{id}")
+    end
+
+    # Puts a message back on the delivery queue, for instance after fixing
+    # the route it should have matched.
+    def retry(id)
+      client.post("inbound/#{id}/retry")
+    end
+
+    # Releases a held message past the hold and delivers it.
+    def bypass(id)
+      client.post("inbound/#{id}/bypass")
+    end
+  end
+end

data/lib/camelmailer/layouts.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module CamelMailer
+  # Template layouts (/api/v2/server/layouts...).
+  #
+  # A layout wraps every template that uses it, so header, footer and
+  # styling live in one place instead of in each template.
+  class Layouts < Resource
+    expose :list, :create, :get, :update, :delete, :upload_logo
+
+    def list
+      client.get("layouts")
+    end
+
+    # Creates a layout. html_wrapper: has to embed the body with
+    # {{{ content }}}; anything else is refused with ValidationError.
+    def create(params)
+      client.post("layouts", params)
+    end
+
+    def get(permalink)
+      client.get("layouts/#{permalink}")
+    end
+
+    # Updates a layout; only the given fields change.
+    def update(permalink, params)
+      client.patch("layouts/#{permalink}", params)
+    end
+
+    # Deletes a layout. Templates that referenced it fall back to no
+    # wrapper.
+    def delete(permalink)
+      client.delete("layouts/#{permalink}")
+    end
+
+    # Uploads the layout's logo as a data URL
+    # ("data:image/png;base64,...") and returns the absolute URL to
+    # reference from the wrapper.
+    def upload_logo(permalink, data_url)
+      client.post("layouts/#{permalink}/logo", { data_url: data_url })
+    end
+  end
+end

data/lib/camelmailer/logs.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module CamelMailer
+  # The server's own request log and tag index
+  # (/api/v2/server/logs, /api/v2/server/tags).
+  #
+  # Useful when a send did not arrive and the question is whether the
+  # request ever reached the API, and with what answer.
+  class Logs < Resource
+    expose :list, :tags
+
+    # Logged API requests, newest first.
+    def list(**filters)
+      client.get("logs", filters)
+    end
+
+    # Tags used by the server's recent messages, most used first.
+    def tags
+      client.get("tags")
+    end
+  end
+end

data/lib/camelmailer/subscribers.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module CamelMailer
+  # Opt-in subscribers of a broadcast stream
+  # (/api/v2/server/streams/:permalink/subscribers...).
+  #
+  # A broadcast send to an address that is not subscribed is refused, so
+  # this list is the audience.
+  class Subscribers < Resource
+    expose :list, :add, :import, :complaint, :remove
+
+    # The stream's subscribers, subscribed and unsubscribed alike.
+    def list(permalink)
+      client.get(base(permalink))
+    end
+
+    # Adds or updates one subscriber. Upserts by address:, so calling it
+    # twice is safe.
+    def add(permalink, params)
+      client.post(base(permalink), params)
+    end
+
+    # Adds many addresses at once, all as subscribed. Blanks and
+    # duplicates within the request are skipped, and the response reports
+    # how many were written against how many survived that filtering.
+    def import(permalink, addresses)
+      client.post("#{base(permalink)}/import", { addresses: addresses })
+    end
+
+    # Records a spam complaint: writes a stream-scoped suppression and
+    # flips the subscription to unsubscribed. Idempotent, so a feedback
+    # loop can replay it safely.
+    def complaint(permalink, address)
+      client.post("#{base(permalink)}/#{encode(address)}/complaint")
+    end
+
+    # Removes a subscriber from the stream entirely.
+    def remove(permalink, address)
+      client.delete("#{base(permalink)}/#{encode(address)}")
+    end
+
+    private
+
+    def base(permalink)
+      "streams/#{permalink}/subscribers"
+    end
+
+    # The plus in an address has to survive the path, or a different
+    # address is addressed.
+    def encode(address)
+      URI.encode_www_form_component(address).gsub("+", "%2B")
+    end
+  end
+end

data/lib/camelmailer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CamelMailer
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/camelmailer.rb

@@ -10,6 +10,11 @@ require "camelmailer/streams"
 require "camelmailer/stats"
 require "camelmailer/bounces"
 require "camelmailer/dmarc"
+require "camelmailer/campaigns"
+require "camelmailer/subscribers"
+require "camelmailer/layouts"
+require "camelmailer/inbound"
+require "camelmailer/logs"
 
 # The Ruby SDK for CamelMailer — https://camelmailer.com
 #

data/sig/camelmailer.rbs

@@ -9,8 +9,8 @@ module CamelMailer
   def self.api_key=: (String?) -> String?
   def self.base_url: () -> String
   def self.base_url=: (String?) -> String?
-  def self.configure: () { (module) -> void } -> module
-  def self.config: () { (module) -> void } -> module
+  def self.configure: () { (singleton(CamelMailer)) -> void } -> singleton(CamelMailer)
+  def self.config: () { (singleton(CamelMailer)) -> void } -> singleton(CamelMailer)
   def self.client: () -> Client
   def self.reset!: () -> void
 
@@ -45,6 +45,12 @@ module CamelMailer
   class ParameterMissingError < APIError
   end
 
+  class SendLimitExceededError < APIError
+  end
+
+  class InvalidIdempotentRequestError < APIError
+  end
+
   class ServerError < APIError
   end
 
@@ -59,16 +65,24 @@ module CamelMailer
 
     def initialize: (api_key: String?, ?base_url: String?, ?open_timeout: Integer, ?read_timeout: Integer) -> void
 
+    RESOURCES: Hash[Symbol, Symbol]
+
     def emails: () -> Emails
     def templates: () -> Templates
     def streams: () -> Streams
     def stats: () -> Stats
     def bounces: () -> Bounces
     def dmarc: () -> Dmarc
+    def campaigns: () -> Campaigns
+    def subscribers: () -> Subscribers
+    def layouts: () -> Layouts
+    def inbound: () -> Inbound
+    def logs: () -> Logs
 
     def get: (String path, ?payload? query) -> response
-    def post: (String path, ?payload? body) -> response
+    def post: (String path, ?(payload | Array[payload])? body, ?Hash[String, String] headers) -> response
     def patch: (String path, ?payload? body) -> response
+    def delete: (String path) -> response
   end
 
   class Resource
@@ -79,10 +93,11 @@ module CamelMailer
   end
 
   class Emails < Resource
-    def send: (payload params) -> response
-    def send_batch: (Array[payload] messages) -> response
-    def send_with_template: (payload params) -> response
-    def send_with_template_batch: (Array[payload] messages) -> response
+    def send: (?payload params, **untyped fields) -> response
+    def send_batch: (Array[payload] messages, ?idempotency_key: String?) -> response
+    def send_with_template: (?payload params, **untyped fields) -> response
+    def send_with_template_batch: (Array[payload] messages, ?idempotency_key: String?) -> response
+    def send_to_stream: (String permalink, payload params) -> response
     def get: (Integer | String id) -> response
     def list: (**untyped filters) -> response
     def deliveries: (Integer | String id) -> response
@@ -90,10 +105,11 @@ module CamelMailer
     def clicks: (Integer | String id) -> response
     def raw: (Integer | String id) -> response
 
-    def self.send: (payload params) -> response
-    def self.send_batch: (Array[payload] messages) -> response
-    def self.send_with_template: (payload params) -> response
-    def self.send_with_template_batch: (Array[payload] messages) -> response
+    def self.send: (?payload params, **untyped fields) -> response
+    def self.send_batch: (Array[payload] messages, ?idempotency_key: String?) -> response
+    def self.send_with_template: (?payload params, **untyped fields) -> response
+    def self.send_with_template_batch: (Array[payload] messages, ?idempotency_key: String?) -> response
+    def self.send_to_stream: (String permalink, payload params) -> response
     def self.get: (Integer | String id) -> response
     def self.list: (**untyped filters) -> response
     def self.deliveries: (Integer | String id) -> response
@@ -158,6 +174,78 @@ module CamelMailer
     def self.report: (Integer | String id) -> response
   end
 
+  class Campaigns < Resource
+    def list: () -> response
+    def list_for_stream: (String permalink) -> response
+    def get: (Integer | String id) -> response
+    def get_for_stream: (String permalink, Integer | String id) -> response
+    def create_draft: (payload params) -> response
+    def create_and_send: (String permalink, payload params) -> response
+    def update: (Integer | String id, payload params) -> response
+    def send: (Integer | String id) -> response
+    def cancel: (Integer | String id) -> response
+
+    def self.list: () -> response
+    def self.list_for_stream: (String permalink) -> response
+    def self.get: (Integer | String id) -> response
+    def self.get_for_stream: (String permalink, Integer | String id) -> response
+    def self.create_draft: (payload params) -> response
+    def self.create_and_send: (String permalink, payload params) -> response
+    def self.update: (Integer | String id, payload params) -> response
+    def self.send: (Integer | String id) -> response
+    def self.cancel: (Integer | String id) -> response
+  end
+
+  class Subscribers < Resource
+    def list: (String permalink) -> response
+    def add: (String permalink, payload params) -> response
+    def import: (String permalink, Array[String] addresses) -> response
+    def complaint: (String permalink, String address) -> response
+    def remove: (String permalink, String address) -> response
+
+    def self.list: (String permalink) -> response
+    def self.add: (String permalink, payload params) -> response
+    def self.import: (String permalink, Array[String] addresses) -> response
+    def self.complaint: (String permalink, String address) -> response
+    def self.remove: (String permalink, String address) -> response
+  end
+
+  class Layouts < Resource
+    def list: () -> response
+    def create: (payload params) -> response
+    def get: (String permalink) -> response
+    def update: (String permalink, payload params) -> response
+    def delete: (String permalink) -> response
+    def upload_logo: (String permalink, String data_url) -> response
+
+    def self.list: () -> response
+    def self.create: (payload params) -> response
+    def self.get: (String permalink) -> response
+    def self.update: (String permalink, payload params) -> response
+    def self.delete: (String permalink) -> response
+    def self.upload_logo: (String permalink, String data_url) -> response
+  end
+
+  class Inbound < Resource
+    def list: (**untyped filters) -> response
+    def get: (Integer | String id) -> response
+    def retry: (Integer | String id) -> response
+    def bypass: (Integer | String id) -> response
+
+    def self.list: (**untyped filters) -> response
+    def self.get: (Integer | String id) -> response
+    def self.retry: (Integer | String id) -> response
+    def self.bypass: (Integer | String id) -> response
+  end
+
+  class Logs < Resource
+    def list: (**untyped filters) -> response
+    def tags: () -> response
+
+    def self.list: (**untyped filters) -> response
+    def self.tags: () -> response
+  end
+
   class Mailer
     IGNORED_HEADERS: Array[String]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: camelmailer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Camelmailer contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-14 00:00:00.000000000 Z
 dependencies: []
 description: Ruby SDK for the Camelmailer transactional email API — send messages,
   manage templates, streams and stats, and plug into Rails via the :camelmailer ActionMailer
@@ -25,15 +25,20 @@ files:
 - README.md
 - lib/camelmailer.rb
 - lib/camelmailer/bounces.rb
+- lib/camelmailer/campaigns.rb
 - lib/camelmailer/client.rb
 - lib/camelmailer/dmarc.rb
 - lib/camelmailer/emails.rb
 - lib/camelmailer/errors.rb
+- lib/camelmailer/inbound.rb
+- lib/camelmailer/layouts.rb
+- lib/camelmailer/logs.rb
 - lib/camelmailer/mailer.rb
 - lib/camelmailer/railtie.rb
 - lib/camelmailer/resource.rb
 - lib/camelmailer/stats.rb
 - lib/camelmailer/streams.rb
+- lib/camelmailer/subscribers.rb
 - lib/camelmailer/templates.rb
 - lib/camelmailer/version.rb
 - sig/camelmailer.rbs