telnyx 5.151.0 → 5.153.0

data/rbi/telnyx/models/uac_inbound_request.rbi

@@ -128,6 +128,16 @@ module Telnyx
       sig { params(sip_compact_headers_enabled: T::Boolean).void }
       attr_writer :sip_compact_headers_enabled
 
+      # Selects which `sip_region` to receive inbound calls from. If null, the default
+      # region (US) will be used.
+      sig { returns(T.nilable(Telnyx::UacInboundRequest::SipRegion::OrSymbol)) }
+      attr_reader :sip_region
+
+      sig do
+        params(sip_region: Telnyx::UacInboundRequest::SipRegion::OrSymbol).void
+      end
+      attr_writer :sip_region
+
       # Time(sec) before aborting if connection is not made.
       sig { returns(T.nilable(Integer)) }
       attr_reader :timeout_1xx_secs
@@ -162,6 +172,7 @@ module Telnyx
           simultaneous_ringing:
             Telnyx::UacInboundRequest::SimultaneousRinging::OrSymbol,
           sip_compact_headers_enabled: T::Boolean,
+          sip_region: Telnyx::UacInboundRequest::SipRegion::OrSymbol,
           timeout_1xx_secs: Integer,
           timeout_2xx_secs: Integer
         ).returns(T.attached_class)
@@ -198,6 +209,9 @@ module Telnyx
         simultaneous_ringing: nil,
         # Defaults to true.
         sip_compact_headers_enabled: nil,
+        # Selects which `sip_region` to receive inbound calls from. If null, the default
+        # region (US) will be used.
+        sip_region: nil,
         # Time(sec) before aborting if connection is not made.
         timeout_1xx_secs: nil,
         # Time(sec) before aborting if call is unanswered (min: 1, max: 600).
@@ -223,6 +237,7 @@ module Telnyx
             simultaneous_ringing:
               Telnyx::UacInboundRequest::SimultaneousRinging::OrSymbol,
             sip_compact_headers_enabled: T::Boolean,
+            sip_region: Telnyx::UacInboundRequest::SipRegion::OrSymbol,
             timeout_1xx_secs: Integer,
             timeout_2xx_secs: Integer
           }
@@ -376,6 +391,30 @@ module Telnyx
         def self.values
         end
       end
