sentdm 0.34.0 → 0.35.0

data/rbi/sentdm/models/call_list_params.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    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::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

data/rbi/sentdm/models/call_list_recordings_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    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::CallListRecordingsParams, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      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,
+          x_profile_id: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(id:, x_profile_id: nil, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call_party.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallParty < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::CallParty, Sentdm::Internal::AnyHash) }
+
+      # 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

data/rbi/sentdm/models/call_record_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    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::CallRecordParams, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # start to begin recording, stop to end it
+      sig { returns(T.nilable(String)) }
+      attr_reader :action
+
+      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
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :sandbox
+
+      sig { params(sandbox: T::Boolean).void }
+      attr_writer :sandbox
+
+      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,
+          action: String,
+          sandbox: T::Boolean,
+          idempotency_key: String,
+          x_profile_id: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # 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,
+        idempotency_key: nil,
+        x_profile_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            action: String,
+            sandbox: T::Boolean,
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call_recording.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallRecording < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::CallRecording, Sentdm::Internal::AnyHash) }
+
+      # 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

data/rbi/sentdm/models/call_recordings.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallRecordings < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::CallRecordings, Sentdm::Internal::AnyHash)
+        end
+
+      # Every recording of the call, oldest first. Empty until the first
+      # call.recording_ready webhook has been sent, and for a call that was never
+      # recorded
+      sig { returns(T.nilable(T::Array[Sentdm::CallRecording])) }
+      attr_reader :recordings
+
+      sig { params(recordings: T::Array[Sentdm::CallRecording::OrHash]).void }
+      attr_writer :recordings
+
+      # The recordings of a call, each as a short-lived download link
+      sig do
+        params(recordings: T::Array[Sentdm::CallRecording::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Every recording of the call, oldest first. Empty until the first
+        # call.recording_ready webhook has been sent, and for a call that was never
+        # recorded
+        recordings: nil
+      )
+      end
+
+      sig { override.returns({ recordings: T::Array[Sentdm::CallRecording] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call_retrieve_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallRetrieveParams < Sentdm::Internal::Type::BaseModel
+      extend Sentdm::Internal::Type::RequestParameters::Converter
+      include Sentdm::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::CallRetrieveParams, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      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,
+          x_profile_id: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(id:, x_profile_id: nil, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/call_timeline_entry.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class CallTimelineEntry < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::CallTimelineEntry, Sentdm::Internal::AnyHash)
+        end
+
+      # 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 this status (UTC)
+      sig { returns(T.nilable(Time)) }
+      attr_reader :timestamp
+
+      sig { params(timestamp: Time).void }
+      attr_writer :timestamp
+
+      # When a call entered a status
+      sig { params(status: String, timestamp: Time).returns(T.attached_class) }
+      def self.new(
+        # initiated, ringing, answered, completed, failed, no_answer or rejected
+        status: nil,
+        # When the call entered this status (UTC)
+        timestamp: nil
+      )
+      end
+
+      sig { override.returns({ status: String, timestamp: Time }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/calls/api_response_of_list_of_call_participant.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Calls
+      class APIResponseOfListOfCallParticipant < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Calls::APIResponseOfListOfCallParticipant,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The response data (null if error)
+        sig { returns(T.nilable(T::Array[Sentdm::Calls::CallParticipant])) }
+        attr_accessor :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(T::Array[Sentdm::Calls::CallParticipant::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)
+          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(T::Array[Sentdm::Calls::CallParticipant]),
+              error: T.nilable(Sentdm::ErrorDetail),
+              meta: Sentdm::APIMeta,
+              success: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/calls/call_participant.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    CallParticipant = Calls::CallParticipant
+
+    module Calls
+      class CallParticipant < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Calls::CallParticipant, Sentdm::Internal::AnyHash)
+          end
+
+        # The participant's own call id: what the mute and remove endpoints take, and what
+        # GET /v3/calls/{id} accepts
+        sig { returns(T.nilable(String)) }
+        attr_reader :id
+
+        sig { params(id: String).void }
+        attr_writer :id
+
+        # How long the participant has been connected to the room, in seconds
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :duration_seconds
+
+        sig { params(duration_seconds: Integer).void }
+        attr_writer :duration_seconds
+
+        # user for one of your app users, number for a phone number, anonymous for a
+        # caller who withheld their number
+        sig { returns(T.nilable(String)) }
+        attr_reader :kind
+
+        sig { params(kind: String).void }
+        attr_writer :kind
+
+        # True while the room mutes this participant
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :muted
+
+        sig { params(muted: T::Boolean).void }
+        attr_writer :muted
+
+        # The app user's identity or the phone number in E.164 format. Null when the kind
+        # is anonymous
+        sig { returns(T.nilable(String)) }
+        attr_accessor :value
+
+        # A participant of a conference call
+        sig do
+          params(
+            id: String,
+            duration_seconds: Integer,
+            kind: String,
+            muted: T::Boolean,
+            value: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The participant's own call id: what the mute and remove endpoints take, and what
+          # GET /v3/calls/{id} accepts
+          id: nil,
+          # How long the participant has been connected to the room, in seconds
+          duration_seconds: nil,
+          # user for one of your app users, number for a phone number, anonymous for a
+          # caller who withheld their number
+          kind: nil,
+          # True while the room mutes this participant
+          muted: nil,
+          # The app user's identity or the phone number in E.164 format. Null when the kind
+          # is anonymous
+          value: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              duration_seconds: Integer,
+              kind: String,
+              muted: T::Boolean,
+              value: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/calls/call_participant_target.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    CallParticipantTarget = Calls::CallParticipantTarget
+
+    module Calls
+      class CallParticipantTarget < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Calls::CallParticipantTarget,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # user for one of your app users, number for a phone number
+        sig { returns(T.nilable(String)) }
+        attr_reader :kind
+
+        sig { params(kind: String).void }
+        attr_writer :kind
+
+        # The app user's identity, or the phone number in E.164 format
+        sig { returns(T.nilable(String)) }
+        attr_reader :value
+
+        sig { params(value: String).void }
+        attr_writer :value
+
+        # A participant to add to a call
+        sig { params(kind: String, value: String).returns(T.attached_class) }
+        def self.new(
+          # user for one of your app users, number for a phone number
+          kind: nil,
+          # The app user's identity, or the phone number in E.164 format
+          value: nil
+        )
+        end
+
+        sig { override.returns({ kind: String, value: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end