sentdm 0.34.0 → 0.35.0

data/rbi/sentdm/models/channels/api_response_of_voice_number_created.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class APIResponseOfVoiceNumberCreated < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::APIResponseOfVoiceNumberCreated,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The response data (null if error)
+        sig { returns(T.nilable(Sentdm::Channels::VoiceNumberCreated)) }
+        attr_reader :data
+
+        sig do
+          params(
+            data: T.nilable(Sentdm::Channels::VoiceNumberCreated::OrHash)
+          ).void
+        end
+        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::Channels::VoiceNumberCreated::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(Sentdm::Channels::VoiceNumberCreated),
+              error: T.nilable(Sentdm::ErrorDetail),
+              meta: Sentdm::APIMeta,
+              success: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/api_response_of_voice_secret.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class APIResponseOfVoiceSecret < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::APIResponseOfVoiceSecret,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # A freshly rotated callback signing secret
+        sig { returns(T.nilable(Sentdm::Channels::VoiceSecret)) }
+        attr_reader :data
+
+        sig do
+          params(data: T.nilable(Sentdm::Channels::VoiceSecret::OrHash)).void
+        end
+        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::Channels::VoiceSecret::OrHash),
+            error: T.nilable(Sentdm::ErrorDetail::OrHash),
+            meta: Sentdm::APIMeta::OrHash,
+            success: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A freshly rotated callback signing secret
+          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::Channels::VoiceSecret),
+              error: T.nilable(Sentdm::ErrorDetail),
+              meta: Sentdm::APIMeta,
+              success: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/api_response_of_voice_token.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class APIResponseOfVoiceToken < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::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)) }
+        attr_reader :data
+
+        sig do
+          params(data: T.nilable(Sentdm::Channels::VoiceToken::OrHash)).void
+        end
+        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::Channels::VoiceToken::OrHash),
+            error: T.nilable(Sentdm::ErrorDetail::OrHash),
+            meta: Sentdm::APIMeta::OrHash,
+            success: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A short-lived token your app passes to the voice client SDK to register
+          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::Channels::VoiceToken),
+              error: T.nilable(Sentdm::ErrorDetail),
+              meta: Sentdm::APIMeta,
+              success: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_callback_test.rbi

