sendly 4.3.0 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aee146f9046fd6558c2ec3af67cf715a780538d5f054a212d1fd27c36c52a59
-  data.tar.gz: f88147e73d75d0a731e2c8fd65634ac79ce5a162908e03d7c778122bb841914f
+  metadata.gz: 5a69a00fe63398e0ad342ed03ad9ddf38d668fe0d2ddd85533a2aa43e534eacb
+  data.tar.gz: 8488579a38c0f09720a8d9e67a5084819eb884dfe6cc99afc66be5d143ae5323
 SHA512:
-  metadata.gz: bd2892234c3a4b5dbd721fe37a0b4ecc8693ea20440fcfa04d724ce9d6ad94fd6f42319aefa9148d3a05e801ac0f2db225096c1b23e7897e54625b406ef1115e
-  data.tar.gz: 89476582a5b3026c6a07d54fb563425df47328d1ba5f00f5da9e17731dfe3e229ceb96b699efa219f9c9fcaa1907e7bc3e4174b5c52b6b3ce6f004553daead90
+  metadata.gz: caa9cd2bb16dc70c5eea42f760fe9295587e0f3b8c7a83bb4de6af903b5ba29ff6ec89c6c53ab211fc630c68d8139648516a95dccd27412382be08012ba922ed
+  data.tar.gz: b5ef93d9ce46c42dd53ef375b23aa66a5027e6534bf93425ab507d37f4c2f17311cdefbda52269e2fbad9b167808ad96abae255fd0b216942d5af1873d5f8337

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # sendly (Ruby)
 
+## 4.4.0
+
+### Minor Changes
+
+- **WhatsApp to SMS fallback.** `messages.send(channel: "whatsapp", fallback_to_sms: true)` sends `fallbackToSms`; it was dropped before. When WhatsApp can't deliver the message (the 24-hour window is closed, WhatsApp refuses it, or reports it undeliverable later), it goes as an SMS from the same number, billed as an SMS. The new `Sendly::WhatsAppSmsFallback` (`channel`, `status`, `reason`, `message_id`, `credits_used`, `error`, `content_dropped`, with `pending?` and `sent?`, and `STATUSES` and `REASONS`) says what happened: it is `WhatsAppMessage#fallback`, and `WhatsAppMessage#fell_back?` is true when the SMS went. When the SMS went in place of the WhatsApp message, `status` is `"failed"` and `fallback.status` is `"sent"`. `Message` gains `fallback` (on a WhatsApp message from `messages.get` or `messages.list`) and `fallback_of` (on the SMS, the id of the WhatsApp message it replaced), and `to_h` includes them when present. The number must already be able to send SMS to the recipient (US and Canada), or the API answers 403 `sms_fallback_unavailable`; marketing and authentication templates, and media without a caption, get 422 `sms_fallback_not_supported`.
+
+### Patch Changes
+
+- **Errors carry the API's error code.** `e.code` is the code the API sent in `error`, such as `"whatsapp_window_closed"`, `"sms_fallback_unavailable"` or `"invalid_api_key"`, on every error class, so refusals with the same status can be told apart. Before, only an unrecognised status read a code, and from a `code` field the API doesn't send, so `e.code` was the class's own code (`"VALIDATION_ERROR"`, `"API_ERROR"` and so on). That code is still used when the body names none (an `error` that is a sentence, or no `error` at all); a body's `code` field is read when `error` isn't a code. Code that compared `e.code` with a class code for an API error should rescue the class instead, or compare with the API's code.
+
 ## 4.3.0
 
 ### Minor Changes

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    sendly (4.3.0)
+    sendly (4.4.0)
       faraday (~> 2.0)
       faraday-retry (~> 2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.9.0)
+    addressable (2.8.8)
       public_suffix (>= 2.0.2, < 8.0)
     ast (2.4.3)
     bigdecimal (3.3.1)
@@ -36,7 +36,7 @@ GEM
       ast (~> 2.4.1)
       racc
     prism (1.6.0)
