sentdm 0.34.0 → 0.36.0

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

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