sentdm 0.32.0 → 0.34.0

data/rbi/sentdm/models/webhook_list_events_response.rbi

@@ -39,9 +39,22 @@ module Sentdm
       attr_accessor :error_message
 
       # The exact event body that was delivered, or attempted, for this record. One of
-      # the four webhook envelopes: a message status change, an inbound message, a
-      # template status change, or a contact consent signal. Read field and event to
-      # tell which, the same way your endpoint does.
+      # the six webhook envelopes:
+      #
+      # message — an outbound message changed status. message with event:
+      # message.received — someone replied to you. templates — a template was approved,
+      # rejected, paused or similar. channel — one of your markets moved in provisioning
+      # or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+      # tracked short link was clicked or a hosted file downloaded, or one expired or
+      # was revoked.
+      #
+      # Read field and event to tell which, the same way your endpoint does. The two
+      # message envelopes are the reason that is two fields and not one: they share a
+      # field and differ by event.
+      #
+      # Treat the list as open. It has grown twice — channel and then link — and a
+      # handler that rejects an envelope it does not recognise will break on the next
+      # addition rather than ignore it.
       sig do
         returns(
           T.nilable(
@@ -59,7 +72,9 @@ module Sentdm
               Sentdm::InboundMessageEvent::OrHash,
               Sentdm::TemplateEvent::OrHash,
               Sentdm::ChannelEvent::OrHash,
-              Sentdm::ContactEvent::OrHash
+              Sentdm::ContactEvent::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::OrHash
             )
         ).void
       end
@@ -96,7 +111,9 @@ module Sentdm
               Sentdm::InboundMessageEvent::OrHash,
               Sentdm::TemplateEvent::OrHash,
               Sentdm::ChannelEvent::OrHash,
-              Sentdm::ContactEvent::OrHash
+              Sentdm::ContactEvent::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::OrHash
             ),
           event_type: String,
           http_status_code: T.nilable(Integer),
@@ -112,9 +129,22 @@ module Sentdm
         delivery_status: nil,
         error_message: nil,
         # The exact event body that was delivered, or attempted, for this record. One of
-        # the four webhook envelopes: a message status change, an inbound message, a
-        # template status change, or a contact consent signal. Read field and event to
-        # tell which, the same way your endpoint does.
+        # the six webhook envelopes:
+        #
+        # message — an outbound message changed status. message with event:
+        # message.received — someone replied to you. templates — a template was approved,
+        # rejected, paused or similar. channel — one of your markets moved in provisioning
+        # or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+        # tracked short link was clicked or a hosted file downloaded, or one expired or
+        # was revoked.
+        #
+        # Read field and event to tell which, the same way your endpoint does. The two
+        # message envelopes are the reason that is two fields and not one: they share a
+        # field and differ by event.
+        #
+        # Treat the list as open. It has grown twice — channel and then link — and a
+        # handler that rejects an envelope it does not recognise will break on the next
+        # addition rather than ignore it.
         event_data: nil,
         event_type: nil,
         http_status_code: nil,
@@ -146,9 +176,22 @@ module Sentdm
       end
 
       # The exact event body that was delivered, or attempted, for this record. One of
-      # the four webhook envelopes: a message status change, an inbound message, a
-      # template status change, or a contact consent signal. Read field and event to
-      # tell which, the same way your endpoint does.
+      # the six webhook envelopes:
+      #
+      # message — an outbound message changed status. message with event:
+      # message.received — someone replied to you. templates — a template was approved,
+      # rejected, paused or similar. channel — one of your markets moved in provisioning
+      # or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+      # tracked short link was clicked or a hosted file downloaded, or one expired or
+      # was revoked.
+      #
+      # Read field and event to tell which, the same way your endpoint does. The two
+      # message envelopes are the reason that is two fields and not one: they share a
+      # field and differ by event.
+      #
+      # Treat the list as open. It has grown twice — channel and then link — and a
+      # handler that rejects an envelope it does not recognise will break on the next
+      # addition rather than ignore it.
       module EventData
         extend Sentdm::Internal::Type::Union
 
@@ -159,10 +202,702 @@ module Sentdm
               Sentdm::InboundMessageEvent,
               Sentdm::TemplateEvent,
               Sentdm::ChannelEvent,
-              Sentdm::ContactEvent
+              Sentdm::ContactEvent,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload
             )
           end
 