-    public_suffix (6.0.2)
+    public_suffix (7.0.0)
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.3.1)
@@ -74,7 +74,7 @@ GEM
       unicode-emoji (~> 4.1)
     unicode-emoji (4.1.0)
     uri (1.1.1)
-    webmock (3.26.4)
+    webmock (3.26.1)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
@@ -92,4 +92,4 @@ DEPENDENCIES
   webmock (~> 3.0)
 
 BUNDLED WITH
-   2.5.23
+   2.6.9

data/README.md

@@ -1316,6 +1316,25 @@ client.messages.send(
   text: "Here is your receipt",
   media_urls: ["https://acme.example/receipt.pdf"]
 )
+
+# Fall back to SMS from the same number when WhatsApp can't deliver: the
+# window is closed, WhatsApp refuses it, or reports it undeliverable later.
+# The SMS is billed as an SMS. The number must already be able to send SMS to
+# the recipient (US and Canada), or this raises 403 sms_fallback_unavailable;
+# marketing and authentication templates, and media without a caption, raise
+# 422 sms_fallback_not_supported.
+message = client.messages.send(
+  channel: "whatsapp",
+  to: "+15555550100",
+  from: "+15125550123",
+  text: "Your table is ready!",
+  fallback_to_sms: true
+)
+message.fallback.status    # "pending", "sent", "failed", "unavailable" or "skipped"
+message.fallback.reason    # "window_closed", "whatsapp_refused" or "whatsapp_failed"
+message.fell_back?         # true when the SMS went (message.status is then "failed")
+sms = client.messages.get(message.fallback.message_id) if message.fallback.message_id
+sms&.fallback_of           # the WhatsApp message's id
 ```
 
 WhatsApp errors map onto the usual classes:
@@ -1770,12 +1789,12 @@ begin
 rescue Sendly::AuthenticationError => e
   puts "Invalid API key"
 rescue Sendly::RateLimitError => e
-  if e.response_body&.dig("error") == "too_many_failed_key_attempts"
+  if e.code == "too_many_failed_key_attempts"
     # Repeated wrong API keys from this address locked it out for up to
     # 5 minutes. Fix the key; do not retry until the lockout ends.
     puts "Locked out for #{e.retry_after}s: check the API key"
   else
-    puts "Rate limited (#{e.response_body&.dig('error')}), retry after #{e.retry_after} seconds"
+    puts "Rate limited (#{e.code}), retry after #{e.retry_after} seconds"
   end
 rescue Sendly::InsufficientCreditsError => e
   puts "Add more credits to your account"
@@ -1786,17 +1805,18 @@ rescue Sendly::NotFoundError => e
 rescue Sendly::NetworkError => e
   puts "Network error: #{e.message}"
 rescue Sendly::Error => e
-  puts "Error: #{e.message} (#{e.response_body&.dig('error') || e.code})"
+  puts "Error: #{e.message} (#{e.code})"
 end
 ```
 
 Every error is a `Sendly::Error`, which carries `message`, `code`,
 `status_code`, `details` and `response_body` — the parsed JSON body of the
 API's response, or `nil` for an error raised before the request went out.
