opensms 0.1.0

data/lib/opensms/resources/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "uri"
+
+require_relative "../models"
+
+module Opensms
+  # Resource groups hanging off {Opensms::Client}. Each resource is thin: build
+  # the path, query and body, call the transport, decode the model.
+  module Resources
+    # Shared plumbing for resources. Not part of the public API.
+    class Base
+      # @param transport [Opensms::Transport]
+      def initialize(transport)
+        @transport = transport
+      end
+
+      private
+
+      # Build a path from literal segments and escaped values:
+      # path("/v1/messages", id, "attempts").
+      def path(prefix, *segments)
+        ([prefix] + segments.map { |s| s.is_a?(Symbol) ? s.to_s : escape(s) }).join("/")
+      end
+
+      # Escape a path segment ("a/b" -> "a%2Fb", space -> "%20").
+      def escape(value)
+        URI.encode_www_form_component(value.to_s).gsub("+", "%20")
+      end
+
+      # Validate that an id argument is present.
+      def id!(value, name = "id")
+        raise ArgumentError, "Opensms: `#{name}` is required." if value.nil? || value.to_s.strip.empty?
+
+        value
+      end
+
+      # Idempotency-Key for methods marked req/opt: the caller's key or a new
+      # UUIDv4, generated once per call and reused on every retry.
+      def idem(key)
+        key.nil? ? SecureRandom.uuid : key.to_s
+      end
+
+      # Merge a positional Hash with keyword arguments.
+      def merge(params, kwargs)
+        Models.symbolize(params || {}).merge(kwargs)
+      end
+
+      def http_get(p, query = nil)
+        @transport.request(:get, p, query: query)
+      end
+
+      def http_page(p, query = nil)
+        Page.from(http_get(p, query))
+      end
+
+      def http_delete(p, idempotency_key: nil)
+        @transport.request(:delete, p, idempotency_key: idempotency_key)
+        nil
+      end
+    end
+  end
+end

