sendly 3.18.0 → 3.18.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b45492ba74b05f9d480cea6a2a911c8b6ec9b66c5e197230a0a10ea81e4692f9
-  data.tar.gz: 981f6d67200e9725c9e0f546d65a9b575a3cfc4a1d5b935bd8f0c5c2034a1dd1
+  metadata.gz: bade33a147b49cd340671aaf86a187388360ba9c2e8d58fa0d51b6b486620bb8
+  data.tar.gz: eb35d212b0466da3fe3ae102e80a8314a0fd6081f8a8e1c89e680ad715c7fb7f
 SHA512:
-  metadata.gz: 7724bb3862a1b21aab27d4470b41b468585bfbce1fc73eb4f62c851afd710b8e24b54362cd2da64d6e3833b859717510220f4ccf502786330d04950f056fbe8f
-  data.tar.gz: e4319bb9b9a322d2b119e1dd1c6da32e68e4c178e2006a2987058a7a5af6112fde9a590aaeee18691ea7427b3b06f0e31be1a351d5e1d2b4ba51c9c89f12987f
+  metadata.gz: 321cb814654988946c7029a44233383a28caaae97702d374669ad77be6b9c277befc22166fd42f16018f90d723ab4ee1050c1dbccd4483d3e636ea3ccffbf8fa
+  data.tar.gz: 9f1244a84aa2c84848e83fc74eb15bdcf2aea5ecaebf1e3406796a6d64aeb4e6c081cf81555455e0be89a2cfbed20439225f1301d99bd61d74876236a261e9fb

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# sendly (Ruby)
+
+## 3.18.1
+
+### Patch Changes
+
+- fix: webhook signature verification and payload parsing now match server implementation
+  - `verify_signature()` accepts `timestamp:` keyword argument for HMAC on `timestamp.payload` format
+  - `parse_event()` handles `data[:object]` nesting (with flat `data` fallback for backwards compat)
+  - `WebhookEvent` adds `livemode` attr, `created` field, `created_at` alias
+  - `WebhookMessageData` renamed `message_id` to `id` (with `message_id` method alias)
+  - Added `direction`, `organization_id`, `text`, `message_format`, `media_urls` attrs
+  - `generate_signature()` accepts `timestamp:` keyword argument
+  - 5-minute timestamp tolerance check prevents replay attacks
+
+## 3.18.0
+
+### Minor Changes
+
+- Add MMS support for US/CA domestic messaging
+
+## 3.17.0
+
+### Minor Changes
+
+- Add structured error classification and automatic message retry
+- New `error_code` field with 13 structured codes (E001-E013, E099)
+- New `retry_count` field tracks retry attempts
+- New `retrying` status and `message.retrying` webhook event
+
+## 3.16.0
+
+### Minor Changes
+
+- Add `transfer_credits` for moving credits between workspaces
+
+## 3.15.2
+
+### Patch Changes
+
+- Add metadata support to Message class
+
+## 3.13.0
+
+### Minor Changes
+
+- Campaigns, Contacts & Contact Lists resources with full CRUD
+- Template clone method

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    sendly (3.18.0)
+    sendly (3.18.2)
       faraday (~> 2.0)
       faraday-retry (~> 2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.8.8)
+    addressable (2.8.9)
       public_suffix (>= 2.0.2, < 8.0)
     ast (2.4.3)
     bigdecimal (3.3.1)

data/README.md

@@ -372,6 +372,74 @@ Use test API keys (`sk_test_v1_xxx`) with these test numbers:
 | +15005550004 | Fails: rate_limit_exceeded |
 | +15005550006 | Fails: carrier_violation |
 
