sentdm 0.34.0 → 0.36.0

data/lib/sentdm/resources/messages.rb

@@ -19,6 +19,11 @@ module Sentdm
     # the send pipeline. It is a new attempt, not a free retry: every policy runs
     # again, the message is billed again, and its status webhooks fire again. A
     # FILTERED message is never resendable.
+    #
+    # **A scheduled message can be called off.** `POST /v3/messages/{id}/cancel`
+    # cancels a send you scheduled with `scheduled_at`, as long as it has not been
+    # released yet. Cancelling is free, fires `message.cancelled`, and is final — a
+    # cancelled message cannot be resent.
     class Messages
       # Some parameter documentations has been truncated, see
       # {Sentdm::Models::MessageRetrieveActivitiesParams} for more details.
@@ -55,10 +60,11 @@ module Sentdm
       #
       # Retrieves the current status and details of a message by ID. Includes delivery
       # status, timestamps, and error information if applicable. A message that is or
-      # was held for a later time (a send you scheduled with scheduled_at, or a
-      # quiet-hours hold) is returned as a ScheduledMessageResponse: the same fields
-      # plus scheduled_at, the release instant in UTC. A message sent immediately has no
-      # scheduled_at key.
+      # was held for a later time (a send you scheduled with scheduled_at, a quiet-hours
+      # hold, or a message you cancelled while it was held) is returned as a
+      # ScheduledMessageResponse: the same fields plus scheduled_at, the instant it is
+      # held for in UTC — or, on a CANCELLED message, the instant that was called off. A
+      # message sent immediately has no scheduled_at key.
       #
       # @overload retrieve_status(id, x_profile_id: nil, request_options: {})
       #

data/lib/sentdm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentdm
-  VERSION = "0.34.0"
+  VERSION = "0.36.0"
 end

data/lib/sentdm.rb

@@ -52,14 +52,19 @@ require_relative "sentdm/errors"
 require_relative "sentdm/internal/transport/base_client"
 require_relative "sentdm/internal/transport/pooled_net_requester"
 require_relative "sentdm/client"
+require_relative "sentdm/internal/calls_page"
 require_relative "sentdm/internal/contacts_page"
 require_relative "sentdm/internal/conversations_page"
 require_relative "sentdm/internal/templates_page"
 require_relative "sentdm/internal/webhook_events_page"
 require_relative "sentdm/internal/webhooks_page"
 require_relative "sentdm/models/mutation_request"
+require_relative "sentdm/models/channels/voice_number"
 require_relative "sentdm/models/template_body_content"
 require_relative "sentdm/models/api_meta"
+require_relative "sentdm/models/api_response_of_call"
+require_relative "sentdm/models/api_response_of_call_recordings"
+require_relative "sentdm/models/api_response_of_calls_list"
 require_relative "sentdm/models/api_response_of_contact"
 require_relative "sentdm/models/api_response_of_contact_message_summary"
 require_relative "sentdm/models/api_response_of_conversation_messages_list"
@@ -73,8 +78,49 @@ require_relative "sentdm/models/brand_business_info"
 require_relative "sentdm/models/brand_compliance_info"
 require_relative "sentdm/models/brand_contact_info"
 require_relative "sentdm/models/brands_brand_data"
+require_relative "sentdm/models/call"
+require_relative "sentdm/models/call_event"
+require_relative "sentdm/models/call_event_payload"
+require_relative "sentdm/models/call_hangup_params"
+require_relative "sentdm/models/call_list_params"
+require_relative "sentdm/models/call_list_recordings_params"
+require_relative "sentdm/models/call_party"
+require_relative "sentdm/models/call_recording"
+require_relative "sentdm/models/call_recordings"
+require_relative "sentdm/models/call_record_params"
+require_relative "sentdm/models/call_retrieve_params"
+require_relative "sentdm/models/calls/api_response_of_list_of_call_participant"
+require_relative "sentdm/models/calls/call_participant"
+require_relative "sentdm/models/calls/call_participant_target"
+require_relative "sentdm/models/calls/participant_add_params"
+require_relative "sentdm/models/calls/participant_list_params"
+require_relative "sentdm/models/calls/participant_remove_all_params"
+require_relative "sentdm/models/calls/participant_remove_params"
+require_relative "sentdm/models/calls/participant_update_params"
+require_relative "sentdm/models/calls_list"
+require_relative "sentdm/models/call_timeline_entry"
 require_relative "sentdm/models/channel_event"
 require_relative "sentdm/models/channel_event_payload"
