sentdm 0.38.0 → 0.39.0

data/rbi/sentdm/models/{calls/api_response_of_list_of_call_participant.rbi → voice/api_response_of_calls_list.rbi}

@@ -2,19 +2,22 @@
 
 module Sentdm
   module Models
-    module Calls
-      class APIResponseOfListOfCallParticipant < Sentdm::Internal::Type::BaseModel
+    module Voice
+      class APIResponseOfCallsList < Sentdm::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
             T.any(
-              Sentdm::Calls::APIResponseOfListOfCallParticipant,
+              Sentdm::Voice::APIResponseOfCallsList,
               Sentdm::Internal::AnyHash
             )
           end
 
-        # The response data (null if error)
-        sig { returns(T.nilable(T::Array[Sentdm::Calls::CallParticipant])) }
-        attr_accessor :data
+        # Paginated list of calls
+        sig { returns(T.nilable(Sentdm::Voice::CallsList)) }
+        attr_reader :data
+
+        sig { params(data: T.nilable(Sentdm::Voice::CallsList::OrHash)).void }
+        attr_writer :data
 
         # Error information
         sig { returns(T.nilable(Sentdm::ErrorDetail)) }
@@ -40,14 +43,14 @@ module Sentdm
         # Standard API response envelope for all v3 endpoints
         sig do
           params(
-            data: T.nilable(T::Array[Sentdm::Calls::CallParticipant::OrHash]),
+            data: T.nilable(Sentdm::Voice::CallsList::OrHash),
             error: T.nilable(Sentdm::ErrorDetail::OrHash),
             meta: Sentdm::APIMeta::OrHash,
             success: T::Boolean
           ).returns(T.attached_class)
         end
         def self.new(
-          # The response data (null if error)
+          # Paginated list of calls
           data: nil,
           # Error information
           error: nil,
@@ -61,7 +64,7 @@ module Sentdm
         sig do
           override.returns(
             {
-              data: T.nilable(T::Array[Sentdm::Calls::CallParticipant]),
+              data: T.nilable(Sentdm::Voice::CallsList),
               error: T.nilable(Sentdm::ErrorDetail),
               meta: Sentdm::APIMeta,
               success: T::Boolean

data/rbi/sentdm/models/{channels → voice}/api_response_of_voice_token.rbi

@@ -2,23 +2,21 @@
 
 module Sentdm
   module Models
-    module Channels
+    module Voice
       class APIResponseOfVoiceToken < Sentdm::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
             T.any(
-              Sentdm::Channels::APIResponseOfVoiceToken,
+              Sentdm::Voice::APIResponseOfVoiceToken,
               Sentdm::Internal::AnyHash
             )
           end
 
         # A short-lived token your app passes to the voice client SDK to register
-        sig { returns(T.nilable(Sentdm::Channels::VoiceToken)) }
+        sig { returns(T.nilable(Sentdm::Voice::VoiceToken)) }
         attr_reader :data
 
-        sig do
-          params(data: T.nilable(Sentdm::Channels::VoiceToken::OrHash)).void
-        end
+        sig { params(data: T.nilable(Sentdm::Voice::VoiceToken::OrHash)).void }
         attr_writer :data
 
         # Error information
@@ -45,7 +43,7 @@ module Sentdm
         # Standard API response envelope for all v3 endpoints
         sig do
           params(
-            data: T.nilable(Sentdm::Channels::VoiceToken::OrHash),
+            data: T.nilable(Sentdm::Voice::VoiceToken::OrHash),
             error: T.nilable(Sentdm::ErrorDetail::OrHash),
             meta: Sentdm::APIMeta::OrHash,
             success: T::Boolean
@@ -66,7 +64,7 @@ module Sentdm
         sig do
           override.returns(
             {
-              data: T.nilable(Sentdm::Channels::VoiceToken),
+              data: T.nilable(Sentdm::Voice::VoiceToken),
               error: T.nilable(Sentdm::ErrorDetail),
               meta: Sentdm::APIMeta,
               success: T::Boolean

data/rbi/sentdm/models/voice/call.rbi

@@ -0,0 +1,196 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Voice
+      class Call < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias { T.any(Sentdm::Voice::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, callback_not_configured, 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::Voice::CallParty)) }
+        attr_reader :from
+
+        sig { params(from: Sentdm::Voice::CallParty::OrHash).void }
+        attr_writer :from
+
+        # The calling mode: inapp for a call between people in your app and phone numbers,
+        # routed by your number's callback URL
+        sig { returns(T.nilable(String)) }
+        attr_reader :mode
+
+        sig { params(mode: String).void }
+        attr_writer :mode
+
+        # 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::Voice::CallTimelineEntry])) }
+        attr_accessor :timeline
+
+        # One end of a call
+        sig { returns(T.nilable(Sentdm::Voice::CallParty)) }
+        attr_reader :to
+
+        sig { params(to: Sentdm::Voice::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::Voice::CallParty::OrHash,
+            mode: String,
+            number: String,
+            price: T.nilable(Float),
+            recording_available: T::Boolean,
+            started_at: Time,
+            status: String,
+            timeline:
+              T.nilable(T::Array[Sentdm::Voice::CallTimelineEntry::OrHash]),
+            to: Sentdm::Voice::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, callback_not_configured, 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,
+          # The calling mode: inapp for a call between people in your app and phone numbers,
+          # routed by your number's callback URL
+          mode: 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::Voice::CallParty,
+              mode: String,
+              number: String,
+              price: T.nilable(Float),
+              recording_available: T::Boolean,
+              started_at: Time,
+              status: String,
+              timeline: T.nilable(T::Array[Sentdm::Voice::CallTimelineEntry]),
+              to: Sentdm::Voice::CallParty
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/{calls/participant_remove_params.rbi → voice/call_hangup_params.rbi}

@@ -2,24 +2,24 @@
 
 module Sentdm
   module Models
-    module Calls
-      class ParticipantRemoveParams < Sentdm::Models::MutationRequest
+    module Voice
+      class CallHangupParams < Sentdm::Models::MutationRequest
         extend Sentdm::Internal::Type::RequestParameters::Converter
         include Sentdm::Internal::Type::RequestParameters
 
         OrHash =
           T.type_alias do
-            T.any(
-              Sentdm::Calls::ParticipantRemoveParams,
-              Sentdm::Internal::AnyHash
-            )
+            T.any(Sentdm::Voice::CallHangupParams, Sentdm::Internal::AnyHash)
           end
 
         sig { returns(String) }
         attr_accessor :id
 
-        sig { returns(String) }
-        attr_accessor :participant_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
@@ -30,14 +30,14 @@ module Sentdm
         sig do
           params(
             id: String,
-            participant_id: String,
+            idempotency_key: String,
             x_profile_id: String,
             request_options: Sentdm::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
         def self.new(
           id:,
-          participant_id:,
+          idempotency_key: nil,
           x_profile_id: nil,
           request_options: {}
         )
@@ -47,7 +47,7 @@ module Sentdm
           override.returns(
             {
               id: String,
-              participant_id: String,
+              idempotency_key: String,
               x_profile_id: String,
               request_options: Sentdm::RequestOptions
             }

data/rbi/sentdm/models/voice/call_list_params.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Voice
+      class CallListParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Voice::CallListParams, Sentdm::Internal::AnyHash)
+          end
+
+        # Optional direction filter: outbound for calls placed from your app, inbound for
+        # calls to one of your numbers
+        sig { returns(T.nilable(String)) }
+        attr_accessor :direction
+
+        # Only calls started at or after this time (ISO 8601)
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :from
+
+        # Optional filter on the number that owns the call, one of your voice-enabled
+        # numbers in E.164 format
+        sig { returns(T.nilable(String)) }
+        attr_accessor :number
+
+        # Page number (1-indexed)
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page
+
+        sig { params(page: Integer).void }
+        attr_writer :page
+
+        # Number of items per page
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        # Optional status filter: initiated, ringing, answered, completed, failed,
+        # no_answer or rejected
+        sig { returns(T.nilable(String)) }
+        attr_accessor :status
+
+        # Only calls started at or before this time (ISO 8601)
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :to
+
+        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(
+            direction: T.nilable(String),
+            from: T.nilable(Time),
+            number: T.nilable(String),
+            page: Integer,
+            page_size: Integer,
+            status: T.nilable(String),
+            to: T.nilable(Time),
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Optional direction filter: outbound for calls placed from your app, inbound for
+          # calls to one of your numbers
+          direction: nil,
+          # Only calls started at or after this time (ISO 8601)
+          from: nil,
+          # Optional filter on the number that owns the call, one of your voice-enabled
+          # numbers in E.164 format
+          number: nil,
+          # Page number (1-indexed)
+          page: nil,
+          # Number of items per page
+          page_size: nil,
+          # Optional status filter: initiated, ringing, answered, completed, failed,
+          # no_answer or rejected
+          status: nil,
+          # Only calls started at or before this time (ISO 8601)
+          to: nil,
+          x_profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              direction: T.nilable(String),
+              from: T.nilable(Time),
+              number: T.nilable(String),
+              page: Integer,
+              page_size: Integer,
+              status: T.nilable(String),
+              to: T.nilable(Time),
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/{calls/participant_list_params.rbi → voice/call_list_recordings_params.rbi}

@@ -2,15 +2,15 @@
 
 module Sentdm
   module Models
-    module Calls
-      class ParticipantListParams < Sentdm::Internal::Type::BaseModel
+    module Voice
+      class CallListRecordingsParams < Sentdm::Internal::Type::BaseModel
         extend Sentdm::Internal::Type::RequestParameters::Converter
         include Sentdm::Internal::Type::RequestParameters
 
         OrHash =
           T.type_alias do
             T.any(
-              Sentdm::Calls::ParticipantListParams,
+              Sentdm::Voice::CallListRecordingsParams,
               Sentdm::Internal::AnyHash
             )
           end

data/rbi/sentdm/models/voice/call_party.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Voice
+      class CallParty < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Voice::CallParty, Sentdm::Internal::AnyHash)
+          end
+
+        # user for one of your app users, number for a phone number, conference for a
+        # room, anonymous for a caller who withheld their number
+        sig { returns(T.nilable(String)) }
+        attr_reader :kind
+
+        sig { params(kind: String).void }
+        attr_writer :kind
+
+        # The app user's identity, the phone number in E.164 format, or the room name.
+        # Null when the kind is anonymous
+        sig { returns(T.nilable(String)) }
+        attr_accessor :value
+
+        # One end of a call
+        sig do
+          params(kind: String, value: T.nilable(String)).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # user for one of your app users, number for a phone number, conference for a
+          # room, anonymous for a caller who withheld their number
+          kind: nil,
+          # The app user's identity, the phone number in E.164 format, or the room name.
+          # Null when the kind is anonymous
+          value: nil
+        )
+        end
+
+        sig { override.returns({ kind: String, value: T.nilable(String) }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/{calls/participant_update_params.rbi → voice/call_record_params.rbi}

@@ -2,31 +2,25 @@
 
 module Sentdm
   module Models
-    module Calls
-      class ParticipantUpdateParams < Sentdm::Internal::Type::BaseModel
+    module Voice
+      class CallRecordParams < Sentdm::Internal::Type::BaseModel
         extend Sentdm::Internal::Type::RequestParameters::Converter
         include Sentdm::Internal::Type::RequestParameters
 
         OrHash =
           T.type_alias do
-            T.any(
-              Sentdm::Calls::ParticipantUpdateParams,
-              Sentdm::Internal::AnyHash
-            )
+            T.any(Sentdm::Voice::CallRecordParams, Sentdm::Internal::AnyHash)
           end
 
         sig { returns(String) }
         attr_accessor :id
 
-        sig { returns(String) }
-        attr_accessor :participant_id
-
-        # true to mute the participant, false to unmute them
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :muted
+        # start to begin recording, stop to end it
+        sig { returns(T.nilable(String)) }
+        attr_reader :action
 
-        sig { params(muted: T::Boolean).void }
-        attr_writer :muted
+        sig { params(action: String).void }
+        attr_writer :action
 
         # Sandbox flag - when true, the operation is simulated without side effects Useful
         # for testing integrations without actual execution
@@ -51,8 +45,7 @@ module Sentdm
         sig do
           params(
             id: String,
-            participant_id: String,
-            muted: T::Boolean,
+            action: String,
             sandbox: T::Boolean,
             idempotency_key: String,
             x_profile_id: String,
@@ -61,9 +54,8 @@ module Sentdm
         end
         def self.new(
           id:,
-          participant_id:,
-          # true to mute the participant, false to unmute them
-          muted: nil,
+          # start to begin recording, stop to end it
+          action: nil,
           # Sandbox flag - when true, the operation is simulated without side effects Useful
           # for testing integrations without actual execution
           sandbox: nil,
@@ -77,8 +69,7 @@ module Sentdm
           override.returns(
             {
               id: String,
-              participant_id: String,
-              muted: T::Boolean,
+              action: String,
               sandbox: T::Boolean,
               idempotency_key: String,
               x_profile_id: String,

data/rbi/sentdm/models/voice/call_recording.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Voice
+      class CallRecording < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Voice::CallRecording, Sentdm::Internal::AnyHash)
+          end
+
+        # A pre-signed link that downloads the recording as an MP3 file. Anyone holding it
+        # can download the recording until it expires
+        sig { returns(T.nilable(String)) }
+        attr_reader :download_url
+
+        sig { params(download_url: String).void }
+        attr_writer :download_url
+
+        # The recording's id, the one the call.recording_ready webhook announced it under
+        sig { returns(T.nilable(String)) }
+        attr_reader :recording_id
+
+        sig { params(recording_id: String).void }
+        attr_writer :recording_id
+
+        # When the link stops working (UTC). Request the recordings again for a fresh link
+        sig { returns(T.nilable(Time)) }
+        attr_reader :url_expires_at
+
+        sig { params(url_expires_at: Time).void }
+        attr_writer :url_expires_at
+
+        # A short-lived link to a call recording
+        sig do
+          params(
+            download_url: String,
+            recording_id: String,
+            url_expires_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A pre-signed link that downloads the recording as an MP3 file. Anyone holding it
+          # can download the recording until it expires
+          download_url: nil,
+          # The recording's id, the one the call.recording_ready webhook announced it under
+          recording_id: nil,
+          # When the link stops working (UTC). Request the recordings again for a fresh link
+          url_expires_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { download_url: String, recording_id: String, url_expires_at: Time }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end