-The API's own error code is `e.response_body["error"]`; `code` is the SDK's
-name for the class (`"VALIDATION_ERROR"`, `"RATE_LIMIT_EXCEEDED"` and so on),
-except on `APIError`, where it is the body's `"code"` when there is one. Some
-refusals put more in that body than a message: a 409 `agent_in_use` lists the
+`code` is the API's own error code, such as `"whatsapp_window_closed"` or
+`"sms_fallback_unavailable"` (the body's `"error"`), so refusals with the same
+status can be told apart. When the body names no code, `code` is the SDK's
+name for the class (`"VALIDATION_ERROR"`, `"RATE_LIMIT_EXCEEDED"` and so on).
+Some refusals put more in that body than a message: a 409 `agent_in_use` lists the
 numbers under `"numbers"`, a 422 `invalid_address` carries a corrected
 address under `"suggested"`.
 
@@ -1809,7 +1829,7 @@ endpoint.
 | Class | Raised for |
 |-------|-----------|
 | `Sendly::AuthenticationError` | 401, and a missing or malformed API key at construction |
-| `Sendly::ValidationError` | 400 and 422; `field_errors` holds the API's `errors` list. `status_code` reads 400 for both, so tell them apart by `response_body["error"]` |
+| `Sendly::ValidationError` | 400 and 422; `field_errors` holds the API's `errors` list. `status_code` reads 400 for both, so tell them apart by `code` |
 | `Sendly::InsufficientCreditsError` | 402 |
 | `Sendly::NotFoundError` | 404, including a feature that is not enabled for you |
 | `Sendly::RateLimitError` | 429; `retry_after` in seconds when the API sent one |
@@ -2066,7 +2086,6 @@ client.enterprise.workspaces.list_keys("ws_xxx")
 # Enterprise-level account, credits and billing
 client.enterprise.get_account
 client.enterprise.credits.get
-client.enterprise.credits.deposit(amount: 100_000, description: "Q4 top-up")
 client.enterprise.settings.get_auto_top_up
 client.enterprise.settings.update_auto_top_up(enabled: true, threshold: 1000, amount: 10_000)
 client.enterprise.billing.get_breakdown(period: "30d")

data/lib/sendly/calls_resource.rb

@@ -55,6 +55,7 @@ module Sendly
       ring_timeout callee_declined callee_busy caller_cancelled room_closed_unanswered
       agent_left_unanswered agent_caller_never_joined invalid_number destination_rejected
       max_duration credits_exhausted media_aborted peer_connection_lost room_closed agent_left
+      transferred voicemail voicemail_unavailable
       setup_failed agent_dispatch_failed agent_api_unreachable agent_already_ended
       ended
     ].freeze

data/lib/sendly/errors.rb

@@ -3,7 +3,10 @@
 module Sendly
   # Base error class for all Sendly errors
   class Error < StandardError
-    # @return [String, nil] Error code from the API
+    # @return [String, nil] The API's error code, such as
+    #   +"whatsapp_window_closed"+ or +"sms_fallback_unavailable"+, for an
+    #   error built from an API response that names one. Otherwise the
+    #   class's own code, such as +"VALIDATION_ERROR"+.
     attr_reader :code
 
     # @return [Hash, nil] Additional error details
@@ -40,8 +43,8 @@ module Sendly
 
   # Raised when the API key is invalid or missing
   class AuthenticationError < Error
-    def initialize(message = "Invalid or missing API key")
-      super(message, code: "AUTHENTICATION_ERROR", status_code: 401)
+    def initialize(message = "Invalid or missing API key", code: nil)
+      super(message, code: code || "AUTHENTICATION_ERROR", status_code: 401)
     end
   end
 
@@ -50,16 +53,16 @@ module Sendly
     # @return [Integer, nil] Seconds to wait before retrying
     attr_reader :retry_after
 
-    def initialize(message = "Rate limit exceeded", retry_after: nil)
+    def initialize(message = "Rate limit exceeded", retry_after: nil, code: nil)
       @retry_after = retry_after
-      super(message, code: "RATE_LIMIT_EXCEEDED", status_code: 429)
+      super(message, code: code || "RATE_LIMIT_EXCEEDED", status_code: 429)
     end
   end
 
   # Raised when the account has insufficient credits
   class InsufficientCreditsError < Error
-    def initialize(message = "Insufficient credits")
-      super(message, code: "INSUFFICIENT_CREDITS", status_code: 402)
+    def initialize(message = "Insufficient credits", code: nil)
+      super(message, code: code || "INSUFFICIENT_CREDITS", status_code: 402)
     end
   end
 
@@ -70,16 +73,16 @@ module Sendly
     #   e.g. +[{ "path" => "brand.ein", "message" => "Enter a 9-digit EIN" }]+
     attr_reader :field_errors
 
-    def initialize(message = "Validation failed", field_errors: nil, details: nil)
+    def initialize(message = "Validation failed", field_errors: nil, details: nil, code: nil)
       @field_errors = field_errors