+require_relative "sentdm/models/channels/api_response_of_list_of_voice_number"
+require_relative "sentdm/models/channels/api_response_of_voice_callback_test"
+require_relative "sentdm/models/channels/api_response_of_voice_number"
+require_relative "sentdm/models/channels/api_response_of_voice_number_created"
+require_relative "sentdm/models/channels/api_response_of_voice_secret"
+require_relative "sentdm/models/channels/api_response_of_voice_token"
+require_relative "sentdm/models/channels/voice_callback_test"
+require_relative "sentdm/models/channels/voice_callback_test_error_info"
+require_relative "sentdm/models/channels/voice_callback_test_request_info"
+require_relative "sentdm/models/channels/voice_callback_test_response_info"
+require_relative "sentdm/models/channels/voice_create_params"
+require_relative "sentdm/models/channels/voice_create_token_params"
+require_relative "sentdm/models/channels/voice_list_params"
+require_relative "sentdm/models/channels/voice_number_created"
+require_relative "sentdm/models/channels/voice_retrieve_params"
+require_relative "sentdm/models/channels/voice_rotate_secret_params"
+require_relative "sentdm/models/channels/voice_secret"
+require_relative "sentdm/models/channels/voice_test_params"
+require_relative "sentdm/models/channels/voice_token"
+require_relative "sentdm/models/channels/voice_update_params"
 require_relative "sentdm/models/contact_create_params"
 require_relative "sentdm/models/contact_delete_params"
 require_relative "sentdm/models/contact_event"
@@ -168,6 +214,10 @@ require_relative "sentdm/models/webhook_test_response"
 require_relative "sentdm/models/webhook_toggle_status_params"
 require_relative "sentdm/models/webhook_update_params"
 require_relative "sentdm/models"
+require_relative "sentdm/resources/calls"
+require_relative "sentdm/resources/calls/participants"
+require_relative "sentdm/resources/channels"
+require_relative "sentdm/resources/channels/voice"
 require_relative "sentdm/resources/contacts"
 require_relative "sentdm/resources/conversations"
 require_relative "sentdm/resources/me"

data/rbi/sentdm/client.rbi

@@ -84,6 +84,11 @@ module Sentdm
     # the send pipeline. It is a new attempt, not a free retry: every policy runs
     # again, the message is billed again, and its status webhooks fire again. A
     # FILTERED message is never resendable.
+    #
+    # **A scheduled message can be called off.** `POST /v3/messages/{id}/cancel`
+    # cancels a send you scheduled with `scheduled_at`, as long as it has not been
+    # released yet. Cancelling is free, fires `message.cancelled`, and is final — a
+    # cancelled message cannot be resent.
     sig { returns(Sentdm::Resources::Messages) }
     attr_reader :messages
 
@@ -110,6 +115,29 @@ module Sentdm
     sig { returns(Sentdm::Resources::Conversations) }
     attr_reader :conversations
 
+    # Phone calls from the numbers you hold, driven by your own callback URL.
+    #
+    # `POST /v3/channels/voice` enables a number for calls, with the callback URL Sent
+    # asks what to do with each call on it, and `POST /v3/channels/voice/tokens` mints
+    # a short-lived token that lets a user of your app place and receive calls as that
+    # number. When a call arrives or a caller presses a key, a signed question is
+    # POSTed to the callback URL and the answer decides the call;
+    # `POST /v3/channels/voice/{number}/test` checks the URL answers the way we need
+    # before a real call reaches it, and
+    # `POST /v3/channels/voice/{number}/rotate-secret` replaces the signing secret.
+    # The call events themselves (`call.completed` and the rest) arrive through your
+    # webhooks.
+    #
+    # Every call is a record under `/v3/calls`: read it, list its recordings once one
+    # is ready, hang it up, start or stop recording, and add, mute or remove
+    # conference participants while it is live. A leg to a phone number runs for at
+    # most what your balance affords at the destination's rate.
+    sig { returns(Sentdm::Resources::Calls) }
+    attr_reader :calls
+
+    sig { returns(Sentdm::Resources::Channels) }
+    attr_reader :channels
+
     # Who the current key is.
     #
     # `GET /v3/me` answers with the account the key authenticates as, which is the

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,179 @@
+# 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, 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::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, 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,
+        # 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