data/lib/opensms/resources/batches.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +batches+ resource: bulk sends that are validated first and started
+    # explicitly. Accessed as +client.batches+.
+    class Batches < Base
+      ITEM_FIELDS = %i[to text sender_id traffic_type callback_url metadata].freeze
+      ITEMS_QUERY = %i[status limit cursor].freeze
+
+      # Create a batch from items. POST /v1/messages/batch -> 202 Batch
+      # (status "ready"; nothing is sent until {#start}).
+      #
+      # @param params [Hash] :items (Array of {to:, text:, sender_id:, ...}), :dedupe
+      # @param idempotency_key [String, nil]
+      # @return [Hash] Batch
+      def create(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[items dedupe], required: %i[items])
+        body[:items] = Array(body[:items]).map { |item| Models.build(item, ITEM_FIELDS) }
+        @transport.request(:post, "/v1/messages/batch", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # Create a batch from CSV text (header row "to,text[,sender_id,...]").
+      # Sent as text/csv. With +dedupe: false+ the CSV is sent as a
+      # multipart/form-data upload instead, because that is the only form in
+      # which the API accepts a dedupe flag next to CSV.
+      #
+      # @param csv [String]
+      # @param dedupe [Boolean, nil] default true on the server
+      # @param idempotency_key [String, nil]
+      # @return [Hash] Batch
+      def create_from_csv(csv, dedupe: nil, idempotency_key: nil)
+        raise ArgumentError, "Opensms: `csv` is required." if csv.nil? || csv.to_s.empty?
+
+        key = idem(idempotency_key)
+        if dedupe == false
+          boundary = "OpensmsBoundary#{SecureRandom.hex(12)}"
+          return @transport.request(:post, "/v1/messages/batch",
+                                    raw_body: multipart(boundary, csv.to_s),
+                                    content_type: "multipart/form-data; boundary=#{boundary}",
+                                    idempotency_key: key)
+        end
+        @transport.request(:post, "/v1/messages/batch", raw_body: csv.to_s, content_type: "text/csv",
+                                                        idempotency_key: key)
+      end
+
+      # GET /v1/batches/{id} -> Batch.
+      def get(id)
+        http_get(path("/v1/batches", id!(id)))
+      end
+
+      # Per-row validation report. GET /v1/batches/{id}/validation.
+      # @return [Hash] { rows:, total:, valid:, invalid:, duplicates:, suppressed: }
+      def validation(id)
+        http_get(path("/v1/batches", id!(id), :validation))
+      end
+
+      # Start a ready batch. POST /v1/batches/{id}/start -> Batch.
+      def start(id, idempotency_key: nil)
+        @transport.request(:post, path("/v1/batches", id!(id), :start), idempotency_key: idem(idempotency_key))
+      end
+
+      # Stop a batch. POST /v1/batches/{id}/stop -> { id:, status: "stopped", cancelled: }.
+      def stop(id, idempotency_key: nil)
+        @transport.request(:post, path("/v1/batches", id!(id), :stop), idempotency_key: idem(idempotency_key))
+      end
+
+      # Messages created by a batch. GET /v1/batches/{id}/items -> Page<BatchItem>.
+      #
+      # @param params [Hash] :status, :limit, :cursor
+      # @return [Opensms::Page]
+      def list_items(id, params = nil, **kwargs)
+        http_page(path("/v1/batches", id!(id), :items), Models.build(merge(params, kwargs), ITEMS_QUERY))
+      end
+
+      private
+
+      def multipart(boundary, csv)
+        [
+          "--#{boundary}\r\n",
+          %(Content-Disposition: form-data; name="dedupe"\r\n\r\n),
+          "false\r\n",
+          "--#{boundary}\r\n",
+          %(Content-Disposition: form-data; name="file"; filename="batch.csv"\r\n),
+          "Content-Type: text/csv\r\n\r\n",
+          csv.b,
+          "\r\n--#{boundary}--\r\n"
+        ].map(&:b).join
+      end
+    end
+  end
+end

data/lib/opensms/resources/compliance.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +compliance+ resource: per-country rules and content rules.
+    # Accessed as +client.compliance+.
+    class Compliance < Base
+      # GET /v1/compliance/countries -> Array<CountryRules>.
+      def list_countries
+        http_get("/v1/compliance/countries")
+      end
+
+      # GET /v1/compliance/countries/{iso2} -> CountryRules.
+      def get_country(iso2)
+        http_get(path("/v1/compliance/countries", id!(iso2, "iso2")))
+      end
+
+      # GET /v1/content-rules -> Array<ContentRule>.
+      def list_content_rules
+        http_get("/v1/content-rules")
+      end
+    end
+  end
+end

data/lib/opensms/resources/contact_groups.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +contact_groups+ resource. Accessed as +client.contact_groups+.
+    class ContactGroups < Base
+      FIELDS = %i[name contact_ids].freeze
+      SEND_FIELDS = %i[text template_id variables sender_id traffic_type callback_url].freeze
+
+      # GET /v1/contact-groups -> Page<Group>.
+      # @param params [Hash] :limit, :cursor
+      def list(params = nil, **kwargs)
+        http_page("/v1/contact-groups", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/contact-groups -> 201 Group.
+      # @param params [Hash] :name (required), :contact_ids
+      def create(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), FIELDS, required: %i[name])
+        @transport.request(:post, "/v1/contact-groups", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # GET /v1/contact-groups/{id} -> Group.
+      def get(id)
+        http_get(path("/v1/contact-groups", id!(id)))
+      end
+
+      # PATCH /v1/contact-groups/{id} -> Group.
+      # @param params [Hash] :name, :contact_ids
+      def update(id, params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), FIELDS)
+        @transport.request(:patch, path("/v1/contact-groups", id!(id)), body: body)
+      end
+
+      # DELETE /v1/contact-groups/{id} -> 204.
+      # @return [nil]
+      def delete(id)
+        http_delete(path("/v1/contact-groups", id!(id)))
+      end
+
+      # Send to every contact in the group. POST /v1/contact-groups/{id}/send
+      # -> Batch (already "running").
+      #
+      # @param params [Hash] :text or :template_id, :variables, :sender_id,
+      #   :traffic_type, :callback_url
+      def send(id, params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), SEND_FIELDS)
+        @transport.request(:post, path("/v1/contact-groups", id!(id), :send), body: body,
+                                                                             idempotency_key: idem(idempotency_key))
+      end
+    end
+  end
+end

data/lib/opensms/resources/contacts.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +contacts+ resource. Accessed as +client.contacts+.
+    class Contacts < Base
+      FIELDS = %i[e164 name attributes].freeze
+
+      # GET /v1/contacts -> Page<Contact>.
+      # @param params [Hash] :limit, :cursor
+      # @return [Opensms::Page]
+      def list(params = nil, **kwargs)
+        http_page("/v1/contacts", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/contacts -> 201 Contact.
+      # @param params [Hash] :e164 (required), :name, :attributes
+      def create(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), FIELDS, required: %i[e164])
+        @transport.request(:post, "/v1/contacts", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # GET /v1/contacts/{id} -> Contact.
+      def get(id)
+        http_get(path("/v1/contacts", id!(id)))
+      end
+
+      # Partial update. PATCH /v1/contacts/{id} -> Contact.
+      # @param params [Hash] :e164, :name, :attributes
+      def update(id, params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), FIELDS)
+        @transport.request(:patch, path("/v1/contacts", id!(id)), body: body)
+      end
+
+      # DELETE /v1/contacts/{id} -> 204.
+      # @return [nil]
+      def delete(id)
+        http_delete(path("/v1/contacts", id!(id)))
+      end
+    end
+  end
+end

