sentdm 0.33.0 → 0.34.0

data/rbi/sentdm/models/message_retrieve_status_response.rbi

@@ -198,6 +198,20 @@ module Sentdm
         sig { returns(T.nilable(Float)) }
         attr_accessor :price
 
+        # A human-readable sentence for reason_code, for example "Insufficient balance".
+        # Omitted whenever reason_code is.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # Why the message is at its current status, as a stable platform code such as
+        # DELIVERY_007, BUSINESS_003 or DELIVERY_003. Present when the current status is
+        # FAILED, FILTERED or BLOCKED and the lifecycle was loaded; omitted otherwise.
+        # Switch on this rather than on reason: the code is stable, the wording may be
+        # improved. It is the platform's classification of the outcome, never a carrier or
+        # vendor code.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason_code
+
         sig { returns(T.nilable(String)) }
         attr_reader :region_code
 
@@ -247,6 +261,8 @@ module Sentdm
             phone: String,
             phone_international: String,
             price: T.nilable(Float),
+            reason: T.nilable(String),
+            reason_code: T.nilable(String),
             region_code: String,
             status: String,
             template_category: T.nilable(String),
@@ -276,6 +292,16 @@ module Sentdm
           phone: nil,
           phone_international: nil,
           price: nil,
+          # A human-readable sentence for reason_code, for example "Insufficient balance".
+          # Omitted whenever reason_code is.
+          reason: nil,
+          # Why the message is at its current status, as a stable platform code such as
+          # DELIVERY_007, BUSINESS_003 or DELIVERY_003. Present when the current status is
+          # FAILED, FILTERED or BLOCKED and the lifecycle was loaded; omitted otherwise.
+          # Switch on this rather than on reason: the code is stable, the wording may be
+          # improved. It is the platform's classification of the outcome, never a carrier or
+          # vendor code.
+          reason_code: nil,
           region_code: nil,
           status: nil,
           template_category: nil,
@@ -307,6 +333,8 @@ module Sentdm
               phone: String,
               phone_international: String,
               price: T.nilable(Float),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String),
               region_code: String,
               status: String,
               template_category: T.nilable(String),
@@ -336,15 +364,39 @@ module Sentdm
           sig { returns(T.nilable(String)) }
           attr_accessor :description
 
+          # A human-readable sentence for reason_code. Omitted whenever reason_code is.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reason
+
+          # Why the message reached this status, as a stable platform code such as
+          # DELIVERY_007. Present on FAILED, FILTERED and BLOCKED events; omitted on every
+          # status that needs no explanation. Same wire name and vocabulary as on the
+          # activities list and the webhook.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reason_code
+
           # Represents a status change event in a message's lifecycle (v3)
           sig do
             params(
               status: String,
               timestamp: Time,
-              description: T.nilable(String)
+              description: T.nilable(String),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String)
             ).returns(T.attached_class)
           end
-          def self.new(status:, timestamp:, description: nil)
+          def self.new(
+            status:,
+            timestamp:,
+            description: nil,
+            # A human-readable sentence for reason_code. Omitted whenever reason_code is.
+            reason: nil,
+            # Why the message reached this status, as a stable platform code such as
+            # DELIVERY_007. Present on FAILED, FILTERED and BLOCKED events; omitted on every
+            # status that needs no explanation. Same wire name and vocabulary as on the
+            # activities list and the webhook.
+            reason_code: nil
+          )
           end
 
           sig do
@@ -352,7 +404,9 @@ module Sentdm
               {
                 status: String,
                 timestamp: Time,
-                description: T.nilable(String)
+                description: T.nilable(String),
+                reason: T.nilable(String),
+                reason_code: T.nilable(String)
               }
             )
           end
@@ -619,38 +673,87 @@ module Sentdm
                 )
               end
 
-            # One of Constants.MmsMediaTypes when known. Advisory — the carrier reads the
-            # fetched object's Content-Type, not this.
+            # One of MmsMediaTypes when the content type is known. Advisory — a reader should
+            # trust the fetched object's own Content-Type.
             sig { returns(T.nilable(String)) }
             attr_accessor :media_type
 
+            # Content type as the provider declared it. Null when it declared none.
             sig { returns(T.nilable(String)) }
-            attr_reader :url
+            attr_accessor :mime_type
 
-            sig { params(url: String).void }
-            attr_writer :url
+            # Size as the provider declared it. Never measured here — nothing downloads the
+            # file.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :size_bytes
 
