late-sdk 0.0.725 → 0.0.726

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65aaf8b2bc3bb1e402c75d2e6c50db0a9177f9085a7c66b77b7ef2a3474f1eda
-  data.tar.gz: 710864477441e625408d5d03282ca1899b23477cfa86d187f0f33fa3101e2754
+  metadata.gz: 389c2a6db9bcb1e1bfe4682df90c5ef3f73f8b23ee2bbb4a418ff43737c991c6
+  data.tar.gz: 6a98465ee15e882eda3f4a8ce86d943f0792388649bed0683535bd2610940128
 SHA512:
-  metadata.gz: 15df9bcbbcbcf159e4ce2a1f314b7e5de4337625c9890ebc5246851f81aef238007c4f2ac8fc19031a1d8f994d2d567708fa06b2e9934cf1e6128f2252dd25e1
-  data.tar.gz: e3617905c7f2f098c9a77c6a3f0ab2a339b40e77f14335349e165d08c2fc3fee48c625f039f70222ec0a5006809e93a073b26900e9980d70a684aa89f6072c5e
+  metadata.gz: 94468de2ca9483929a9a94a401ea2dadb816e47fbc6517901a1f9d566be02d4d3b2313ec219bb7cb763f6262e13749b11a668f7f8d027a4cb72122e0903c640c
+  data.tar.gz: 80f6f893e201edb178ced529fb411564b0740fd0256024e777bcb481f065cdd7fe653f86b95c827e7eeb674614fa1b2b24ff42a854f614944cbb212f2c24220f

data/README.md

@@ -1862,6 +1862,7 @@ Class | Method | HTTP request | Description
  - [Zernio::SendDiscordDirectMessageRequestAttachmentsInner](docs/SendDiscordDirectMessageRequestAttachmentsInner.md)
  - [Zernio::SendInboxMessage200Response](docs/SendInboxMessage200Response.md)
  - [Zernio::SendInboxMessage200ResponseData](docs/SendInboxMessage200ResponseData.md)
+ - [Zernio::SendInboxMessage200ResponseDataAttachmentsInner](docs/SendInboxMessage200ResponseDataAttachmentsInner.md)
  - [Zernio::SendInboxMessage400Response](docs/SendInboxMessage400Response.md)
  - [Zernio::SendInboxMessage400ResponsePlatformError](docs/SendInboxMessage400ResponsePlatformError.md)
  - [Zernio::SendInboxMessageRequest](docs/SendInboxMessageRequest.md)

data/docs/MessagesApi.md

@@ -854,7 +854,7 @@ end
 
 Send message
 
-Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours. 
+Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours.  Only successful (2xx) responses are stored for replay: if the request throws or returns a non-2xx status, the key is released so the same key can be retried once the problem is fixed. The header therefore protects the \"request succeeded but the response was lost\" case. For an ambiguous failure (a 5xx or a network timeout), reconcile before retrying: a failure after the platform already accepted the message also releases the key, and a blind retry could send it twice. List the conversation's messages first, and treat an empty result as inconclusive rather than as proof nothing was sent, since a send that failed while being recorded leaves no trace on our side. 
 
 ### Examples
 

data/docs/SendInboxMessage200ResponseData.md

@@ -4,10 +4,9 @@
 
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
-| **message_id** | **String** | ID of the sent message (not returned for Reddit) | [optional] |
-| **conversation_id** | **String** | Twitter conversation ID | [optional] |
-| **sent_at** | **Time** | Bluesky sent timestamp | [optional] |
-| **message** | **String** | Success message (Reddit only) | [optional] |
+| **message_id** | **String** | Platform id of the sent message (not returned for Reddit). For WhatsApp this is the raw Meta wamid, the same id delivered as message.platformMessageId on webhooks and delivery-status updates, and the value to pass as replyTo to quote-reply. | [optional] |
+| **conversation_id** | **String** | Zernio conversation id, echoed so the thread can be read back or replied to. It equals the id the list-conversations endpoint returns for Telegram, WhatsApp, SMS and Slack; for Facebook, Instagram, Bluesky and Reddit that endpoint returns the platform thread id instead, so do not correlate the two by equality. For X (Twitter), when the request addressed the conversation by its Twitter dm_conversation_id, that platform id is echoed back instead. Omitted when the send succeeded but the conversation could not be resolved to a stored record. | [optional] |
+| **attachments** | [**Array<SendInboxMessage200ResponseDataAttachmentsInner>**](SendInboxMessage200ResponseDataAttachmentsInner.md) | Echo of the sent attachment with its resolved public URL, when one is available (Facebook, Instagram, Telegram, WhatsApp). | [optional] |
 
 ## Example
 