-      super(message, code: "VALIDATION_ERROR", details: details, status_code: 400)
+      super(message, code: code || "VALIDATION_ERROR", details: details, status_code: 400)
     end
   end
 
   # Raised when the requested resource is not found
   class NotFoundError < Error
-    def initialize(message = "Resource not found")
-      super(message, code: "NOT_FOUND", status_code: 404)
+    def initialize(message = "Resource not found", code: nil)
+      super(message, code: code || "NOT_FOUND", status_code: 404)
     end
   end
 
@@ -107,38 +110,50 @@ module Sendly
 
   # Raised for server errors (5xx)
   class ServerError < Error
-    def initialize(message = "Server error occurred", status_code: 500)
-      super(message, code: "SERVER_ERROR", status_code: status_code)
+    def initialize(message = "Server error occurred", status_code: 500, code: nil)
+      super(message, code: code || "SERVER_ERROR", status_code: status_code)
     end
   end
 
   # Convert API response to appropriate error
   class ErrorFactory
+    API_ERROR_CODE = /\A[a-z][a-z0-9_]*\z/
+    private_constant :API_ERROR_CODE
+
     def self.from_response(status, body, retry_after_header: nil)
       message = body["message"] || body["error"] || "Unknown error"
-      code = body["code"]
+      code = api_error_code(body)
       details = body["details"]
 
       error = case status
               when 400, 422
-                ValidationError.new(message, details: details, field_errors: body["errors"])
+                ValidationError.new(message, details: details, field_errors: body["errors"], code: code)
               when 401
-                AuthenticationError.new(message)
+                AuthenticationError.new(message, code: code)
               when 402
-                InsufficientCreditsError.new(message)
+                InsufficientCreditsError.new(message, code: code)
               when 404
-                NotFoundError.new(message)
+                NotFoundError.new(message, code: code)
               when 429
                 retry_after = parse_retry_after(retry_after_header) || body["retry_after"] || body["retryAfter"]
-                RateLimitError.new(message, retry_after: retry_after)
+                RateLimitError.new(message, retry_after: retry_after, code: code)
               when 500..599
-                ServerError.new(message, status_code: status)
+                ServerError.new(message, status_code: status, code: code)
               else
                 APIError.new(message, status_code: status, code: code, details: details)
               end
       error.with_response_body(body)
     end
 
+    def self.api_error_code(body)
+      error = body["error"]
+      return error.strip if error.is_a?(String) && error.strip.match?(API_ERROR_CODE)
+
+      code = body["code"]
+      code.is_a?(String) && !code.strip.empty? ? code : nil
+    end
+    private_class_method :api_error_code
+
     def self.parse_retry_after(value)
       text = value.to_s.strip
       return text.to_i if text.match?(/\A\d+\z/)

data/lib/sendly/messages.rb

@@ -62,9 +62,17 @@ module Sendly
     #   { action: { text: ..., postbackData: ..., url: ... } }. Passed
     #   through verbatim, so use the camelCase keys shown. Suggestions have
     #   no SMS form and are dropped on a fallback.
-    # @param fallback_to_sms [Boolean] RCS only: deliver +text+ as plain SMS
+    # @param fallback_to_sms [Boolean] RCS: deliver +text+ as plain SMS
     #   when the recipient can't receive RCS (default true). Pass false to
-    #   fail with 422 +rcs_not_supported_for_recipient+ instead.
+    #   fail with 422 +rcs_not_supported_for_recipient+ instead. WhatsApp:
+    #   default false. With true, a message WhatsApp can't deliver (the
+    #   24-hour window is closed, WhatsApp refuses it, or reports it
+    #   undeliverable later) goes as an SMS from the same number, billed as
+    #   an SMS; +message.fallback+ ({Sendly::WhatsAppSmsFallback}) says what
+    #   happened. The number must already be able to send SMS to the
+    #   recipient (US and Canada), or the API answers 403
+    #   +sms_fallback_unavailable+; marketing and authentication templates,
+    #   and media without a caption, get 422 +sms_fallback_not_supported+.
     # @param idempotency_key [String] Idempotency key for this operation
     #   (1-255 printable ASCII characters). The SDK already generates a key
     #   per logical request automatically, so the server can dedupe the