+## Enterprise
+
+The Enterprise API lets you programmatically manage workspaces, verification, credits, and API keys for multi-tenant platforms. Requires an enterprise master key (`sk_live_v1_master_*`).
+
+### Quick Provision
+
+Create a fully configured workspace in a single call:
+
+```ruby
+client = Sendly::Client.new(api_key: "sk_live_v1_master_YOUR_KEY")
+
+result = client.enterprise.provision(
+  name: "Acme Insurance - Austin",
+  source_workspace_id: "ws_verified",
+  credit_amount: 5000,
+  credit_source_workspace_id: "ws_pool",
+  key_name: "Production",
+  key_type: "live",
+  generate_opt_in_page: true
+)
+
+puts result["workspace"]["id"]
+puts result["apiKey"]["rawKey"]
+```
+
+Three provisioning modes:
+
+| Mode | Params | Description |
+|------|--------|-------------|
+| **Inherit** | `source_workspace_id:` | Shares toll-free number from verified workspace |
+| **Inherit + New Number** | `source_workspace_id:` + `inherit_with_new_number: true` | Copies business info, purchases new number |
+| **Fresh** | `verification: { ... }` | Full business details, new number + carrier approval |
+
+### Workspace Management
+
+```ruby
+ws = client.enterprise.workspaces.create("Acme Insurance")
+list = client.enterprise.workspaces.list
+detail = client.enterprise.workspaces.get("ws_xxx")
+client.enterprise.workspaces.delete("ws_xxx")
+```
+
+### Credits & API Keys
+
+```ruby
+client.enterprise.workspaces.transfer_credits("ws_dest",
+  source_workspace_id: "ws_source", amount: 5000)
+
+key = client.enterprise.workspaces.create_key("ws_xxx",
+  name: "Production", type: "live")
+puts key["rawKey"]
+
+client.enterprise.workspaces.revoke_key("ws_xxx", "key_abc")
+```
+
+### Webhooks & Analytics
+
+```ruby
+client.enterprise.webhooks.set("https://yourapp.com/webhooks")
+overview = client.enterprise.analytics.overview
+messages = client.enterprise.analytics.messages(period: "30d")
+delivery = client.enterprise.analytics.delivery
+```
+
+Full enterprise docs: [sendly.live/docs/enterprise](https://sendly.live/docs/enterprise)
+
+---
+
 ## Requirements
 
 - Ruby 3.0+

data/lib/sendly/client.rb

@@ -95,6 +95,13 @@ module Sendly
       @contacts ||= ContactsResource.new(self)
     end
 
+    # Access the Enterprise resource
+    #
+    # @return [Sendly::EnterpriseResource]
+    def enterprise
+      @enterprise ||= EnterpriseResource.new(self)
+    end
+
     # Make a GET request
     #
     # @param path [String] API path
@@ -122,6 +129,15 @@ module Sendly
       request(:patch, path, body: body)
     end
 
+    # Make a PUT request
+    #
+    # @param path [String] API path
+    # @param body [Hash] Request body
+    # @return [Hash] Response body
+    def put(path, body = {})
+      request(:put, path, body: body)
+    end
+
     # Make a DELETE request
     #
     # @param path [String] API path
@@ -250,6 +266,8 @@ module Sendly
               Net::HTTP::Get.new(uri)
             when :post
               Net::HTTP::Post.new(uri)
+            when :put
+              Net::HTTP::Put.new(uri)
             when :patch
               Net::HTTP::Patch.new(uri)
             when :delete

data/lib/sendly/enterprise.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+module Sendly
+  class EnterpriseWorkspacesSubResource
+    def initialize(client)
+      @client = client
+    end
+
+    def create(name:, description: nil)
+      raise ArgumentError, "Workspace name is required" if name.nil? || name.strip.empty?
+
+      body = { name: name }
+      body[:description] = description if description
+
+      @client.post("/enterprise/workspaces", body)
+    end
+
+    def list
+      @client.get("/enterprise/workspaces")
+    end
+
+    def get(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}")
+    end
+
+    def delete(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.delete("/enterprise/workspaces/#{workspace_id}")
+    end
+
+    def submit_verification(workspace_id, business_name:, business_type:, ein:, address:, city:, state:, zip:, use_case:, sample_messages:, monthly_volume: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      body = {
+        business_name: business_name,
+        business_type: business_type,
+        ein: ein,
+        address: address,
+        city: city,
+        state: state,
+        zip: zip,
+        use_case: use_case,
+        sample_messages: sample_messages
+      }
+      body[:monthly_volume] = monthly_volume if monthly_volume
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/verification/submit", body)
+    end
+
+    def inherit_verification(workspace_id, source_workspace_id:)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Source workspace ID is required" if source_workspace_id.nil? || source_workspace_id.empty?
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/verification/inherit", {
+        source_workspace_id: source_workspace_id
+      })
+    end
+
+    def get_verification(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/verification")
+    end
+
+    def transfer_credits(workspace_id, source_workspace_id:, amount:)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Source workspace ID is required" if source_workspace_id.nil? || source_workspace_id.empty?
+      raise ArgumentError, "Amount must be a positive number" if !amount.is_a?(Integer) || amount <= 0
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/transfer-credits", {
+        source_workspace_id: source_workspace_id,
+        amount: amount
+      })
+    end
+
+    def get_credits(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/credits")
+    end
+
+    def create_key(workspace_id, name: nil, type: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      body = {}
+      body[:name] = name if name
+      body[:type] = type if type
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/keys", body)
+    end
+
+    def list_keys(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/keys")
+    end
+
+    def revoke_key(workspace_id, key_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Key ID is required" if key_id.nil? || key_id.empty?
+
+      @client.delete("/enterprise/workspaces/#{workspace_id}/keys/#{key_id}")
+    end
+
+    def list_opt_in_pages(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/opt-in-pages")
+    end
+
+    def create_opt_in_page(workspace_id, business_name:, use_case: nil, use_case_summary: nil, sample_messages: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Business name is required" if business_name.nil? || business_name.strip.empty?
+
+      body = { businessName: business_name }
+      body[:useCase] = use_case if use_case
+      body[:useCaseSummary] = use_case_summary if use_case_summary
+      body[:sampleMessages] = sample_messages if sample_messages
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/opt-in-pages", body)
+    end
+
+    def update_opt_in_page(workspace_id, page_id, logo_url: nil, header_color: nil, button_color: nil, custom_headline: nil, custom_benefits: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Page ID is required" if page_id.nil? || page_id.empty?
+
+      body = {}
+      body[:logoUrl] = logo_url unless logo_url.nil?
+      body[:headerColor] = header_color unless header_color.nil?
+      body[:buttonColor] = button_color unless button_color.nil?
+      body[:customHeadline] = custom_headline unless custom_headline.nil?
+      body[:customBenefits] = custom_benefits unless custom_benefits.nil?
+
+      @client.patch("/enterprise/workspaces/#{workspace_id}/opt-in-pages/#{page_id}", body)
+    end
+
+    def delete_opt_in_page(workspace_id, page_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Page ID is required" if page_id.nil? || page_id.empty?
+
+      @client.delete("/enterprise/workspaces/#{workspace_id}/opt-in-pages/#{page_id}")
+    end
+
+    def set_webhook(workspace_id, url:, events: nil, description: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Webhook URL is required" if url.nil? || url.empty?
+
+      body = { url: url }
+      body[:events] = events if events
+      body[:description] = description if description
+
+      @client.put("/enterprise/workspaces/#{workspace_id}/webhooks", body)
+    end
+
+    def list_webhooks(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/webhooks")
+    end
+
+    def delete_webhooks(workspace_id, webhook_id: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      path = "/enterprise/workspaces/#{workspace_id}/webhooks"
+      path += "?webhookId=#{webhook_id}" if webhook_id
+
+      @client.delete(path)
+    end
+
+    def test_webhook(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/webhooks/test")
+    end
+
+    def suspend(workspace_id, reason: nil)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      body = {}
+      body[:reason] = reason if reason
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/suspend", body)
+    end
+
+    def resume(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/resume")
+    end
+
+    def provision_bulk(workspaces)
+      raise ArgumentError, "Workspaces array is required" if workspaces.nil? || !workspaces.is_a?(Array) || workspaces.empty?
+      raise ArgumentError, "Maximum 50 workspaces per bulk provision" if workspaces.length > 50
+
+      @client.post("/enterprise/workspaces/provision/bulk", { workspaces: workspaces })
+    end
+
+    def set_custom_domain(workspace_id, page_id, domain:)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Page ID is required" if page_id.nil? || page_id.empty?
+      raise ArgumentError, "Domain is required" if domain.nil? || domain.empty?
+
+      @client.put("/enterprise/workspaces/#{workspace_id}/pages/#{page_id}/domain", { domain: domain })
+    end
+
+    def send_invitation(workspace_id, email:, role:)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Email is required" if email.nil? || email.empty?
+      raise ArgumentError, "Role is required" if role.nil? || role.empty?
+
+      @client.post("/enterprise/workspaces/#{workspace_id}/invitations", {
+        email: email,
+        role: role
+      })
+    end
+
+    def list_invitations(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/invitations")
+    end
+
+    def cancel_invitation(workspace_id, invite_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+      raise ArgumentError, "Invite ID is required" if invite_id.nil? || invite_id.empty?
+
+      @client.delete("/enterprise/workspaces/#{workspace_id}/invitations/#{invite_id}")
+    end
+
+    def get_quota(workspace_id)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.get("/enterprise/workspaces/#{workspace_id}/quota")
+    end
+
+    def set_quota(workspace_id, monthly_message_quota:)
+      raise ArgumentError, "Workspace ID is required" if workspace_id.nil? || workspace_id.empty?
+
+      @client.put("/enterprise/workspaces/#{workspace_id}/quota", {
+        monthlyMessageQuota: monthly_message_quota
+      })
+    end
+  end
+
+  class EnterpriseWebhooksSubResource
+    def initialize(client)
+      @client = client
+    end
+
+    def set(url:)
+      raise ArgumentError, "Webhook URL is required" if url.nil? || url.empty?
+
+      @client.put("/enterprise/webhooks", { url: url })
+    end
+
+    def get
+      @client.get("/enterprise/webhooks")
+    end
+
+    def delete
+      @client.delete("/enterprise/webhooks")
+    end
+
+    def test
+      @client.post("/enterprise/webhooks/test")
+    end
+  end
+
+  class EnterpriseAnalyticsSubResource
+    def initialize(client)
+      @client = client
+    end
+
+    def overview
+      @client.get("/enterprise/analytics/overview")
+    end
+
+    def messages(period: nil, workspace_id: nil)
+      params = {}
+      params[:period] = period if period
+      params[:workspaceId] = workspace_id if workspace_id
+
+      @client.get("/enterprise/analytics/messages", params)
+    end
+
+    def delivery
+      @client.get("/enterprise/analytics/delivery")
+    end
+
+    def credits(period: nil)
+      params = {}
+      params[:period] = period if period
+
+      @client.get("/enterprise/analytics/credits", params)
+    end
+  end
+
+  class EnterpriseSettingsSubResource
+    def initialize(client)
+      @client = client
+    end
+
+    def get_auto_top_up
+      @client.get("/enterprise/settings/auto-top-up")
+    end
+
+    def update_auto_top_up(enabled:, threshold:, amount:, source_workspace_id: nil)
+      body = {
+        enabled: enabled,
+        threshold: threshold,
+        amount: amount
+      }
+      body[:sourceWorkspaceId] = source_workspace_id if source_workspace_id
+
+      @client.put("/enterprise/settings/auto-top-up", body)
+    end
+  end
+
+  class EnterpriseBillingSubResource
+    def initialize(client)
+      @client = client
+    end
+
+    def get_breakdown(period: nil, page: nil, limit: nil)
+      params = {}
+      params[:period] = period if period
+      params[:page] = page if page
+      params[:limit] = limit if limit
+
+      @client.get("/enterprise/billing/workspace-breakdown", params)
+    end
+  end
+
+  class EnterpriseResource
+    attr_reader :workspaces, :webhooks, :analytics, :settings, :billing
+
+    def initialize(client)
+      @client = client
+      @workspaces = EnterpriseWorkspacesSubResource.new(client)
+      @webhooks = EnterpriseWebhooksSubResource.new(client)
+      @analytics = EnterpriseAnalyticsSubResource.new(client)
+      @settings = EnterpriseSettingsSubResource.new(client)
+      @billing = EnterpriseBillingSubResource.new(client)
+    end
+
+    def get_account
+      @client.get("/enterprise/account")
+    end
+
+    def provision(name:, source_workspace_id: nil, inherit_with_new_number: nil, verification: nil, credit_amount: nil, credit_source_workspace_id: nil, key_name: nil, key_type: nil, webhook_url: nil, generate_opt_in_page: nil)
+      raise ArgumentError, "Workspace name is required" if name.nil? || name.strip.empty?
+
+      body = { name: name }
+      body[:sourceWorkspaceId] = source_workspace_id if source_workspace_id
+      body[:inheritWithNewNumber] = true if inherit_with_new_number
+      body[:verification] = verification if verification
+      body[:creditAmount] = credit_amount if credit_amount
+      body[:creditSourceWorkspaceId] = credit_source_workspace_id if credit_source_workspace_id
+      body[:keyName] = key_name if key_name
+      body[:keyType] = key_type if key_type
+      body[:webhookUrl] = webhook_url if webhook_url
+      body[:generateOptInPage] = generate_opt_in_page unless generate_opt_in_page.nil?
+
+      @client.post("/enterprise/workspaces/provision", body)
+    end
+  end
+end

data/lib/sendly/version.rb

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

data/lib/sendly/webhooks.rb

@@ -12,14 +12,15 @@ module Sendly
   #
   #     def handle
   #       signature = request.headers['X-Sendly-Signature']
+  #       timestamp = request.headers['X-Sendly-Timestamp']
   #       payload = request.raw_post
   #
   #       begin
-  #         event = Sendly::Webhooks.parse_event(payload, signature, ENV['WEBHOOK_SECRET'])
+  #         event = Sendly::Webhooks.parse_event(payload, signature, ENV['WEBHOOK_SECRET'], timestamp: timestamp)
   #
   #         case event.type
   #         when 'message.delivered'
-  #           puts "Message delivered: #{event.data.message_id}"
+  #           puts "Message delivered: #{event.data.id}"
   #         when 'message.failed'
   #           puts "Message failed: #{event.data.error}"
   #         end
@@ -31,21 +32,30 @@ module Sendly
   #     end
   #   end
   module Webhooks
+    SIGNATURE_TOLERANCE_SECONDS = 300
+
     class << self
       # Verify webhook signature from Sendly.
       #
       # @param payload [String] Raw request body as string
       # @param signature [String] X-Sendly-Signature header value
       # @param secret [String] Your webhook secret from dashboard
+      # @param timestamp [String, nil] X-Sendly-Timestamp header value (recommended)
       # @return [Boolean] True if signature is valid, false otherwise
-      def verify_signature(payload, signature, secret)
+      def verify_signature(payload, signature, secret, timestamp: nil)
         return false if payload.nil? || payload.empty?
         return false if signature.nil? || signature.empty?
         return false if secret.nil? || secret.empty?
 
-        expected = 'sha256=' + OpenSSL::HMAC.hexdigest('SHA256', secret, payload)
+        if timestamp
+          signed_payload = "#{timestamp}.#{payload}"
+          return false if (Time.now.to_i - timestamp.to_i).abs > SIGNATURE_TOLERANCE_SECONDS
+        else
+          signed_payload = payload
+        end
+
+        expected = 'sha256=' + OpenSSL::HMAC.hexdigest('SHA256', secret, signed_payload)
 
-        # Timing-safe comparison
         secure_compare(expected, signature)
       end
 
@@ -54,14 +64,17 @@ module Sendly
       # @param payload [String] Raw request body as string
       # @param signature [String] X-Sendly-Signature header value
       # @param secret [String] Your webhook secret from dashboard
+      # @param timestamp [String, nil] X-Sendly-Timestamp header value (recommended)
       # @return [WebhookEvent] Parsed and validated event
       # @raise [WebhookSignatureError] If signature is invalid or payload is malformed
-      def parse_event(payload, signature, secret)
-        raise WebhookSignatureError, 'Invalid webhook signature' unless verify_signature(payload, signature, secret)
+      def parse_event(payload, signature, secret, timestamp: nil)
+        unless verify_signature(payload, signature, secret, timestamp: timestamp)
+          raise WebhookSignatureError, 'Invalid webhook signature'
+        end
 
         data = JSON.parse(payload, symbolize_names: true)
 
-        unless data[:id] && data[:type] && data[:data] && data[:created_at]
+        unless data[:id] && data[:type] && data[:data]
           raise WebhookSignatureError, 'Invalid event structure'
         end
 
@@ -74,14 +87,15 @@ module Sendly
       #
       # @param payload [String] The payload to sign
       # @param secret [String] The secret to use for signing
+      # @param timestamp [String, nil] Optional timestamp to include in signature
       # @return [String] The signature in the format "sha256=..."
-      def generate_signature(payload, secret)
-        'sha256=' + OpenSSL::HMAC.hexdigest('SHA256', secret, payload)
+      def generate_signature(payload, secret, timestamp: nil)
+        signed_payload = timestamp ? "#{timestamp}.#{payload}" : payload
+        'sha256=' + OpenSSL::HMAC.hexdigest('SHA256', secret, signed_payload)
       end
 
       private
 
-      # Timing-safe string comparison
       def secure_compare(a, b)
         return false unless a.bytesize == b.bytesize
 
@@ -93,23 +107,27 @@ module Sendly
     end
   end
 
-  # Webhook signature verification error
   class WebhookSignatureError < Error
     def initialize(message = 'Invalid webhook signature')
       super(message, code: 'WEBHOOK_SIGNATURE_ERROR')
     end
   end
 
-  # Webhook event from Sendly
   class WebhookEvent
-    attr_reader :id, :type, :data, :created_at, :api_version
+    attr_reader :id, :type, :data, :created, :api_version, :livemode
 
     def initialize(data)
       @id = data[:id]
       @type = data[:type]
-      @data = WebhookMessageData.new(data[:data])
-      @created_at = data[:created_at]
-      @api_version = data[:api_version] || '2024-01-01'
+      obj = data[:data][:object] || data[:data]
+      @data = WebhookMessageData.new(obj)
+      @created = data[:created] || data[:created_at] || 0
+      @api_version = data[:api_version] || '2024-01'
+      @livemode = data[:livemode] || false
+    end
+
+    def created_at
+      @created
     end
 
     def to_h
@@ -117,36 +135,48 @@ module Sendly
         id: @id,
         type: @type,
         data: @data.to_h,
-        created_at: @created_at,
-        api_version: @api_version
+        created: @created,
+        api_version: @api_version,
+        livemode: @livemode
       }
     end
   end
 
-  # Webhook message data
   class WebhookMessageData
-    attr_reader :message_id, :status, :to, :from, :error, :error_code,
-                :delivered_at, :failed_at, :segments, :credits_used
+    attr_reader :id, :status, :to, :from, :direction, :organization_id,
+                :text, :error, :error_code, :delivered_at, :failed_at,
+                :created_at, :segments, :credits_used, :message_format, :media_urls
 
     def initialize(data)
-      @message_id = data[:message_id]
+      @id = data[:id] || data[:message_id] || ''
       @status = data[:status]
       @to = data[:to]
       @from = data[:from] || ''
+      @direction = data[:direction] || 'outbound'
+      @organization_id = data[:organization_id]
+      @text = data[:text]
       @error = data[:error]
       @error_code = data[:error_code]
       @delivered_at = data[:delivered_at]
       @failed_at = data[:failed_at]
+      @created_at = data[:created_at]
       @segments = data[:segments] || 1
       @credits_used = data[:credits_used] || 0
+      @message_format = data[:message_format]
+      @media_urls = data[:media_urls]
+    end
+
+    def message_id
+      @id
     end
 
     def to_h
       {
-        message_id: @message_id,
+        id: @id,
         status: @status,
         to: @to,
         from: @from,
+        direction: @direction,
         error: @error,
         error_code: @error_code,
         delivered_at: @delivered_at,

data/lib/sendly.rb

@@ -16,6 +16,7 @@ require_relative "sendly/verify"
 require_relative "sendly/templates_resource"
 require_relative "sendly/campaigns_resource"
 require_relative "sendly/contacts_resource"
+require_relative "sendly/enterprise"
 
 # Sendly Ruby SDK
 #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendly
 version: !ruby/object:Gem::Version
-  version: 3.18.0
+  version: 3.18.2
 platform: ruby
 authors:
 - Sendly
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-02-26 00:00:00.000000000 Z
+date: 2026-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -117,6 +117,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -127,6 +128,7 @@ files:
 - lib/sendly/campaigns_resource.rb
 - lib/sendly/client.rb
 - lib/sendly/contacts_resource.rb
+- lib/sendly/enterprise.rb
 - lib/sendly/errors.rb
 - lib/sendly/media.rb
 - lib/sendly/messages.rb