@@ -0,0 +1,126 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceCallbackTest < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::VoiceCallbackTest,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # Your answer as Sent read it, with numbers in E.164 and a missing caller id
+        # filled in. Set only when the outcome is ok.
+        sig { returns(T.nilable(T.anything)) }
+        attr_accessor :answer
+
+        # The call id the test question carried. It does not exist anywhere else and
+        # cannot be looked up.
+        sig { returns(T.nilable(String)) }
+        attr_reader :call_id
+
+        sig { params(call_id: String).void }
+        attr_writer :call_id
+
+        # Why the test did not end with ok
+        sig { returns(T.nilable(Sentdm::Channels::VoiceCallbackTestErrorInfo)) }
+        attr_reader :error
+
+        sig do
+          params(
+            error:
+              T.nilable(Sentdm::Channels::VoiceCallbackTestErrorInfo::OrHash)
+          ).void
+        end
+        attr_writer :error
+
+        # What happened: ok, timeout, connection_failed, http_error or invalid_answer
+        sig { returns(T.nilable(String)) }
+        attr_reader :outcome
+
+        sig { params(outcome: String).void }
+        attr_writer :outcome
+
+        # The test question exactly as it was sent
+        sig do
+          returns(T.nilable(Sentdm::Channels::VoiceCallbackTestRequestInfo))
+        end
+        attr_reader :request
+
+        sig do
+          params(
+            request:
+              T.nilable(Sentdm::Channels::VoiceCallbackTestRequestInfo::OrHash)
+          ).void
+        end
+        attr_writer :request
+
+        # What your endpoint answered
+        sig do
+          returns(T.nilable(Sentdm::Channels::VoiceCallbackTestResponseInfo))
+        end
+        attr_reader :response
+
+        sig do
+          params(
+            response:
+              T.nilable(Sentdm::Channels::VoiceCallbackTestResponseInfo::OrHash)
+          ).void
+        end
+        attr_writer :response
+
+        # The verdict of a test question sent to your callback URL
+        sig do
+          params(
+            answer: T.nilable(T.anything),
+            call_id: String,
+            error:
+              T.nilable(Sentdm::Channels::VoiceCallbackTestErrorInfo::OrHash),
+            outcome: String,
+            request:
+              T.nilable(Sentdm::Channels::VoiceCallbackTestRequestInfo::OrHash),
+            response:
+              T.nilable(Sentdm::Channels::VoiceCallbackTestResponseInfo::OrHash)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Your answer as Sent read it, with numbers in E.164 and a missing caller id
+          # filled in. Set only when the outcome is ok.
+          answer: nil,
+          # The call id the test question carried. It does not exist anywhere else and
+          # cannot be looked up.
+          call_id: nil,
+          # Why the test did not end with ok
+          error: nil,
+          # What happened: ok, timeout, connection_failed, http_error or invalid_answer
+          outcome: nil,
+          # The test question exactly as it was sent
+          request: nil,
+          # What your endpoint answered
+          response: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              answer: T.nilable(T.anything),
+              call_id: String,
+              error: T.nilable(Sentdm::Channels::VoiceCallbackTestErrorInfo),
+              outcome: String,
+              request:
+                T.nilable(Sentdm::Channels::VoiceCallbackTestRequestInfo),
+              response:
+                T.nilable(Sentdm::Channels::VoiceCallbackTestResponseInfo)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_callback_test_error_info.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceCallbackTestErrorInfo < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::VoiceCallbackTestErrorInfo,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # What to fix
+        sig { returns(T.nilable(String)) }
+        attr_reader :message
+
+        sig { params(message: String).void }
+        attr_writer :message
+
+        # Dotted path of the answer field at fault, such as action.action, when one field
+        # is to blame
+        sig { returns(T.nilable(String)) }
+        attr_accessor :path
+
+        # Machine-readable reason, such as timeout, http_error, malformed_json,
+        # missing_action or unknown_action
+        sig { returns(T.nilable(String)) }
+        attr_reader :reason
+
+        sig { params(reason: String).void }
+        attr_writer :reason
+
+        # Why the test did not end with ok
+        sig do
+          params(
+            message: String,
+            path: T.nilable(String),
+            reason: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # What to fix
+          message: nil,
+          # Dotted path of the answer field at fault, such as action.action, when one field
+          # is to blame
+          path: nil,
+          # Machine-readable reason, such as timeout, http_error, malformed_json,
+          # missing_action or unknown_action
+          reason: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { message: String, path: T.nilable(String), reason: String }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_callback_test_request_info.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceCallbackTestRequestInfo < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::VoiceCallbackTestRequestInfo,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The request body byte for byte. This is what the signature covers.
+        sig { returns(T.nilable(String)) }
+        attr_reader :body
+
+        sig { params(body: String).void }
+        attr_writer :body
+
+        # Every header Sent added, the signature included, so you can compare against what
+        # your endpoint verified. The signing secret itself is never included.
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :headers
+
+        sig { params(headers: T::Hash[Symbol, String]).void }
+        attr_writer :headers
+
+        # The callback URL that was called
+        sig { returns(T.nilable(String)) }
+        attr_reader :url
+
+        sig { params(url: String).void }
+        attr_writer :url
+
+        # The test question exactly as it was sent
+        sig do
+          params(
+            body: String,
+            headers: T::Hash[Symbol, String],
+            url: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The request body byte for byte. This is what the signature covers.
+          body: nil,
+          # Every header Sent added, the signature included, so you can compare against what
+          # your endpoint verified. The signing secret itself is never included.
+          headers: nil,
+          # The callback URL that was called
+          url: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            { body: String, headers: T::Hash[Symbol, String], url: String }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_callback_test_response_info.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceCallbackTestResponseInfo < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::VoiceCallbackTestResponseInfo,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The start of the raw response body, capped at 2048 characters
+        sig { returns(T.nilable(String)) }
+        attr_accessor :body
+
+        # The HTTP status your endpoint returned
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :status_code
+
+        sig { params(status_code: Integer).void }
+        attr_writer :status_code
+
+        # What your endpoint answered
+        sig do
+          params(body: T.nilable(String), status_code: Integer).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The start of the raw response body, capped at 2048 characters
+          body: nil,
+          # The HTTP status your endpoint returned
+          status_code: nil
+        )
+        end
+
+        sig do
+          override.returns({ body: T.nilable(String), status_code: Integer })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_create_params.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceCreateParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::VoiceCreateParams,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # Where Sent asks what to do with each call on this number: an absolute HTTP or
+        # HTTPS URL on a public host. A signed question is POSTed here when a call arrives
+        # or a caller presses a key, and the answer decides the call. Every question is
+        # signed with the callback_secret the response returns, the same way your webhooks
+        # are signed. Turning the number on again with a different URL replaces it and
+        # keeps the secret.
+        sig { returns(String) }
+        attr_accessor :callback_url
+
+        # The US area code a new number should be in, as 212. Only for a request that
+        # leaves number out — sending both says two different things about which number to
+        # use, and is refused. Omit it too and the number comes from anywhere in the
+        # country.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :area_code
+
+        # Make this the line app-originated calls are placed from when a voice token names
+        # no number. Omit it and your first voice number takes that role; a later one
+        # leaves it where it is.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :default_for_app_calls
+
+        # One of your phone numbers, in E.164 format. Leave the field out entirely to be
+        # given a new one instead; sending it empty is a refused request rather than a
+        # request for a new number.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :number
+
+        # 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(
+            callback_url: String,
+            area_code: T.nilable(String),
+            default_for_app_calls: T.nilable(T::Boolean),
+            number: T.nilable(String),
+            sandbox: T::Boolean,
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Where Sent asks what to do with each call on this number: an absolute HTTP or
+          # HTTPS URL on a public host. A signed question is POSTed here when a call arrives
+          # or a caller presses a key, and the answer decides the call. Every question is
+          # signed with the callback_secret the response returns, the same way your webhooks
+          # are signed. Turning the number on again with a different URL replaces it and
+          # keeps the secret.
+          callback_url:,
+          # The US area code a new number should be in, as 212. Only for a request that
+          # leaves number out — sending both says two different things about which number to
+          # use, and is refused. Omit it too and the number comes from anywhere in the
+          # country.
+          area_code: nil,
+          # Make this the line app-originated calls are placed from when a voice token names
+          # no number. Omit it and your first voice number takes that role; a later one
+          # leaves it where it is.
+          default_for_app_calls: nil,
+          # One of your phone numbers, in E.164 format. Leave the field out entirely to be
+          # given a new one instead; sending it empty is a refused request rather than a
+          # request for a new number.
+          number: 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(
+            {
+              callback_url: String,
+              area_code: T.nilable(String),
+              default_for_app_calls: T.nilable(T::Boolean),
+              number: T.nilable(String),
+              sandbox: T::Boolean,
+              idempotency_key: String,
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end