+        class SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload,
+                Sentdm::Internal::AnyHash
+              )
+            end
+
+          # The specific event within the family, for example message.delivered,
+          # message.received or contact.opt_out. Absent on events that have no subtype, so
+          # treat it as optional.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :event
+
+          # The event family, for example message, templates or contact. Route on this
+          # first, then on event for the specific change.
+          sig { returns(T.nilable(String)) }
+          attr_reader :field
+
+          sig { params(field: String).void }
+          attr_writer :field
+
+          # Body of a link event: something happened to a tracked link Sent published on the
+          # customer's behalf. A link points either at a URL the customer supplied or at a
+          # file Sent hosts for them; LinkKind says which. Delivered when an eligible
+          # request is served, or when a published link reaches the end of its life.
+          #
+          # A click is a request, not a read receipt. link.clicked means the redirect was
+          # served; link.downloaded means bytes went out. Neither proves a person saw
+          # anything — messaging providers and link scanners fetch URLs on their own, which
+          # is what TrafficClass exists to tell apart. Filter on it before reporting a
+          # click-through rate; treat likely_human as a hint, never as delivery
+          # confirmation.
+          #
+          # RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+          # delivery. One link is hit many times, so those are the two keys a subscriber
+          # needs: group by the first, deduplicate on the second — exactly as on every other
+          # family. The payload carries no event identifier of its own, for the same reason
+          # none of the others do.
+          #
+          # Nothing here identifies the visitor. No IP address and no visitor token crosses
+          # this boundary. Country, Device and Browser are coarse buckets derived at the
+          # edge and are absent whenever the request did not supply enough to derive them.
+          sig do
+            returns(
+              T.nilable(
+                Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload
+              )
+            )
+          end
+          attr_reader :payload
+
+          sig do
+            params(
+              payload:
+                T.nilable(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload::OrHash
+                )
+            ).void
+          end
+          attr_writer :payload
+
+          # The event-specific body.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :request_id
+
+          # When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+          # time, not the time the underlying change happened. Use the timestamp inside the
+          # payload for the latter.
+          sig { returns(T.nilable(String)) }
+          attr_reader :timestamp
+
+          sig { params(timestamp: String).void }
+          attr_writer :timestamp
+
+          # The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
+          # this shape and varies only in Payload.
+          sig do
+            params(
+              event: T.nilable(String),
+              field: String,
+              payload:
+                T.nilable(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload::OrHash
+                ),
+              request_id: T.nilable(String),
+              timestamp: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The specific event within the family, for example message.delivered,
+            # message.received or contact.opt_out. Absent on events that have no subtype, so
+            # treat it as optional.
+            event: nil,
+            # The event family, for example message, templates or contact. Route on this
+            # first, then on event for the specific change.
+            field: nil,
+            # Body of a link event: something happened to a tracked link Sent published on the
+            # customer's behalf. A link points either at a URL the customer supplied or at a
+            # file Sent hosts for them; LinkKind says which. Delivered when an eligible
+            # request is served, or when a published link reaches the end of its life.
+            #
+            # A click is a request, not a read receipt. link.clicked means the redirect was
+            # served; link.downloaded means bytes went out. Neither proves a person saw
+            # anything — messaging providers and link scanners fetch URLs on their own, which
+            # is what TrafficClass exists to tell apart. Filter on it before reporting a
+            # click-through rate; treat likely_human as a hint, never as delivery
+            # confirmation.
+            #
+            # RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+            # delivery. One link is hit many times, so those are the two keys a subscriber
+            # needs: group by the first, deduplicate on the second — exactly as on every other
+            # family. The payload carries no event identifier of its own, for the same reason
+            # none of the others do.
+            #
+            # Nothing here identifies the visitor. No IP address and no visitor token crosses
+            # this boundary. Country, Device and Browser are coarse buckets derived at the
+            # edge and are absent whenever the request did not supply enough to derive them.
+            payload: nil,
+            # The event-specific body.
+            request_id: nil,
+            # When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+            # time, not the time the underlying change happened. Use the timestamp inside the
+            # payload for the latter.
+            timestamp: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                event: T.nilable(String),
+                field: String,
+                payload:
+                  T.nilable(
+                    Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload
+                  ),
+                request_id: T.nilable(String),
+                timestamp: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Payload < Sentdm::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload,
+                  Sentdm::Internal::AnyHash
+                )
+              end
+
+            # The link's public identifier — the eight-character code in the short URL, for
+            # example A78B2BU0. Unique across both kinds, and never reused, so it is the
+            # stable key to group one link's events by.
+            sig { returns(String) }
+            attr_accessor :record_id
+
+            # Where the request appeared to come from, as an ISO 3166-1 alpha-2 code. Named
+            # separately from the country on a channel event, which is a destination market
+            # the customer registered for — this one is a property of a single visitor and is
+            # absent when the edge could not resolve it.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :access_country
+
+            # How the request was served, when the edge recorded it. Free text describing the
+            # outcome — show it to a human rather than branching on it.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :access_outcome
+
+            # The requesting browser family, for example chrome or safari, or unknown. Derived
+            # from the user agent.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :browser
+
+            # How many bytes were served, for a file access. A ranged request reports the
+            # bytes in that range, not the size of the file, so several accesses of one file
+            # can each report a part.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :bytes_served
+
+            # The channel the message carrying this link went out on: sms, whatsapp, or rcs.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :channel
+
+            # The organization the link belongs to. Always the parent account, never a sender
+            # profile — read SenderProfileId for that.
+            #
+            # This family publishes the owner as an explicit pair rather than the single
+            # account_id the other families use. The pair says which organization and which
+            # profile without the subscriber deriving either, which is the trade: one more key
+            # against not having to know that account_id silently becomes the profile when one
+            # exists.
+            sig { returns(T.nilable(String)) }
+            attr_reader :customer_id
+
+            sig { params(customer_id: String).void }
+            attr_writer :customer_id
+
+            # The requesting device class: mobile, tablet, desktop or unknown. Derived from
+            # the user agent.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :device
+
+            # What the link points at: url for a destination the customer supplied, file for
+            # media Sent hosts. Always present, and implied by the event — link.clicked is
+            # always url and link.downloaded always file — but published as its own field so a
+            # subscriber can branch on the kind without parsing the event name, the same
+            # separation the channel family keeps between its event and its status.
+            sig { returns(T.nilable(String)) }
+            attr_reader :link_kind
+
+            sig { params(link_kind: String).void }
+            attr_writer :link_kind
+
+            # The message the link was published in.
+            #
+            # The event can arrive before the message is readable through GET /v3/messages: a
+            # provider may fetch a link within milliseconds of the send, and nothing here
+            # waits for the message row. Retry the read rather than treating an unknown id as
+            # an error.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :message_id
+
+            # When the access or lifecycle change actually happened, in UTC
+            # (yyyy-MM-ddTHH:mm:ssZ). The envelope's timestamp is when Sent emitted the event;
+            # this is when the thing occurred, and the two differ by the ingest delay.
+            sig { returns(T.nilable(String)) }
+            attr_reader :occurred_at
+
+            sig { params(occurred_at: String).void }
+            attr_writer :occurred_at
+
+            # The caller-supplied label tying this link back to a position in the message, for
+            # example body:0 for the first link in the body. Present when the link was created
+            # with one.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :reference_key
+
+            # The host of the page that linked here, when the request supplied one. The host
+            # only — never a full referring URL.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :referrer_host
+
+            # The HTTP method of the request that was served, for an access event. Omitted on
+            # link.expired and link.revoked, which describe no request.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :request_method
+
+            # The sender profile that owns the link, or null when the organization owns it
+            # directly. Always on the wire so a handler reads one shape rather than branching
+            # on whether the key arrived.
+            #
+            # sender_profile_id, not profile_id: the API already publishes
+            # messaging_profile_id and sending_phone_number_profile_id for provider-side
+            # profiles, which are a different thing entirely. The unqualified name would read
+            # as one of those.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :sender_profile_id
+
+            # The HTTP status Sent answered the request with: 302 for a link, 200 or 206 for a
+            # file. Omitted on lifecycle events.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :status_code
+
+            # A coarse guess at what made the request: likely_human, provider (a messaging
+            # platform prefetching the link), bot, or unknown. Derived from the user agent, so
+            # it is a hint for filtering noise rather than a fact to bill or report on.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :traffic_class
+
+            # Body of a link event: something happened to a tracked link Sent published on the
+            # customer's behalf. A link points either at a URL the customer supplied or at a
+            # file Sent hosts for them; LinkKind says which. Delivered when an eligible
+            # request is served, or when a published link reaches the end of its life.
+            #
+            # A click is a request, not a read receipt. link.clicked means the redirect was
+            # served; link.downloaded means bytes went out. Neither proves a person saw
+            # anything — messaging providers and link scanners fetch URLs on their own, which
+            # is what TrafficClass exists to tell apart. Filter on it before reporting a
+            # click-through rate; treat likely_human as a hint, never as delivery
+            # confirmation.
+            #
+            # RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+            # delivery. One link is hit many times, so those are the two keys a subscriber
+            # needs: group by the first, deduplicate on the second — exactly as on every other
+            # family. The payload carries no event identifier of its own, for the same reason
+            # none of the others do.
+            #
+            # Nothing here identifies the visitor. No IP address and no visitor token crosses
+            # this boundary. Country, Device and Browser are coarse buckets derived at the
+            # edge and are absent whenever the request did not supply enough to derive them.
+            sig do
+              params(
+                record_id: String,
+                access_country: T.nilable(String),
+                access_outcome: T.nilable(String),
+                browser: T.nilable(String),
+                bytes_served: T.nilable(Integer),
+                channel: T.nilable(String),
+                customer_id: String,
+                device: T.nilable(String),
+                link_kind: String,
+                message_id: T.nilable(String),
+                occurred_at: String,
+                reference_key: T.nilable(String),
+                referrer_host: T.nilable(String),
+                request_method: T.nilable(String),
+                sender_profile_id: T.nilable(String),
+                status_code: T.nilable(Integer),
+                traffic_class: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The link's public identifier — the eight-character code in the short URL, for
+              # example A78B2BU0. Unique across both kinds, and never reused, so it is the
+              # stable key to group one link's events by.
+              record_id:,
+              # Where the request appeared to come from, as an ISO 3166-1 alpha-2 code. Named
+              # separately from the country on a channel event, which is a destination market
+              # the customer registered for — this one is a property of a single visitor and is
+              # absent when the edge could not resolve it.
+              access_country: nil,
+              # How the request was served, when the edge recorded it. Free text describing the
+              # outcome — show it to a human rather than branching on it.
+              access_outcome: nil,
+              # The requesting browser family, for example chrome or safari, or unknown. Derived
+              # from the user agent.
+              browser: nil,
+              # How many bytes were served, for a file access. A ranged request reports the
+              # bytes in that range, not the size of the file, so several accesses of one file
+              # can each report a part.
+              bytes_served: nil,
+              # The channel the message carrying this link went out on: sms, whatsapp, or rcs.
+              channel: nil,
+              # The organization the link belongs to. Always the parent account, never a sender
+              # profile — read SenderProfileId for that.
+              #
+              # This family publishes the owner as an explicit pair rather than the single
+              # account_id the other families use. The pair says which organization and which
+              # profile without the subscriber deriving either, which is the trade: one more key
+              # against not having to know that account_id silently becomes the profile when one
+              # exists.
+              customer_id: nil,
+              # The requesting device class: mobile, tablet, desktop or unknown. Derived from
+              # the user agent.
+              device: nil,
+              # What the link points at: url for a destination the customer supplied, file for
+              # media Sent hosts. Always present, and implied by the event — link.clicked is
+              # always url and link.downloaded always file — but published as its own field so a
+              # subscriber can branch on the kind without parsing the event name, the same
+              # separation the channel family keeps between its event and its status.
+              link_kind: nil,
+              # The message the link was published in.
+              #
+              # The event can arrive before the message is readable through GET /v3/messages: a
+              # provider may fetch a link within milliseconds of the send, and nothing here
+              # waits for the message row. Retry the read rather than treating an unknown id as
+              # an error.
+              message_id: nil,
+              # When the access or lifecycle change actually happened, in UTC
+              # (yyyy-MM-ddTHH:mm:ssZ). The envelope's timestamp is when Sent emitted the event;
+              # this is when the thing occurred, and the two differ by the ingest delay.
+              occurred_at: nil,
+              # The caller-supplied label tying this link back to a position in the message, for
+              # example body:0 for the first link in the body. Present when the link was created
+              # with one.
+              reference_key: nil,
+              # The host of the page that linked here, when the request supplied one. The host
+              # only — never a full referring URL.
+              referrer_host: nil,
+              # The HTTP method of the request that was served, for an access event. Omitted on
+              # link.expired and link.revoked, which describe no request.
+              request_method: nil,
+              # The sender profile that owns the link, or null when the organization owns it
+              # directly. Always on the wire so a handler reads one shape rather than branching
+              # on whether the key arrived.
+              #
+              # sender_profile_id, not profile_id: the API already publishes
+              # messaging_profile_id and sending_phone_number_profile_id for provider-side
+              # profiles, which are a different thing entirely. The unqualified name would read
+              # as one of those.
+              sender_profile_id: nil,
+              # The HTTP status Sent answered the request with: 302 for a link, 200 or 206 for a
+              # file. Omitted on lifecycle events.
+              status_code: nil,
+              # A coarse guess at what made the request: likely_human, provider (a messaging
+              # platform prefetching the link), bot, or unknown. Derived from the user agent, so
+              # it is a hint for filtering noise rather than a fact to bill or report on.
+              traffic_class: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  record_id: String,
+                  access_country: T.nilable(String),
+                  access_outcome: T.nilable(String),
+                  browser: T.nilable(String),
+                  bytes_served: T.nilable(Integer),
+                  channel: T.nilable(String),
+                  customer_id: String,
+                  device: T.nilable(String),
+                  link_kind: String,
+                  message_id: T.nilable(String),
+                  occurred_at: String,
+                  reference_key: T.nilable(String),
+                  referrer_host: T.nilable(String),
+                  request_method: T.nilable(String),
+                  sender_profile_id: T.nilable(String),
+                  status_code: T.nilable(Integer),
+                  traffic_class: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
+        class SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload,
+                Sentdm::Internal::AnyHash
+              )
+            end
+
+          # The specific event within the family, for example message.delivered,
+          # message.received or contact.opt_out. Absent on events that have no subtype, so
+          # treat it as optional.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :event
+
+          # The event family, for example message, templates or contact. Route on this
+          # first, then on event for the specific change.
+          sig { returns(T.nilable(String)) }
+          attr_reader :field
+
+          sig { params(field: String).void }
+          attr_writer :field
+
+          # Body of a call.initiated, call.answered, call.completed, call.failed or
+          # call.recording_ready event. Which of them occurred is the envelope's event.
+          #
+          # Shaped like the message, inbound, template and channel payloads: account_id
+          # names the account the event is about, channel names the channel, and updated_at
+          # is when the change happened on the call, in the same yyyy-MM-ddTHH:mm:ssZ form.
+          # duration_seconds and price are added on call.completed, reason on call.failed
+          # and recording_id on call.recording_ready; each is omitted rather than sent as
+          # null when it does not apply.
+          #
+          # Casing is snake_case because these ride the same webhook stream customers
+          # already parse message_id from; the question/answer contract is a separate
+          # surface and stays camelCase. Nothing here is provider-shaped: no provider call
+          # id, no namespaced identity.
+          sig do
+            returns(
+              T.nilable(
+                Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::Payload
+              )
+            )
+          end
+          attr_reader :payload
+
+          sig do
+            params(
+              payload:
+                T.nilable(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::Payload::OrHash
+                )
+            ).void
+          end
+          attr_writer :payload
+
+          # The event-specific body.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :request_id
+
+          # When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+          # time, not the time the underlying change happened. Use the timestamp inside the
+          # payload for the latter.
+          sig { returns(T.nilable(String)) }
+          attr_reader :timestamp
+
+          sig { params(timestamp: String).void }
+          attr_writer :timestamp
+
+          # The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
+          # this shape and varies only in Payload.
+          sig do
+            params(
+              event: T.nilable(String),
+              field: String,
+              payload:
+                T.nilable(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::Payload::OrHash
+                ),
+              request_id: T.nilable(String),
+              timestamp: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The specific event within the family, for example message.delivered,
+            # message.received or contact.opt_out. Absent on events that have no subtype, so
+            # treat it as optional.
+            event: nil,
+            # The event family, for example message, templates or contact. Route on this
+            # first, then on event for the specific change.
+            field: nil,
+            # Body of a call.initiated, call.answered, call.completed, call.failed or
+            # call.recording_ready event. Which of them occurred is the envelope's event.
+            #
+            # Shaped like the message, inbound, template and channel payloads: account_id
+            # names the account the event is about, channel names the channel, and updated_at
+            # is when the change happened on the call, in the same yyyy-MM-ddTHH:mm:ssZ form.
+            # duration_seconds and price are added on call.completed, reason on call.failed
+            # and recording_id on call.recording_ready; each is omitted rather than sent as
+            # null when it does not apply.
+            #
+            # Casing is snake_case because these ride the same webhook stream customers
+            # already parse message_id from; the question/answer contract is a separate
+            # surface and stays camelCase. Nothing here is provider-shaped: no provider call
+            # id, no namespaced identity.
+            payload: nil,
+            # The event-specific body.
+            request_id: nil,
+            # When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+            # time, not the time the underlying change happened. Use the timestamp inside the
+            # payload for the latter.
+            timestamp: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                event: T.nilable(String),
+                field: String,
+                payload:
+                  T.nilable(
+                    Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::Payload
+                  ),
+                request_id: T.nilable(String),
+                timestamp: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Payload < Sentdm::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::Payload,
+                  Sentdm::Internal::AnyHash
+                )
+              end
+
+            # Sent's call id, the same one the customer saw on the first question.
+            sig { returns(String) }
+            attr_accessor :call_id
+
+            # The account the call belongs to: the key's own customer, or the sender profile
+            # it acted as.
+            sig { returns(T.nilable(String)) }
+            attr_reader :account_id
+
+            sig { params(account_id: String).void }
+            attr_writer :account_id
+
+            # Always voice.
+            sig { returns(T.nilable(String)) }
+            attr_reader :channel
+
+            sig { params(channel: String).void }
+            attr_writer :channel
+
+            # How long the call lasted. Only on call.completed.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :duration_seconds
+
+            # The customer number that owns the call, in E.164 format.
+            sig { returns(T.nilable(String)) }
+            attr_reader :number
+
+            sig { params(number: String).void }
+            attr_writer :number
+
+            # What the call was charged. Only on call.completed, and omitted there until
+            # billing has recorded the charge.
+            sig { returns(T.nilable(Float)) }
+            attr_accessor :price
+
+            # The machine-readable reason the call did not complete. Only on call.failed, and
+            # omitted when no reason was recorded.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :reason
+
+            # The recording that became available, the same id GET /v3/calls/{id}/recordings
+            # lists it under. Only on call.recording_ready, which is sent once per recording.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :recording_id
+
+            # When the change happened on the call, as opposed to when the event was emitted.
+            sig { returns(T.nilable(String)) }
+            attr_reader :updated_at
+
+            sig { params(updated_at: String).void }
+            attr_writer :updated_at
+
+            # Body of a call.initiated, call.answered, call.completed, call.failed or
+            # call.recording_ready event. Which of them occurred is the envelope's event.
+            #
+            # Shaped like the message, inbound, template and channel payloads: account_id
+            # names the account the event is about, channel names the channel, and updated_at
+            # is when the change happened on the call, in the same yyyy-MM-ddTHH:mm:ssZ form.
+            # duration_seconds and price are added on call.completed, reason on call.failed
+            # and recording_id on call.recording_ready; each is omitted rather than sent as
+            # null when it does not apply.
+            #
+            # Casing is snake_case because these ride the same webhook stream customers
+            # already parse message_id from; the question/answer contract is a separate
+            # surface and stays camelCase. Nothing here is provider-shaped: no provider call
+            # id, no namespaced identity.
+            sig do
+              params(
+                call_id: String,
+                account_id: String,
+                channel: String,
+                duration_seconds: T.nilable(Integer),
+                number: String,
+                price: T.nilable(Float),
+                reason: T.nilable(String),
+                recording_id: T.nilable(String),
+                updated_at: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Sent's call id, the same one the customer saw on the first question.
+              call_id:,
+              # The account the call belongs to: the key's own customer, or the sender profile
+              # it acted as.
+              account_id: nil,
+              # Always voice.
+              channel: nil,
+              # How long the call lasted. Only on call.completed.
+              duration_seconds: nil,
+              # The customer number that owns the call, in E.164 format.
+              number: nil,
+              # What the call was charged. Only on call.completed, and omitted there until
+              # billing has recorded the charge.
+              price: nil,
+              # The machine-readable reason the call did not complete. Only on call.failed, and
+              # omitted when no reason was recorded.
+              reason: nil,
+              # The recording that became available, the same id GET /v3/calls/{id}/recordings
+              # lists it under. Only on call.recording_ready, which is sent once per recording.
+              recording_id: nil,
+              # When the change happened on the call, as opposed to when the event was emitted.
+              updated_at: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  call_id: String,
+                  account_id: String,
+                  channel: String,
+                  duration_seconds: T.nilable(Integer),
+                  number: String,
+                  price: T.nilable(Float),
+                  reason: T.nilable(String),
+                  recording_id: T.nilable(String),
+                  updated_at: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
         sig do
           override.returns(
             T::Array[