-            # One attachment on a message: a customer-supplied public URL handed to the
-            # carrier as-is.
+            # Inbound only: the SHA-256 the provider declared alongside the attachment, when
+            # it declared one. Relayed to the customer so they can verify what they fetch
+            # matches what the carrier said it sent. It is the only integrity signal available
+            # on an attachment nobody here has read.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :source_hash_sha256
+
+            # Where the file lives. Outbound: the URL the customer gave us and the carrier
+            # fetched. Inbound: the URL the carrier hosts it at, relayed unchanged.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :url
+
+            # One attachment on a message, in either direction — and in both, a URL somebody
+            # else hosts.
             #
-            #              A URL and nothing else. sent.dm never takes custody of MMS media — the customer hosts it and we
-            #              pass the link through at send time — so there is no storage key, size or expiry to record. If we ever
-            #              do host attachments, that belongs with the change that introduces the hosting, not here.
+            # Outbound: the customer supplied a public URL and we handed it to the carrier.
+            # Inbound: the carrier hosts the file and we record where. sent.dm never holds the
+            # bytes, so there is no key, no expiry bookkeeping and nothing minted per read —
+            # what is stored is what is served.
+            #
+            # An inbound link expires on the carrier's own schedule and is unauthenticated.
+            # That is the customer's to manage, and it is documented where they will see it
+            # rather than only here — a recipient who needs an attachment to outlive that
+            # window copies it on receipt.
+            #
+            # Storing a presigned URL is the specific mistake this shape still avoids:
+            # M260826130000 and M260826140000 exist because RCS assets were stored as signed
+            # URLs and went stale. Nothing here is signed.
             sig do
-              params(media_type: T.nilable(String), url: String).returns(
-                T.attached_class
-              )
+              params(
+                media_type: T.nilable(String),
+                mime_type: T.nilable(String),
+                size_bytes: T.nilable(Integer),
+                source_hash_sha256: T.nilable(String),
+                url: T.nilable(String)
+              ).returns(T.attached_class)
             end
             def self.new(
-              # One of Constants.MmsMediaTypes when known. Advisory — the carrier reads the
-              # fetched object's Content-Type, not this.
+              # One of MmsMediaTypes when the content type is known. Advisory — a reader should
+              # trust the fetched object's own Content-Type.
               media_type: nil,
+              # Content type as the provider declared it. Null when it declared none.
+              mime_type: nil,
+              # Size as the provider declared it. Never measured here — nothing downloads the
+              # file.
+              size_bytes: nil,
+              # Inbound only: the SHA-256 the provider declared alongside the attachment, when
+              # it declared one. Relayed to the customer so they can verify what they fetch
+              # matches what the carrier said it sent. It is the only integrity signal available
+              # on an attachment nobody here has read.
+              source_hash_sha256: nil,
+              # Where the file lives. Outbound: the URL the customer gave us and the carrier
+              # fetched. Inbound: the URL the carrier hosts it at, relayed unchanged.
               url: nil
             )
             end
 
             sig do
-              override.returns({ media_type: T.nilable(String), url: String })
+              override.returns(
+                {
+                  media_type: T.nilable(String),
+                  mime_type: T.nilable(String),
+                  size_bytes: T.nilable(Integer),
+                  source_hash_sha256: T.nilable(String),
+                  url: T.nilable(String)
+                }
+              )
             end
             def to_hash
             end

data/rbi/sentdm/models/template_create_params.rbi

@@ -11,6 +11,15 @@ module Sentdm
           T.any(Sentdm::TemplateCreateParams, Sentdm::Internal::AnyHash)
         end
 
+      # Create this template automatically on every sender profile of the organization,
+      # now and in future (default: false). Accepted only from an organization that has
+      # been enabled for it, and only at creation — it cannot be changed afterwards.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :auto_create_for_sp
+
+      sig { params(auto_create_for_sp: T::Boolean).void }
+      attr_writer :auto_create_for_sp
+
       # Template category: MARKETING, UTILITY, AUTHENTICATION (optional, auto-detected
       # if not provided)
       sig { returns(T.nilable(String)) }
