sentdm 0.33.0 → 0.35.0

data/rbi/sentdm/internal/calls_page.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Sentdm
+  module Internal
+    class CallsPage
+      include Sentdm::Internal::Type::BasePage
+
+      Elem = type_member
+
+      sig { returns(Data) }
+      attr_accessor :data
+
+      # @api private
+      sig { returns(String) }
+      def inspect
+      end
+
+      class Data < Sentdm::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(Data, Sentdm::Internal::AnyHash) }
+
+        sig { returns(T.nilable(T::Array[T.anything])) }
+        attr_reader :calls
+
+        sig { params(calls: T::Array[T.anything]).void }
+        attr_writer :calls
+
+        sig { returns(T.nilable(Data::Pagination)) }
+        attr_reader :pagination
+
+        sig { params(pagination: Data::Pagination::OrHash).void }
+        attr_writer :pagination
+
+        sig do
+          params(
+            calls: T::Array[T.anything],
+            pagination: Data::Pagination::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(calls: nil, pagination: nil)
+        end
+
+        sig do
+          override.returns(
+            { calls: T::Array[T.anything], pagination: Data::Pagination }
+          )
+        end
+        def to_hash
+        end
+
+        class Pagination < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias { T.any(Data::Pagination, Sentdm::Internal::AnyHash) }
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :has_more
+
+          sig { params(has_more: T::Boolean).void }
+          attr_writer :has_more
+
+          sig { params(has_more: T::Boolean).returns(T.attached_class) }
+          def self.new(has_more: nil)
+          end
+
+          sig { override.returns({ has_more: T::Boolean }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

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