@@ -17,8 +16,7 @@ require 'zernio-sdk'
 instance = Zernio::SendInboxMessage200ResponseData.new(
   message_id: null,
   conversation_id: null,
-  sent_at: null,
-  message: null
+  attachments: null
 )
 ```
 

data/docs/SendInboxMessage200ResponseDataAttachmentsInner.md

@@ -0,0 +1,20 @@
+# Zernio::SendInboxMessage200ResponseDataAttachmentsInner
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **type** | **String** |  | [optional] |
+| **url** | **String** |  | [optional] |
+
+## Example
+
+```ruby
+require 'zernio-sdk'
+
+instance = Zernio::SendInboxMessage200ResponseDataAttachmentsInner.new(
+  type: null,
+  url: null
+)
+```
+

data/lib/zernio-sdk/api/messages_api.rb

@@ -932,7 +932,7 @@ module Zernio
     end
 
     # Send message
-    # Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours. 
+    # Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours.  Only successful (2xx) responses are stored for replay: if the request throws or returns a non-2xx status, the key is released so the same key can be retried once the problem is fixed. The header therefore protects the \"request succeeded but the response was lost\" case. For an ambiguous failure (a 5xx or a network timeout), reconcile before retrying: a failure after the platform already accepted the message also releases the key, and a blind retry could send it twice. List the conversation's messages first, and treat an empty result as inconclusive rather than as proof nothing was sent, since a send that failed while being recorded leaves no trace on our side. 
     # @param conversation_id [String] Opaque conversation identifier, accepted verbatim from the list endpoint or from the conversationId on inbox webhooks. Format not to be assumed.
     # @param send_inbox_message_request [SendInboxMessageRequest] 
     # @param [Hash] opts the optional parameters
@@ -944,7 +944,7 @@ module Zernio
     end
 
     # Send message
-    # Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours. 
+    # Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours.  Only successful (2xx) responses are stored for replay: if the request throws or returns a non-2xx status, the key is released so the same key can be retried once the problem is fixed. The header therefore protects the \"request succeeded but the response was lost\" case. For an ambiguous failure (a 5xx or a network timeout), reconcile before retrying: a failure after the platform already accepted the message also releases the key, and a blind retry could send it twice. List the conversation's messages first, and treat an empty result as inconclusive rather than as proof nothing was sent, since a send that failed while being recorded leaves no trace on our side. 
     # @param conversation_id [String] Opaque conversation identifier, accepted verbatim from the list endpoint or from the conversationId on inbox webhooks. Format not to be assumed.
     # @param send_inbox_message_request [SendInboxMessageRequest] 
     # @param [Hash] opts the optional parameters

data/lib/zernio-sdk/models/send_inbox_message200_response_data.rb

@@ -15,25 +15,21 @@ require 'time'
 
 module Zernio
   class SendInboxMessage200ResponseData < ApiModelBase
-    # ID of the sent message (not returned for Reddit)
+    # Platform id of the sent message (not returned for Reddit). For WhatsApp this is the raw Meta wamid, the same id delivered as message.platformMessageId on webhooks and delivery-status updates, and the value to pass as replyTo to quote-reply.
     attr_accessor :message_id
 
-    # Twitter conversation ID
+    # Zernio conversation id, echoed so the thread can be read back or replied to. It equals the id the list-conversations endpoint returns for Telegram, WhatsApp, SMS and Slack; for Facebook, Instagram, Bluesky and Reddit that endpoint returns the platform thread id instead, so do not correlate the two by equality. For X (Twitter), when the request addressed the conversation by its Twitter dm_conversation_id, that platform id is echoed back instead. Omitted when the send succeeded but the conversation could not be resolved to a stored record.
     attr_accessor :conversation_id
 
-    # Bluesky sent timestamp
-    attr_accessor :sent_at
-
-    # Success message (Reddit only)
-    attr_accessor :message
+    # Echo of the sent attachment with its resolved public URL, when one is available (Facebook, Instagram, Telegram, WhatsApp).
+    attr_accessor :attachments
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'message_id' => :'messageId',
         :'conversation_id' => :'conversationId',
-        :'sent_at' => :'sentAt',
-        :'message' => :'message'
+        :'attachments' => :'attachments'
       }
     end
 
@@ -52,17 +48,13 @@ module Zernio
       {
         :'message_id' => :'String',
         :'conversation_id' => :'String',
-        :'sent_at' => :'Time',
-        :'message' => :'String'
+        :'attachments' => :'Array<SendInboxMessage200ResponseDataAttachmentsInner>'
       }
     end
 
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
-        :'conversation_id',
-        :'sent_at',
-        :'message'
       ])
     end
 
@@ -90,12 +82,10 @@ module Zernio
         self.conversation_id = attributes[:'conversation_id']
       end
 
-      if attributes.key?(:'sent_at')
-        self.sent_at = attributes[:'sent_at']
-      end
-
-      if attributes.key?(:'message')
-        self.message = attributes[:'message']
+      if attributes.key?(:'attachments')
+        if (value = attributes[:'attachments']).is_a?(Array)
+          self.attachments = value
+        end
       end
     end
 
@@ -121,8 +111,7 @@ module Zernio
       self.class == o.class &&
           message_id == o.message_id &&
           conversation_id == o.conversation_id &&
-          sent_at == o.sent_at &&
-          message == o.message
+          attachments == o.attachments
     end
 
     # @see the `==` method
@@ -134,7 +123,7 @@ module Zernio
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [message_id, conversation_id, sent_at, message].hash
+      [message_id, conversation_id, attachments].hash
     end
 
     # Builds the object from hash

data/lib/zernio-sdk/models/send_inbox_message200_response_data_attachments_inner.rb

@@ -0,0 +1,156 @@
+=begin
+#Zernio API
+
+#API reference for Zernio. Authenticate with a Bearer API key. Base URL: https://zernio.com/api 
+
+The version of the OpenAPI document: 1.0.4
+Contact: support@zernio.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.19.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Zernio
+  class SendInboxMessage200ResponseDataAttachmentsInner < ApiModelBase
+    attr_accessor :type
+
+    attr_accessor :url
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'type' => :'type',
+        :'url' => :'url'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'type' => :'String',
+        :'url' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Zernio::SendInboxMessage200ResponseDataAttachmentsInner` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Zernio::SendInboxMessage200ResponseDataAttachmentsInner`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'type')
+        self.type = attributes[:'type']
+      end
+
+      if attributes.key?(:'url')
+        self.url = attributes[:'url']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          type == o.type &&
+          url == o.url
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [type, url].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/zernio-sdk/version.rb

@@ -11,5 +11,5 @@ Generator version: 7.19.0
 =end
 
 module Zernio
-  VERSION = '0.0.725'
+  VERSION = '0.0.726'
 end

data/lib/zernio-sdk.rb

@@ -1237,6 +1237,7 @@ require 'zernio-sdk/models/send_discord_direct_message_request'
 require 'zernio-sdk/models/send_discord_direct_message_request_attachments_inner'
 require 'zernio-sdk/models/send_inbox_message200_response'
 require 'zernio-sdk/models/send_inbox_message200_response_data'
+require 'zernio-sdk/models/send_inbox_message200_response_data_attachments_inner'
 require 'zernio-sdk/models/send_inbox_message400_response'
 require 'zernio-sdk/models/send_inbox_message400_response_platform_error'
 require 'zernio-sdk/models/send_inbox_message_request'

data/openapi.yaml

@@ -25894,6 +25894,17 @@ paths:
         instead of sending the message a second time; same key + different body
         returns 422; a key still in flight returns 409. Works for JSON and
         multipart (file upload) requests alike. Keys are retained for 24 hours.
+
+        Only successful (2xx) responses are stored for replay: if the request
+        throws or returns a non-2xx status, the key is released so the same key
+        can be retried once the problem is fixed. The header therefore protects
+        the "request succeeded but the response was lost" case. For an ambiguous
+        failure (a 5xx or a network timeout), reconcile before retrying: a
+        failure after the platform already accepted the message also releases
+        the key, and a blind retry could send it twice. List the conversation's
+        messages first, and treat an empty result as inconclusive rather than
+        as proof nothing was sent, since a send that failed while being recorded
+        leaves no trace on our side.
       tags: [Messages]
       security: [{ bearerAuth: [] }]
       parameters:
@@ -26434,10 +26445,20 @@ paths:
                   data:
                     type: object
                     properties:
-                      messageId: { type: string, description: ID of the sent message (not returned for Reddit) }
-                      conversationId: { type: [string, "null"], description: Twitter conversation ID }
-                      sentAt: { type: [string, "null"], format: date-time, description: Bluesky sent timestamp }
-                      message: { type: [string, "null"], description: Success message (Reddit only) }
+                      messageId:
+                        type: string
+                        description: 'Platform id of the sent message (not returned for Reddit). For WhatsApp this is the raw Meta wamid, the same id delivered as message.platformMessageId on webhooks and delivery-status updates, and the value to pass as replyTo to quote-reply.'
+                      conversationId:
+                        type: string
+                        description: 'Zernio conversation id, echoed so the thread can be read back or replied to. It equals the id the list-conversations endpoint returns for Telegram, WhatsApp, SMS and Slack; for Facebook, Instagram, Bluesky and Reddit that endpoint returns the platform thread id instead, so do not correlate the two by equality. For X (Twitter), when the request addressed the conversation by its Twitter dm_conversation_id, that platform id is echoed back instead. Omitted when the send succeeded but the conversation could not be resolved to a stored record.'
+                      attachments:
+                        type: array
+                        description: 'Echo of the sent attachment with its resolved public URL, when one is available (Facebook, Instagram, Telegram, WhatsApp).'
+                        items:
+                          type: object
+                          properties:
+                            type: { type: string }
+                            url: { type: string }
         '400':
           description: 'Bad request (e.g., attachment not supported for platform, validation error, category combined with a template or attachment, category used on a non-WhatsApp account, or the WhatsApp Business Account is not eligible for Direct Send)'
           content:

data/spec/api/messages_api_spec.rb

@@ -196,7 +196,7 @@ describe 'MessagesApi' do
 
   # unit tests for send_inbox_message
   # Send message
-  # Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours. 
+  # Send a message in a conversation. Supports text, attachments, quick replies, buttons, templates, and message tags. Attachment and interactive message support varies by platform.  WhatsApp template messages: to send an approved template into this conversation (required when the 24-hour customer-service window is closed), use the `template` field with a single element carrying the template reference: `{ \"elements\": [{ \"name\": ..., \"language\": ..., \"components\": [...] }] }`. See the `template` field below for the exact shape. To send a template to a phone number you have no conversation with yet, use the create-conversation endpoint (POST /v1/inbox/conversations) instead.  WhatsApp rich interactive messages (list, CTA URL, Flow, location request) are available via the `interactive` field. Tap events are delivered through the `message.received` webhook with WhatsApp-specific `metadata` fields (`interactiveType`, `interactiveId`, `flowResponseJson`, `flowResponseData`).  **Idempotency:** send an `Idempotency-Key` header to make retries safe (e.g. after a client-side timeout where delivery is unknown): same key + same body replays the original response (with `Idempotent-Replayed: true`) instead of sending the message a second time; same key + different body returns 422; a key still in flight returns 409. Works for JSON and multipart (file upload) requests alike. Keys are retained for 24 hours.  Only successful (2xx) responses are stored for replay: if the request throws or returns a non-2xx status, the key is released so the same key can be retried once the problem is fixed. The header therefore protects the \"request succeeded but the response was lost\" case. For an ambiguous failure (a 5xx or a network timeout), reconcile before retrying: a failure after the platform already accepted the message also releases the key, and a blind retry could send it twice. List the conversation's messages first, and treat an empty result as inconclusive rather than as proof nothing was sent, since a send that failed while being recorded leaves no trace on our side. 
   # @param conversation_id Opaque conversation identifier, accepted verbatim from the list endpoint or from the conversationId on inbox webhooks. Format not to be assumed.
   # @param send_inbox_message_request 
   # @param [Hash] opts the optional parameters

data/spec/models/send_inbox_message200_response_data_attachments_inner_spec.rb

@@ -0,0 +1,42 @@
+=begin
+#Zernio API
+
+#API reference for Zernio. Authenticate with a Bearer API key. Base URL: https://zernio.com/api 
+
+The version of the OpenAPI document: 1.0.4
+Contact: support@zernio.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.19.0
+
+=end
+
+require 'spec_helper'
+require 'json'
+require 'date'
+
+# Unit tests for Zernio::SendInboxMessage200ResponseDataAttachmentsInner
+# Automatically generated by openapi-generator (https://openapi-generator.tech)
+# Please update as you see appropriate
+describe Zernio::SendInboxMessage200ResponseDataAttachmentsInner do
+  #let(:instance) { Zernio::SendInboxMessage200ResponseDataAttachmentsInner.new }
+
+  describe 'test an instance of SendInboxMessage200ResponseDataAttachmentsInner' do
+    it 'should create an instance of SendInboxMessage200ResponseDataAttachmentsInner' do
+      # uncomment below to test the instance creation
+      #expect(instance).to be_instance_of(Zernio::SendInboxMessage200ResponseDataAttachmentsInner)
+    end
+  end
+
+  describe 'test attribute "type"' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  describe 'test attribute "url"' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+end

data/spec/models/send_inbox_message200_response_data_spec.rb

@@ -39,13 +39,7 @@ describe Zernio::SendInboxMessage200ResponseData do
     end
   end
 
-  describe 'test attribute "sent_at"' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
-    end
-  end
-
-  describe 'test attribute "message"' do
+  describe 'test attribute "attachments"' do
     it 'should work' do
       # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: late-sdk
 version: !ruby/object:Gem::Version
-  version: 0.0.725
+  version: 0.0.726
 platform: ruby
 authors:
 - OpenAPI-Generator
@@ -1330,6 +1330,7 @@ files:
 - docs/SendDiscordDirectMessageRequestAttachmentsInner.md
 - docs/SendInboxMessage200Response.md
 - docs/SendInboxMessage200ResponseData.md
+- docs/SendInboxMessage200ResponseDataAttachmentsInner.md
 - docs/SendInboxMessage400Response.md
 - docs/SendInboxMessage400ResponsePlatformError.md
 - docs/SendInboxMessageRequest.md
@@ -3110,6 +3111,7 @@ files:
 - lib/zernio-sdk/models/send_discord_direct_message_request_attachments_inner.rb
 - lib/zernio-sdk/models/send_inbox_message200_response.rb
 - lib/zernio-sdk/models/send_inbox_message200_response_data.rb
+- lib/zernio-sdk/models/send_inbox_message200_response_data_attachments_inner.rb
 - lib/zernio-sdk/models/send_inbox_message400_response.rb
 - lib/zernio-sdk/models/send_inbox_message400_response_platform_error.rb
 - lib/zernio-sdk/models/send_inbox_message_request.rb
@@ -4864,6 +4866,7 @@ files:
 - spec/models/send_discord_direct_message200_response_spec.rb
 - spec/models/send_discord_direct_message_request_attachments_inner_spec.rb
 - spec/models/send_discord_direct_message_request_spec.rb
+- spec/models/send_inbox_message200_response_data_attachments_inner_spec.rb
 - spec/models/send_inbox_message200_response_data_spec.rb
 - spec/models/send_inbox_message200_response_spec.rb
 - spec/models/send_inbox_message400_response_platform_error_spec.rb
@@ -5336,7 +5339,7 @@ files:
 - spec/models/you_tube_video_retention_response_retention_curve_inner_spec.rb
 - spec/models/you_tube_video_retention_response_spec.rb
 - spec/spec_helper.rb
-- zernio-sdk-0.0.725.gem
+- zernio-sdk-0.0.726.gem
 - zernio-sdk.gemspec
 homepage: https://openapi-generator.tech
 licenses:
@@ -6639,6 +6642,7 @@ test_files:
 - spec/models/ad_tree_campaign_budget_spec.rb
 - spec/models/add_message_reaction_request_spec.rb
 - spec/models/add_users_to_ad_audience_request_users_inner_spec.rb
+- spec/models/send_inbox_message200_response_data_attachments_inner_spec.rb
 - spec/models/create_sequence200_response_sequence_spec.rb
 - spec/models/get_linked_in_organizations200_response_organizations_inner_spec.rb
 - spec/models/instagram_account_insights_response_metrics_value_values_inner_spec.rb