sentdm 0.34.0 → 0.35.0

data/rbi/sentdm/models/api_response_of_call.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfCall < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfCall, Sentdm::Internal::AnyHash)
+        end
+
+      # A call record
+      sig { returns(T.nilable(Sentdm::Call)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::Call::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::Call::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A call record
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::Call),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_call_recordings.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfCallRecordings < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfCallRecordings, Sentdm::Internal::AnyHash)
+        end
+
+      # The recordings of a call, each as a short-lived download link
+      sig { returns(T.nilable(Sentdm::CallRecordings)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::CallRecordings::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::CallRecordings::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The recordings of a call, each as a short-lived download link
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::CallRecordings),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_calls_list.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfCallsList < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfCallsList, Sentdm::Internal::AnyHash)
+        end
+
+      # Paginated list of calls
+      sig { returns(T.nilable(Sentdm::CallsList)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::CallsList::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::CallsList::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Paginated list of calls
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::CallsList),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call.rbi

@@ -0,0 +1,177 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class Call < Sentdm::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Sentdm::Call, Sentdm::Internal::AnyHash) }
+
+      # The call id, the same one carried by the call.request question and every call
+      # webhook
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # When the call was answered (UTC). Null until then, and always null for a call
+      # between two of your app users
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :answered_at
+
+      # outbound for a call placed from your app, inbound for a call to one of your
+      # numbers
+      sig { returns(T.nilable(String)) }
+      attr_reader :direction
+
+      sig { params(direction: String).void }
+      attr_writer :direction
+
+      # Billable duration in seconds. Null while the call is live
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :duration_seconds
+
+      # When the call ended (UTC). Null while the call is live
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :ended_at
+
+      # Why the call did not complete: callback_timeout, invalid_answer,
+      # insufficient_balance, destination_blocked, rejected or no_answer. Null while the
+      # call is live, when it completed, and when it failed without a recorded reason
+      sig { returns(T.nilable(String)) }
+      attr_accessor :failure_reason
+
+      # One end of a call
+      sig { returns(T.nilable(Sentdm::CallParty)) }
+      attr_reader :from
+
+      sig { params(from: Sentdm::CallParty::OrHash).void }
+      attr_writer :from
+
+      # Your number that owns the call, in E.164 format: the dialed number for an
+      # inbound call, the caller's bound number for a call placed from your app
+      sig { returns(T.nilable(String)) }
+      attr_reader :number
+
+      sig { params(number: String).void }
+      attr_writer :number
+
+      # What the call cost. Null until it has been priced
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :price
+
+      # True once a recording of the call is available
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :recording_available
+
+      sig { params(recording_available: T::Boolean).void }
+      attr_writer :recording_available
+
+      # When the call was placed (UTC)
+      sig { returns(T.nilable(Time)) }
+      attr_reader :started_at
+
+      sig { params(started_at: Time).void }
+      attr_writer :started_at
+
+      # initiated, ringing, answered, completed, failed, no_answer or rejected
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      # When the call entered each status, oldest first. Only returned when reading one
+      # call
+      sig { returns(T.nilable(T::Array[Sentdm::CallTimelineEntry])) }
+      attr_accessor :timeline
+
+      # One end of a call
+      sig { returns(T.nilable(Sentdm::CallParty)) }
+      attr_reader :to
+
+      sig { params(to: Sentdm::CallParty::OrHash).void }
+      attr_writer :to
+
+      # A call record
+      sig do
+        params(
+          id: String,
+          answered_at: T.nilable(Time),
+          direction: String,
+          duration_seconds: T.nilable(Integer),
+          ended_at: T.nilable(Time),
+          failure_reason: T.nilable(String),
+          from: Sentdm::CallParty::OrHash,
+          number: String,
+          price: T.nilable(Float),
+          recording_available: T::Boolean,
+          started_at: Time,
+          status: String,
+          timeline: T.nilable(T::Array[Sentdm::CallTimelineEntry::OrHash]),
+          to: Sentdm::CallParty::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The call id, the same one carried by the call.request question and every call
+        # webhook
+        id: nil,
+        # When the call was answered (UTC). Null until then, and always null for a call
+        # between two of your app users
+        answered_at: nil,
+        # outbound for a call placed from your app, inbound for a call to one of your
+        # numbers
+        direction: nil,
+        # Billable duration in seconds. Null while the call is live
+        duration_seconds: nil,
+        # When the call ended (UTC). Null while the call is live
+        ended_at: nil,
+        # Why the call did not complete: callback_timeout, invalid_answer,
+        # insufficient_balance, destination_blocked, rejected or no_answer. Null while the
+        # call is live, when it completed, and when it failed without a recorded reason
+        failure_reason: nil,
+        # One end of a call
+        from: nil,
+        # Your number that owns the call, in E.164 format: the dialed number for an
+        # inbound call, the caller's bound number for a call placed from your app
+        number: nil,
+        # What the call cost. Null until it has been priced
+        price: nil,
+        # True once a recording of the call is available
+        recording_available: nil,
+        # When the call was placed (UTC)
+        started_at: nil,
+        # initiated, ringing, answered, completed, failed, no_answer or rejected
+        status: nil,
+        # When the call entered each status, oldest first. Only returned when reading one
+        # call
+        timeline: nil,
+        # One end of a call
+        to: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            answered_at: T.nilable(Time),
+            direction: String,
+            duration_seconds: T.nilable(Integer),
+            ended_at: T.nilable(Time),
+            failure_reason: T.nilable(String),
+            from: Sentdm::CallParty,
+            number: String,
+            price: T.nilable(Float),
+            recording_available: T::Boolean,
+            started_at: Time,
+            status: String,
+            timeline: T.nilable(T::Array[Sentdm::CallTimelineEntry]),
+            to: Sentdm::CallParty
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call_event.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallEvent < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::CallEvent, Sentdm::Internal::AnyHash) }
+
+      # 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 { returns(T.nilable(Sentdm::CallEventPayload)) }
+      attr_reader :payload
+
+      sig { params(payload: T.nilable(Sentdm::CallEventPayload::OrHash)).void }
+      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::CallEventPayload::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::CallEventPayload),
+            request_id: T.nilable(String),
+            timestamp: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call_event_payload.rbi

@@ -0,0 +1,135 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallEventPayload < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::CallEventPayload, 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
+end

data/rbi/sentdm/models/call_hangup_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallHangupParams < Sentdm::Models::MutationRequest
+      extend Sentdm::Internal::Type::RequestParameters::Converter
+      include Sentdm::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::CallHangupParams, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :x_profile_id
+
+      sig { params(x_profile_id: String).void }
+      attr_writer :x_profile_id
+
+      sig do
+        params(
+          id: String,
+          idempotency_key: String,
+          x_profile_id: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        idempotency_key: nil,
+        x_profile_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end