@@ -130,6 +138,17 @@ module Sendly
     #   puts message.whatsapp.kind   # "template"
     #   puts message.credits_used    # priced by country + category
     #
+    # @example WhatsApp with an SMS fallback
+    #   message = client.messages.send(
+    #     channel: "whatsapp",
+    #     to: "+15551234567",
+    #     from: "+15559876543",
+    #     text: "Your table is ready!",
+    #     fallback_to_sms: true
+    #   )
+    #   puts message.fallback&.status  # "sent" when it went as an SMS
+    #   puts message.fell_back?
+    #
     # @example RCS text with suggested replies and actions
     #   message = client.messages.send(
     #     channel: "rcs",
@@ -189,6 +208,7 @@ module Sendly
         body[:mediaUrls] = media_urls if has_media
         body[:template] = template if template
         body[:metadata] = metadata if metadata
+        body[:fallbackToSms] = fallback_to_sms unless fallback_to_sms.nil?
 
         response = client.post("/messages", body, idempotency_key: idempotency_key)
         return WhatsAppMessage.new(response)

data/lib/sendly/types.rb

@@ -69,6 +69,14 @@ module Sendly
     # @return [String] "sms", "mms", "rcs" or "whatsapp"; "sms" when the response does not say
     attr_reader :message_format
 
+    # @return [Sendly::WhatsAppSmsFallback, nil] On a WhatsApp message sent
+    #   with +fallback_to_sms+, what happened to its SMS fallback
+    attr_reader :fallback
+
+    # @return [String, nil] On an SMS fallback, the id of the WhatsApp
+    #   message it replaced
+    attr_reader :fallback_of
+
     # Message status constants (sending removed - doesn't exist in database)
     STATUSES = %w[queued sent delivered failed bounced retrying].freeze
 
@@ -98,6 +106,8 @@ module Sendly
       @ai_metadata = data["aiMetadata"]
       @media_urls = data["mediaUrls"] || data["media_urls"] || []
       @message_format = data["messageFormat"] || data["message_format"] || "sms"
+      @fallback = data["fallback"].is_a?(Hash) ? WhatsAppSmsFallback.new(data["fallback"]) : nil
+      @fallback_of = data["fallbackOf"] || data["fallback_of"]
     end
 
     # Check if message was delivered
@@ -143,7 +153,9 @@ module Sendly
         metadata: metadata,
         ai_metadata: ai_metadata,
         media_urls: media_urls,
-        message_format: message_format
+        message_format: message_format,
+        fallback: fallback&.to_h,
+        fallback_of: fallback_of
       }.compact
     end
 

data/lib/sendly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sendly
-  VERSION = "4.3.0"
+  VERSION = "4.4.0"
 end

data/lib/sendly/webhooks.rb

@@ -103,6 +103,11 @@ module Sendly
     EVENT_SHORT_CODE_REJECTED            = "short_code.rejected"
     EVENT_SHORT_CODE_FILED               = "short_code.filed"
     EVENT_SHORT_CODE_LIVE                = "short_code.live"
+    EVENT_SHORT_CODE_SUSPENDED           = "short_code.suspended"
+    EVENT_SHORT_CODE_REACTIVATED         = "short_code.reactivated"
+    EVENT_SHORT_CODE_CANCELLED           = "short_code.cancelled"
+    EVENT_SHORT_CODE_PAYMENT_SUCCEEDED   = "short_code.payment_succeeded"
+    EVENT_SHORT_CODE_PAYMENT_FAILED      = "short_code.payment_failed"
 
     # Source of a list-health event. Frozen enum — new values will be
     # added in minor SDK versions, never removed.

data/lib/sendly/whatsapp_resource.rb

@@ -420,6 +420,51 @@ module Sendly
     end
   end
 