data/lib/opensms/resources/countries.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +countries+ resource: the public country catalog. Accessed as
+    # +client.countries+.
+    class Countries < Base
+      # GET /v1/countries -> Array<Country>.
+      def list
+        http_get("/v1/countries")
+      end
+
+      # GET /v1/countries/{iso2}/carriers -> Array<{ id:, name:, mcc_mnc:, prefixes: }>.
+      def carriers(iso2)
+        http_get(path("/v1/countries", id!(iso2, "iso2"), :carriers))
+      end
+
+      # GET /v1/countries/{iso2}/routes -> Array<Route>.
+      def routes(iso2)
+        http_get(path("/v1/countries", id!(iso2, "iso2"), :routes))
+      end
+
+      # GET /v1/countries/{iso2}/compliance -> CountryRules.
+      def compliance(iso2)
+        http_get(path("/v1/countries", id!(iso2, "iso2"), :compliance))
+      end
+    end
+  end
+end

data/lib/opensms/resources/inbound.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +inbound+ resource: messages received on your numbers. Accessed as
+    # +client.inbound+.
+    class Inbound < Base
+      # GET /v1/inbound -> Page<InboundMessage>.
+      def list(params = nil, **kwargs)
+        http_page("/v1/inbound", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # Reply to an inbound message (live keys only).
+      # POST /v1/inbound/{id}/reply -> 201 Message.
+      #
+      # @param params [Hash] :text (required)
+      def reply(id, params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[text], required: %i[text])
+        @transport.request(:post, path("/v1/inbound", id!(id), :reply), body: body,
+                                                                        idempotency_key: idem(idempotency_key))
+      end
+    end
+  end
+end

data/lib/opensms/resources/lookups.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +lookups+ resource: number lookups (country, carrier, porting).
+    # Accessed as +client.lookups+.
+    class Lookups < Base
+      # POST /v1/lookup -> 200 (completed) or 202 (pending) Lookup.
+      #
+      # @param params [Hash] :to (E.164, required)
+      # @return [Hash] Lookup
+      def create(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[to], required: %i[to])
+        @transport.request(:post, "/v1/lookup", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # GET /v1/lookup/{id} -> Lookup.
+      def get(id)
+        http_get(path("/v1/lookup", id!(id)))
+      end
+    end
+  end
+end

data/lib/opensms/resources/messages.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +messages+ resource: send, list, inspect and cancel SMS. Accessed as
+    # +client.messages+.
+    class Messages < Base
+      SEND_FIELDS = %i[to text sender_id traffic_type scheduled_at callback_url metadata].freeze
+      LIST_FIELDS = %i[limit cursor status to country date_from date_to].freeze
+
+      # Send one SMS. POST /v1/messages -> 201 Message.
+      #
+      # @param params [Hash] :to (E.164, required), :text (required), :sender_id,
+      #   :traffic_type, :scheduled_at (Time or RFC 3339), :callback_url, :metadata
+      # @param idempotency_key [String, nil] generated when omitted
+      # @return [Hash] Message
+      def send(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), SEND_FIELDS, required: %i[to text], times: %i[scheduled_at])
+        @transport.request(:post, "/v1/messages", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # List messages, newest first. GET /v1/messages -> Page<Message>.
+      #
+      # @param params [Hash] :limit (1..100), :cursor, :status, :to, :country,
+      #   :date_from, :date_to
+      # @return [Opensms::Page]
+      def list(params = nil, **kwargs)
+        http_page("/v1/messages", Models.build(merge(params, kwargs), LIST_FIELDS, times: %i[date_from date_to]))
+      end
+
+      # GET /v1/messages/{id} -> Message.
+      # @return [Hash]
+      def get(id)
+        http_get(path("/v1/messages", id!(id)))
+      end
+
+      # Delivery attempts for a message. GET /v1/messages/{id}/attempts.
+      # @return [Array<Hash>]
+      def attempts(id)
+        http_get(path("/v1/messages", id!(id), :attempts))
+      end
+
+      # Cancel a queued or scheduled message. Never auto-retried.
+      # POST /v1/messages/{id}/cancel -> Message.
+      # @return [Hash]
+      def cancel(id)
+        @transport.request(:post, path("/v1/messages", id!(id), :cancel))
+      end
+    end
+  end
+end

data/lib/opensms/resources/numbers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +numbers+ resource: virtual numbers and their inbound rules.
+    # Everything except +list+ and +available+ needs a live key. Accessed as
+    # +client.numbers+.
+    class Numbers < Base
+      RULE_FIELDS = %i[match pattern action target position].freeze
+
+      # GET /v1/numbers -> Page<Number>.
+      def list(params = nil, **kwargs)
+        http_page("/v1/numbers", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # GET /v1/numbers/available -> Array<Number>.
+      # @param params [Hash] :country, :kind
+      def available(params = nil, **kwargs)
+        http_get("/v1/numbers/available", Models.build(merge(params, kwargs), %i[country kind]))
+      end
+
+      # Assign (buy) a number; charges the wallet. POST /v1/numbers -> 201 Number.
+      # @param params [Hash] :country (required), :kind (required)
+      def assign(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[country kind], required: %i[country kind])
+        @transport.request(:post, "/v1/numbers", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # DELETE /v1/numbers/{id} -> 204.
+      # @return [nil]
+      def release(id)
+        http_delete(path("/v1/numbers", id!(id)))
+      end
+
+      # GET /v1/numbers/{id}/rules -> Page<Rule>.
+      def list_rules(id, params = nil, **kwargs)
+        http_page(path("/v1/numbers", id!(id), :rules), Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/numbers/{id}/rules -> 201 Rule.
+      # @param rule [Hash] :match, :pattern, :action, :target, :position
+      def create_rule(id, rule = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(rule, kwargs), RULE_FIELDS, required: %i[match action target])
+        @transport.request(:post, path("/v1/numbers", id!(id), :rules), body: body,
+                                                                        idempotency_key: idem(idempotency_key))
+      end
+
+      # PUT /v1/numbers/{id}/rules/{rule_id} -> Rule.
+      def update_rule(id, rule_id, rule = nil, **kwargs)
+        body = Models.build(merge(rule, kwargs), RULE_FIELDS, required: %i[match action target])
+        @transport.request(:put, path("/v1/numbers", id!(id), :rules, id!(rule_id, "rule_id")), body: body)
+      end
+
+      # DELETE /v1/numbers/{id}/rules/{rule_id} -> 204.
+      # @return [nil]
+      def delete_rule(id, rule_id)
+        http_delete(path("/v1/numbers", id!(id), :rules, id!(rule_id, "rule_id")))
+      end
+    end
+  end
+end

data/lib/opensms/resources/otp.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +otp+ resource: send and verify one-time passcodes. Accessed as
+    # +client.otp+.
+    class Otp < Base
+      # Send a code. POST /v1/otp/send -> 201 { otp_id: }.
+      #
+      # @param params [Hash] :to (required), :sender_id, :template (must contain
+      #   "{{code}}"), :length (4..10), :ttl_seconds (30..86400)
+      # @return [Hash] { otp_id: }
+      def send(params = nil, idempotency_key: nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[to sender_id template length ttl_seconds], required: %i[to])
+        @transport.request(:post, "/v1/otp/send", body: body, idempotency_key: idem(idempotency_key))
+      end
+
+      # Check a code. A wrong code returns { valid: false } and burns an
+      # attempt, so this call is never auto-retried.
+      # POST /v1/otp/verify -> { valid:, attempts_left: }.
+      #
+      # @param params [Hash] :otp_id, :code
+      # @return [Hash]
+      def verify(params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), %i[otp_id code], required: %i[otp_id code])
+        @transport.request(:post, "/v1/otp/verify", body: body)
+      end
+    end
+  end
+end

data/lib/opensms/resources/pricing.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +pricing+ resource. Accessed as +client.pricing+.
+    class Pricing < Base
+      # GET /v1/pricing -> PriceList.
+      # @param params [Hash] :product (sms|lookup|number_monthly), :country (ISO2)
+      def get(params = nil, **kwargs)
+        http_get("/v1/pricing", Models.build(merge(params, kwargs), %i[product country]))
+      end
+    end
+  end
+end

data/lib/opensms/resources/sandbox.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +sandbox+ resource: the rendered text of sandbox sends, including
+    # OTP codes. Accessed as +client.sandbox+.
+    class Sandbox < Base
+      # GET /v1/sandbox/messages -> Page<SandboxMessage>.
+      def list_messages(params = nil, **kwargs)
+        http_page("/v1/sandbox/messages", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+    end
+  end
+end

data/lib/opensms/resources/sender_ids.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Opensms
+  module Resources
+    # The +sender_ids+ resource: registered sender IDs, availability checks,
+    # fee quotes, documents and drafts. Accessed as +client.sender_ids+.
+    class SenderIds < Base
+      CREATE_FIELDS = %i[value kind countries use_case sample_message documents draft_id draft_version quote_id].freeze
+      UPDATE_FIELDS = %i[use_case countries documents sample_message].freeze
+      DRAFT_FIELDS = %i[source value kind countries use_case sample_message documents].freeze
+      DRAFT_UPDATE_FIELDS = %i[version value kind countries use_case sample_message documents].freeze
+
+      # GET /v1/sender-ids -> Page<SenderId>.
+      def list(params = nil, **kwargs)
+        http_page("/v1/sender-ids", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # GET /v1/sender-ids/{id} -> SenderId.
+      def get(id)
+        http_get(path("/v1/sender-ids", id!(id)))
+      end
+
+      # Register a sender ID. May charge fees, so it is never auto-retried.
+      # POST /v1/sender-ids -> 201 SenderId.
+      #
+      # @param params [Hash] :value, :kind, :countries, :documents (required),
+      #   :use_case, :sample_message, :draft_id, :draft_version, :quote_id
+      def create(params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), CREATE_FIELDS, required: %i[value kind countries documents])
+        @transport.request(:post, "/v1/sender-ids", body: body)
+      end
+
+      # Amend a sender ID. PATCH /v1/sender-ids/{id} -> SenderId.
+      # @param params [Hash] :use_case, :countries, :documents (required), :sample_message
+      def update(id, params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), UPDATE_FIELDS, required: %i[use_case countries documents])
+        @transport.request(:patch, path("/v1/sender-ids", id!(id)), body: body)
+      end
+
+      # DELETE /v1/sender-ids/{id} -> 204.
+      # @return [nil]
+      def delete(id)
+        http_delete(path("/v1/sender-ids", id!(id)))
+      end
+
+      # GET /v1/sender-ids/check -> { valid:, available:, reserved:, reason: }.
+      # @param params [Hash] :value (required), :country
+      def check(params = nil, **kwargs)
+        http_get("/v1/sender-ids/check", Models.build(merge(params, kwargs), %i[value country], required: %i[value]))
+      end
+
+      # Registration fee quote. GET /v1/sender-ids/quote?countries=KE,NG.
+      # @param params [Hash] :countries (Array or comma-separated String)
+      def quote(params = nil, **kwargs)
+        http_get("/v1/sender-ids/quote", Models.build(merge(params, kwargs), %i[countries], required: %i[countries]))
+      end
+
+      # Uploaded registration documents. GET /v1/sender-documents.
+      # @return [Array<Hash>] the +items+ of the response (no cursor)
+      def list_documents
+        body = http_get("/v1/sender-documents")
+        body.is_a?(Hash) ? (body[:items] || []) : body
+      end
+
+      # GET /v1/sender-id-drafts -> Page<Draft>.
+      def list_drafts(params = nil, **kwargs)
+        http_page("/v1/sender-id-drafts", Models.build(merge(params, kwargs), %i[limit cursor]))
+      end
+
+      # POST /v1/sender-id-drafts -> 201 Draft. Not auto-retried.
+      def create_draft(params = nil, **kwargs)
+        @transport.request(:post, "/v1/sender-id-drafts", body: Models.build(merge(params, kwargs), DRAFT_FIELDS))
+      end
+
+      # GET /v1/sender-id-drafts/{id} -> Draft.
+      def get_draft(id)
+        http_get(path("/v1/sender-id-drafts", id!(id)))
+      end
+
+      # PATCH /v1/sender-id-drafts/{id} -> Draft. Requires the current
+      # +version+ (optimistic lock; 409 on mismatch).
+      def update_draft(id, params = nil, **kwargs)
+        body = Models.build(merge(params, kwargs), DRAFT_UPDATE_FIELDS, required: %i[version])
+        @transport.request(:patch, path("/v1/sender-id-drafts", id!(id)), body: body)
+      end
+
+      # DELETE /v1/sender-id-drafts/{id} -> 204.
+      # @return [nil]
+      def delete_draft(id)
+        http_delete(path("/v1/sender-id-drafts", id!(id)))
+      end
+    end
+  end
+end