+
+      # Selects which `sip_region` to receive inbound calls from. If null, the default
+      # region (US) will be used.
+      module SipRegion
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Telnyx::UacInboundRequest::SipRegion) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        US = T.let(:US, Telnyx::UacInboundRequest::SipRegion::TaggedSymbol)
+        EUROPE =
+          T.let(:Europe, Telnyx::UacInboundRequest::SipRegion::TaggedSymbol)
+        AUSTRALIA =
+          T.let(:Australia, Telnyx::UacInboundRequest::SipRegion::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Telnyx::UacInboundRequest::SipRegion::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/telnyx/models/whatsapp/phone_number_retrieve_conversation_window_params.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Whatsapp
+      class PhoneNumberRetrieveConversationWindowParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Whatsapp::PhoneNumberRetrieveConversationWindowParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :phone_number
+
+        # Destination phone number in E.164 format
+        sig { returns(String) }
+        attr_accessor :destination_number
+
+        sig do
+          params(
+            phone_number: String,
+            destination_number: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          phone_number:,
+          # Destination phone number in E.164 format
+          destination_number:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              phone_number: String,
+              destination_number: String,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/whatsapp/phone_number_retrieve_conversation_window_response.rbi

@@ -0,0 +1,125 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Whatsapp
+      class PhoneNumberRetrieveConversationWindowResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::Whatsapp::PhoneNumberRetrieveConversationWindowResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(
+              Telnyx::Models::Whatsapp::PhoneNumberRetrieveConversationWindowResponse::Data
+            )
+          )
+        end
+        attr_reader :data
+
+        sig do
+          params(
+            data:
+              Telnyx::Models::Whatsapp::PhoneNumberRetrieveConversationWindowResponse::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        sig do
+          params(
+            data:
+              Telnyx::Models::Whatsapp::PhoneNumberRetrieveConversationWindowResponse::Data::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(data: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              data:
+                Telnyx::Models::Whatsapp::PhoneNumberRetrieveConversationWindowResponse::Data
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::Whatsapp::PhoneNumberRetrieveConversationWindowResponse::Data,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Timestamp of the last inbound message that opened the window
+          sig { returns(T.nilable(Time)) }
+          attr_reader :last_user_message_at
+
+          sig { params(last_user_message_at: Time).void }
+          attr_writer :last_user_message_at
+
+          # Whether the 24-hour conversation window is currently open
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :window_active
+
+          sig { params(window_active: T::Boolean).void }
+          attr_writer :window_active
+
+          # When the window closes. Null if no active window.
+          sig { returns(T.nilable(Time)) }
+          attr_reader :window_expires_at
+
+          sig { params(window_expires_at: Time).void }
+          attr_writer :window_expires_at
+
+          # Window type. Currently always 24h when present.
+          sig { returns(T.nilable(String)) }
+          attr_reader :window_type
+
+          sig { params(window_type: String).void }
+          attr_writer :window_type
+
+          sig do
+            params(
+              last_user_message_at: Time,
+              window_active: T::Boolean,
+              window_expires_at: Time,
+              window_type: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Timestamp of the last inbound message that opened the window
+            last_user_message_at: nil,
+            # Whether the 24-hour conversation window is currently open
+            window_active: nil,
+            # When the window closes. Null if no active window.
+            window_expires_at: nil,
+            # Window type. Currently always 24h when present.
+            window_type: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                last_user_message_at: Time,
+                window_active: T::Boolean,
+                window_expires_at: Time,
+                window_type: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/wireguard_peer_retrieve_config_response.rbi

@@ -2,6 +2,6 @@
 
 module Telnyx
   module Models
-    WireguardPeerRetrieveConfigResponse = String
+    WireguardPeerRetrieveConfigResponse = T.type_alias { String }
   end
 end

data/rbi/telnyx/resources/dir/references.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Dir
+      # Submit and manage the two business references and one financial reference that
+      # vouch for a DIR. References are contacted to confirm the business identity
+      # during vetting.
+      class References
+        # Submit the two business references and one financial reference for a DIR.
+        #
+        # The DIR's authorizer email must be verified first (see the email-verification
+        # endpoint). Until it is, this returns `409` and no references are stored.
+        #
+        # The request body carries exactly two business references plus one financial
+        # reference. On success the references are stored and the response echoes them in
+        # the same shape as the GET. Submitting again converges on the already-stored
+        # references rather than erroring.
+        sig do
+          params(
+            dir_id: String,
+            business_references: T::Array[Telnyx::Dir::ReferenceInput::OrHash],
+            financial_reference: Telnyx::Dir::ReferenceInput::OrHash,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Dir::ReferenceList)
+        end
+        def create(
+          # The DIR id. Lowercase UUID.
+          dir_id,
+          # Exactly two business references.
+          business_references:,
+          # One reference supplied at submit. The reference type is implied by the field
+          # that carries it (business_references vs financial_reference).
+          financial_reference:,
+          request_options: {}
+        )
+        end
+
+        # Partially update one reference, addressed by the DIR id plus the reference's
+        # type (business or financial) and slot.
+        #
+        # Cosmetic fields (full name, job title, organization, relationship, email) are
+        # always editable. The phone number and timezone may only be changed while a
+        # scheduled call has not yet been dialed; if a call is in progress or all attempts
+        # are complete, those fields are locked. Changing the timezone reschedules any
+        # pending call into the new local calling window.
+        sig do
+          params(
+            slot: Integer,
+            dir_id: String,
+            ref_type: Telnyx::Dir::ReferenceUpdateParams::RefType::OrSymbol,
+            email: String,
+            full_name: String,
+            job_title: T.nilable(String),
+            organization: T.nilable(String),
+            phone_e164: String,
+            relationship_to_registrant: T.nilable(String),
+            timezone: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Dir::ReferenceUpdateResponse)
+        end
+        def update(
+          # Path param: Reference slot. Business references use slots 0 and 1; the financial
+          # reference uses slot 0.
+          slot,
+          # Path param: The DIR id. Lowercase UUID.
+          dir_id:,
+          # Path param: Reference type to address.
+          ref_type:,
+          # Body param: Reference contact email address.
+          email: nil,
+          # Body param: Full name of the reference contact.
+          full_name: nil,
+          # Body param: Job title of the reference contact.
+          job_title: nil,
+          # Body param: Organization the reference contact belongs to.
+          organization: nil,
+          # Body param: Reference phone number in E.164 format.
+          phone_e164: nil,
+          # Body param: How the reference contact is related to the registering business.
+          relationship_to_registrant: nil,
+          # Body param: IANA timezone id for the reference.
+          timezone: nil,
+          request_options: {}
+        )
+        end
+
+        # List the business and financial references submitted for a DIR.
+        #
+        # Returns the two business references (slots 0 and 1) followed by the single
+        # financial reference. Each entry carries only the customer-supplied details
+        # (name, title, organization, relationship, phone, email, timezone). Returns an
+        # empty list when no references were submitted.
+        sig do
+          params(
+            dir_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Dir::ReferenceList)
+        end
+        def list(
+          # The DIR id. Lowercase UUID.
+          dir_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/dir/verify_email.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Dir
+      # Verify ownership of a DIR's authorizer email. A short code is emailed and
+      # confirmed; the email must be verified before references can be submitted.
+      class VerifyEmail
+        # Email a 6-digit code to the DIR's authorizer email to confirm ownership of that
+        # address.
+        #
+        # The code expires in 15 minutes. Requesting a new code invalidates any previous
+        # one. Resends are rate limited (a short cooldown plus a daily cap). Submit the
+        # code to `POST /dir/{dir_id}/verify_email/confirm`.
+        sig do
+          params(
+            dir_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Dir::EmailVerificationStatusWrapped)
+        end
+        def create(
+          # The DIR id. Lowercase UUID.
+          dir_id,
+          request_options: {}
+        )
+        end
+
+        # Whether the DIR's current authorizer email has been verified.
+        sig do
+          params(
+            dir_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Dir::EmailVerificationStatusWrapped)
+        end
+        def list(
+          # The DIR id. Lowercase UUID.
+          dir_id,
+          request_options: {}
+        )
+        end
+
+        # Submit the 6-digit code that was emailed to the DIR's authorizer email. On
+        # success the authorizer email is marked verified.
+        #
+        # For security, any failure (wrong, expired, already-used, or too many attempts)
+        # returns the same generic message.
+        sig do
+          params(
+            dir_id: String,
+            code: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Dir::EmailVerificationStatusWrapped)
+        end
+        def confirm(
+          # The DIR id. Lowercase UUID.
+          dir_id,
+          # The 6-digit code sent to the authorizer email.
+          code:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/dir.rbi

@@ -18,6 +18,17 @@ module Telnyx
       sig { returns(Telnyx::Resources::Dir::PhoneNumbers) }
       attr_reader :phone_numbers
 
+      # Submit and manage the two business references and one financial reference that
+      # vouch for a DIR. References are contacted to confirm the business identity
+      # during vetting.
+      sig { returns(Telnyx::Resources::Dir::References) }
+      attr_reader :references
+
+      # Verify ownership of a DIR's authorizer email. A short code is emailed and
+      # confirmed; the email must be verified before references can be submitted.
+      sig { returns(Telnyx::Resources::Dir::VerifyEmail) }
+      attr_reader :verify_email
+
       # Returns a single DIR by id. The enterprise is resolved server-side from the DIR
       # id. Returns `404` if the DIR does not exist or is not yours.
       sig do
@@ -294,7 +305,8 @@ module Telnyx
         infringement_resolution_notes:,
         call_reasons: nil,
         display_name: nil,
-        # Append-only supporting documents.
+        # Append-only supporting documents to attach while resolving the claim (e.g.
+        # authorization or licensing proof).
         documents: nil,
         # Publicly accessible HTTPS URL (max 128 chars) to a 256x256 BMP logo (max 1 MB).
         logo_url: nil,

data/rbi/telnyx/resources/enterprises/dir.rbi

@@ -36,6 +36,7 @@ module Telnyx
             enterprise_id: String,
             authorizer_email: String,
             authorizer_name: String,
+            call_reasons: T::Array[String],
             certify_brand_is_accurate:
               Telnyx::Enterprises::DirCreateParams::CertifyBrandIsAccurate::OrBoolean,
             certify_ip_ownership:
@@ -43,7 +44,6 @@ module Telnyx
             certify_no_shaft_content:
               Telnyx::Enterprises::DirCreateParams::CertifyNoShaftContent::OrBoolean,
             display_name: String,
-            call_reasons: T::Array[String],
             documents: T::Array[Telnyx::Document::OrHash],
             logo_url: String,
             reselling: T::Boolean,
@@ -59,6 +59,9 @@ module Telnyx
           # Name of the person at your enterprise who is authorizing this DIR registration.
           # Must be a real individual (used for audit and trademark-claim contests).
           authorizer_name:,
+          # 1–10 reasons your business calls customers. Validate phrasing against
+          # `POST /call_reasons/validate`.
+          call_reasons:,
           # Must be `true`.
           certify_brand_is_accurate:,
           # Must be `true`. Confirms ownership of any logos/trademarks shown.
@@ -68,9 +71,6 @@ module Telnyx
           certify_no_shaft_content:,
           # Name shown to call recipients. No emoji; not whitespace-only.
           display_name:,
-          # 1–10 reasons your business calls customers. Validate phrasing against
-          # `POST /call_reasons/validate`.
-          call_reasons: nil,
           # Supporting documents. Each `document_id` may appear at most once on a DIR.
           documents: nil,
           # Publicly accessible HTTPS URL (max 128 chars) to a 256x256 BMP logo (max 1 MB).

data/rbi/telnyx/resources/storage/kvs/keys.rbi

@@ -0,0 +1,122 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Storage
+      class Kvs
+        # Read and write keys within a KV namespace
+        class Keys
+          # Returns the raw stored value for a key. The response body is the value exactly
+          # as it was written; the `Content-Type` header echoes the value's stored content
+          # type (defaults to `application/octet-stream`).
+          sig do
+            params(
+              key: String,
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(StringIO)
+          end
+          def retrieve(
+            # Key name. Allowed characters: `a-z A-Z 0-9 - _ / = .`; maximum 256 characters;
+            # names starting with `_` are reserved for system use. May contain `/`. When
+            # calling the HTTP API directly, URL-encode the key so the whole string is treated
+            # as one key (for example `user/1` -> `user%2F1`). SDK users should pass the key
+            # raw - SDKs URL-encode path parameters automatically.
+            key,
+            # KV namespace ID
+            id:,
+            request_options: {}
+          )
+          end
+
+          # Creates or replaces the value for a key. The request body is stored verbatim as
+          # the value — no base64, no JSON envelope — up to 1 MiB. The request's
+          # `Content-Type` header is stored with the value and echoed back on retrieval.
+          # Returns `201` when the key is created and `200` when an existing key is updated.
+          sig do
+            params(
+              key: String,
+              id: String,
+              body: Telnyx::Internal::FileInput,
+              ttl_secs: Integer,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).void
+          end
+          def update(
+            # Path param: Key name. Allowed characters: `a-z A-Z 0-9 - _ / = .`; maximum 256
+            # characters; names starting with `_` are reserved for system use. May contain
+            # `/`. When calling the HTTP API directly, URL-encode the key so the whole string
+            # is treated as one key (for example `user/1` -> `user%2F1`). SDK users should
+            # pass the key raw - SDKs URL-encode path parameters automatically.
+            key,
+            # Path param: KV namespace ID
+            id:,
+            # Body param: Raw value bytes, stored verbatim.
+            body:,
+            # Query param: Time-to-live in seconds. When set, the key expires and is deleted
+            # after this duration. Requires a namespace provisioned with TTL support;
+            # namespaces without it return a `409`.
+            ttl_secs: nil,
+            request_options: {}
+          )
+          end
+
+          # Lists the keys in a namespace. Returns key names and metadata only, never
+          # values. Results are paginated with `limit` and an opaque `cursor`.
+          sig do
+            params(
+              id: String,
+              cursor: String,
+              limit: Integer,
+              prefix: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(
+              Telnyx::Internal::CursorFlatPagination[
+                Telnyx::Models::Storage::Kvs::KeyListResponse
+              ]
+            )
+          end
+          def list(
+            # KV namespace ID
+            id,
+            # Opaque pagination cursor from a previous response's `meta.cursor`.
+            cursor: nil,
+            # Maximum number of keys to return. Values above 1000 are treated as 1000.
+            limit: nil,
+            # Return only keys that start with this prefix.
+            prefix: nil,
+            request_options: {}
+          )
+          end
+
+          # Deletes a key. Idempotent: deleting a key that does not exist still succeeds.
+          # The namespace itself must exist and be provisioned.
+          sig do
+            params(
+              key: String,
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).void
+          end
+          def delete(
+            # Key name. Allowed characters: `a-z A-Z 0-9 - _ / = .`; maximum 256 characters;
+            # names starting with `_` are reserved for system use. May contain `/`. When
+            # calling the HTTP API directly, URL-encode the key so the whole string is treated
+            # as one key (for example `user/1` -> `user%2F1`). SDK users should pass the key
+            # raw - SDKs URL-encode path parameters automatically.
+            key,
+            # KV namespace ID
+            id:,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Telnyx::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end