@@ -61,6 +70,7 @@ module Sentdm
 
       sig do
         params(
+          auto_create_for_sp: T::Boolean,
           category: T.nilable(String),
           creation_source: T.nilable(String),
           definition: Sentdm::TemplateDefinition::OrHash,
@@ -73,6 +83,10 @@ module Sentdm
         ).returns(T.attached_class)
       end
       def self.new(
+        # Create this template automatically on every sender profile of the organization,
+        # now and in future (default: false). Accepted only from an organization that has
+        # been enabled for it, and only at creation — it cannot be changed afterwards.
+        auto_create_for_sp: nil,
         # Template category: MARKETING, UTILITY, AUTHENTICATION (optional, auto-detected
         # if not provided)
         category: nil,
@@ -97,6 +111,7 @@ module Sentdm
       sig do
         override.returns(
           {
+            auto_create_for_sp: T::Boolean,
             category: T.nilable(String),
             creation_source: T.nilable(String),
             definition: Sentdm::TemplateDefinition,

data/rbi/sentdm/models/webhook_create_params.rbi

@@ -46,6 +46,19 @@ module Sentdm
       sig { params(sandbox: T::Boolean).void }
       attr_writer :sandbox
 
+      # Request-only: the events an organization webhook's sender profile clones
+      # receive, one clone per existing and future profile. Responses never return it.
+      sig { returns(T.nilable(Sentdm::WebhookCreateParams::SenderProfile)) }
+      attr_reader :sender_profile
+
+      sig do
+        params(
+          sender_profile:
+            T.nilable(Sentdm::WebhookCreateParams::SenderProfile::OrHash)
+        ).void
+      end
+      attr_writer :sender_profile
+
       sig { returns(T.nilable(Integer)) }
       attr_reader :timeout_seconds
 
@@ -72,6 +85,8 @@ module Sentdm
           event_types: T::Array[String],
           retry_count: Integer,
           sandbox: T::Boolean,
+          sender_profile:
+            T.nilable(Sentdm::WebhookCreateParams::SenderProfile::OrHash),
           timeout_seconds: Integer,
           idempotency_key: String,
           x_profile_id: String,
@@ -87,6 +102,9 @@ module Sentdm
         # Sandbox flag - when true, the operation is simulated without side effects Useful
         # for testing integrations without actual execution
         sandbox: nil,
+        # Request-only: the events an organization webhook's sender profile clones
+        # receive, one clone per existing and future profile. Responses never return it.
+        sender_profile: nil,
         timeout_seconds: nil,
         idempotency_key: nil,
         x_profile_id: nil,
@@ -103,6 +121,8 @@ module Sentdm
             event_types: T::Array[String],
             retry_count: Integer,
             sandbox: T::Boolean,
+            sender_profile:
+              T.nilable(Sentdm::WebhookCreateParams::SenderProfile),
             timeout_seconds: Integer,
             idempotency_key: String,
             x_profile_id: String,
@@ -112,6 +132,47 @@ module Sentdm
       end
       def to_hash
       end
+
+      class SenderProfile < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::WebhookCreateParams::SenderProfile,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Hash[Symbol, T::Array[String]])) }
+        attr_accessor :event_filters
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :event_types
+
+        sig { params(event_types: T::Array[String]).void }
+        attr_writer :event_types
+
+        # Request-only: the events an organization webhook's sender profile clones
+        # receive, one clone per existing and future profile. Responses never return it.
+        sig do
+          params(
+            event_filters: T.nilable(T::Hash[Symbol, T::Array[String]]),
+            event_types: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(event_filters: nil, event_types: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              event_filters: T.nilable(T::Hash[Symbol, T::Array[String]]),
+              event_types: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/sentdm/models/webhook_list_events_response.rbi

@@ -73,7 +73,8 @@ module Sentdm
               Sentdm::TemplateEvent::OrHash,
               Sentdm::ChannelEvent::OrHash,
               Sentdm::ContactEvent::OrHash,
-              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::OrHash
             )
         ).void
       end
@@ -111,7 +112,8 @@ module Sentdm
               Sentdm::TemplateEvent::OrHash,
               Sentdm::ChannelEvent::OrHash,
               Sentdm::ContactEvent::OrHash,
-              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload::OrHash
             ),
           event_type: String,
           http_status_code: T.nilable(Integer),
@@ -201,7 +203,8 @@ module Sentdm
               Sentdm::TemplateEvent,
               Sentdm::ChannelEvent,
               Sentdm::ContactEvent,
-              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload
             )
           end
 
@@ -629,6 +632,272 @@ module Sentdm
           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[