+  # The SMS fallback of a WhatsApp message sent with +fallback_to_sms: true+.
+  # +status+ is +"pending"+ until WhatsApp's outcome is known, +"sent"+ when
+  # the SMS went, +"failed"+ when the SMS was refused or credits ran out,
+  # +"unavailable"+ when the SMS could no longer be sent from this number,
+  # and +"skipped"+ when the WhatsApp failure isn't one an SMS fixes.
+  # +reason+ is what made the message fall back (+"window_closed"+,
+  # +"whatsapp_refused"+ or +"whatsapp_failed"+). +message_id+ is the SMS
+  # message's id once it exists, +credits_used+ what the SMS cost, +error+
+  # why the SMS didn't go, in plain English, and +content_dropped+ the
+  # template parts with no SMS form, such as +"quick_replies"+. Values the
+  # API adds later come through unchanged.
+  class WhatsAppSmsFallback
+    attr_reader :channel, :status, :reason, :message_id, :credits_used,
+                :error, :content_dropped
+
+    STATUSES = %w[pending sent failed unavailable skipped].freeze
+    REASONS = %w[window_closed whatsapp_refused whatsapp_failed].freeze
+
+    def initialize(data)
+      @channel = data["channel"] || "sms"
+      @status = data["status"]
+      @reason = data["reason"]
+      @message_id = data["messageId"] || data["message_id"]
+      @credits_used = data["creditsUsed"] || data["credits_used"]
+      @error = data["error"]
+      @content_dropped = data["contentDropped"] || data["content_dropped"]
+    end
+
+    def pending?
+      status == "pending"
+    end
+
+    def sent?
+      status == "sent"
+    end
+
+    def to_h
+      {
+        channel: channel, status: status, reason: reason,
+        message_id: message_id, credits_used: credits_used, error: error,
+        content_dropped: content_dropped
+      }.compact
+    end
+  end
+
   # A sent WhatsApp message. Unlike {Message}, +segments+ is always 1
   # (WhatsApp has no segment concept), +text+ is the caption for a media
   # send (pass it as +text+ with +media_urls+) and nil for template sends
@@ -431,10 +476,14 @@ module Sendly
   # utility price of 12 credits. Templates are priced by category and
   # destination country; countries without a listed price use 33
   # (marketing), 12 (utility) and 12 (authentication) credits. A failed
-  # send gives its slot back.
+  # send gives its slot back. +fallback+ is a {WhatsAppSmsFallback} when the
+  # send asked for +fallback_to_sms+: when WhatsApp couldn't take the
+  # message and it went as an SMS instead, +status+ is +"failed"+ and
+  # +fallback.status+ is +"sent"+ (check with {#fell_back?}).
   class WhatsAppMessage
     attr_reader :id, :channel, :message_format, :to, :from, :text, :status,
-                :segments, :credits_used, :whatsapp, :created_at, :metadata
+                :segments, :credits_used, :whatsapp, :created_at, :metadata,
+                :fallback
 
     def initialize(data)
       @id = data["id"]
@@ -449,6 +498,11 @@ module Sendly
       @whatsapp = data["whatsapp"] ? WhatsAppMessageDetails.new(data["whatsapp"]) : nil
       @created_at = data["createdAt"] || data["created_at"]
       @metadata = data["metadata"]
+      @fallback = data["fallback"].is_a?(Hash) ? WhatsAppSmsFallback.new(data["fallback"]) : nil
+    end
+
+    def fell_back?
+      fallback&.sent? || false
     end
 
     def delivered?
@@ -464,7 +518,7 @@ module Sendly
         id: id, channel: channel, message_format: message_format,
         to: to, from: from, text: text, status: status, segments: segments,
         credits_used: credits_used, whatsapp: whatsapp&.to_h,
-        created_at: created_at, metadata: metadata
+        created_at: created_at, metadata: metadata, fallback: fallback&.to_h
       }.compact
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendly
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.4.0
 platform: ruby
 authors:
 - Sendly
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -159,7 +159,7 @@ metadata:
   source_code_uri: https://github.com/SendlyHQ/sendly-ruby
   changelog_uri: https://github.com/SendlyHQ/sendly-ruby/blob/main/CHANGELOG.md
   documentation_uri: https://sendly.live/docs
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -174,8 +174,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Official Ruby SDK for the Sendly SMS API
 test_files: []