telnyx 5.168.0 → 5.170.0

data/rbi/telnyx/models/email_messages/email_recipient.rbi

@@ -243,6 +243,16 @@ module Telnyx
               :cancelled,
               Telnyx::EmailMessages::EmailRecipient::Status::TaggedSymbol
             )
+          INJECTION_TIMEOUT =
+            T.let(
+              :injection_timeout,
+              Telnyx::EmailMessages::EmailRecipient::Status::TaggedSymbol
+            )
+          EXPIRED =
+            T.let(
+              :expired,
+              Telnyx::EmailMessages::EmailRecipient::Status::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/telnyx/models/email_messages/recipient_list_params.rbi

@@ -201,6 +201,16 @@ module Telnyx
               :cancelled,
               Telnyx::EmailMessages::RecipientListParams::Status::TaggedSymbol
             )
+          INJECTION_TIMEOUT =
+            T.let(
+              :injection_timeout,
+              Telnyx::EmailMessages::RecipientListParams::Status::TaggedSymbol
+            )
+          EXPIRED =
+            T.let(
+              :expired,
+              Telnyx::EmailMessages::RecipientListParams::Status::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/telnyx/models/email_template.rbi

@@ -9,6 +9,12 @@ module Telnyx
       sig { returns(String) }
       attr_accessor :id
 
+      # Whether HTML autoescaping is enabled for this template. When `true`, only
+      # rendered `html_body` expression output is HTML-escaped at the output boundary;
+      # `subject` and `text_body` are never autoescaped.
+      sig { returns(T::Boolean) }
+      attr_accessor :autoescape
+
       sig { returns(Time) }
       attr_accessor :created_at
 
@@ -21,6 +27,12 @@ module Telnyx
       sig { returns(Telnyx::EmailTemplate::RecordType::TaggedSymbol) }
       attr_accessor :record_type
 
+      # Whether strict variable validation is enabled for this template. When `true`,
+      # sends and renders that are missing a variable marked `required: true` in
+      # `variable_schema` fail with 422 naming the variable.
+      sig { returns(T::Boolean) }
+      attr_accessor :strict_variables
+
       sig { returns(T.nilable(String)) }
       attr_accessor :subject
 
@@ -30,31 +42,59 @@ module Telnyx
       sig { returns(Time) }
       attr_accessor :updated_at
 
+      # Structured variable requirements, or `null` when the template uses only the
+      # legacy `variables` array.
+      sig do
+        returns(
+          T.nilable(T::Hash[Symbol, Telnyx::EmailTemplate::VariableSchema])
+        )
+      end
+      attr_accessor :variable_schema
+
+      # Legacy unstructured variable names. This path remains supported unchanged.
       sig { returns(T::Array[String]) }
       attr_accessor :variables
 
       sig do
         params(
           id: String,
+          autoescape: T::Boolean,
           created_at: Time,
           html_body: T.nilable(String),
           name: String,
           record_type: Telnyx::EmailTemplate::RecordType::OrSymbol,
+          strict_variables: T::Boolean,
           subject: T.nilable(String),
           text_body: T.nilable(String),
           updated_at: Time,
+          variable_schema:
+            T.nilable(
+              T::Hash[Symbol, Telnyx::EmailTemplate::VariableSchema::OrHash]
+            ),
           variables: T::Array[String]
         ).returns(T.attached_class)
       end
       def self.new(
         id:,
+        # Whether HTML autoescaping is enabled for this template. When `true`, only
+        # rendered `html_body` expression output is HTML-escaped at the output boundary;
+        # `subject` and `text_body` are never autoescaped.
+        autoescape:,
         created_at:,
         html_body:,
         name:,
         record_type:,
+        # Whether strict variable validation is enabled for this template. When `true`,
+        # sends and renders that are missing a variable marked `required: true` in
+        # `variable_schema` fail with 422 naming the variable.
+        strict_variables:,
         subject:,
         text_body:,
         updated_at:,
+        # Structured variable requirements, or `null` when the template uses only the
+        # legacy `variables` array.
+        variable_schema:,
+        # Legacy unstructured variable names. This path remains supported unchanged.
         variables:
       )
       end
@@ -63,13 +103,17 @@ module Telnyx
         override.returns(
           {
             id: String,
+            autoescape: T::Boolean,
             created_at: Time,
             html_body: T.nilable(String),
             name: String,
             record_type: Telnyx::EmailTemplate::RecordType::TaggedSymbol,
+            strict_variables: T::Boolean,
             subject: T.nilable(String),
             text_body: T.nilable(String),
             updated_at: Time,
+            variable_schema:
+              T.nilable(T::Hash[Symbol, Telnyx::EmailTemplate::VariableSchema]),
             variables: T::Array[String]
           }
         )
@@ -98,6 +142,46 @@ module Telnyx
         def self.values
         end
       end
+
+      class VariableSchema < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailTemplate::VariableSchema,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        # Whether the variable must be supplied when strict variable validation is
+        # enabled.
+        sig { returns(T::Boolean) }
+        attr_accessor :required
+
+        # Default value for an optional variable. Rejected when `required` is `true`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :default
+
+        sig { params(default: String).void }
+        attr_writer :default
+
+        sig do
+          params(required: T::Boolean, default: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Whether the variable must be supplied when strict variable validation is
+          # enabled.
+          required:,
+          # Default value for an optional variable. Rejected when `required` is `true`.
+          default: nil
+        )
+        end
+
+        sig { override.returns({ required: T::Boolean, default: String }) }
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/telnyx/models/email_template_create_params.rbi

@@ -15,10 +15,36 @@ module Telnyx
       sig { returns(String) }
       attr_accessor :name
 
+      # Per-template HTML autoescaping setting. Defaults to `false` for backward
+      # compatibility. When `true`, the rendered `html_body` HTML-escapes each Liquid
+      # expression's output at the output boundary (after its filters run, before
+      # concatenation with literal template markup). Input values are never mutated and
+      # `subject`/`text_body` are never autoescaped. The boundary escape is idempotent:
+      # HTML entities already present in the output (e.g. from an explicit `escape`
+      # filter) are preserved, so an explicit `escape`/`escape_once` is never
+      # double-escaped, and markup introduced by any later filter in the chain is still
+      # escaped.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :autoescape
+
+      sig { params(autoescape: T::Boolean).void }
+      attr_writer :autoescape
+
       # Liquid template HTML body.
       sig { returns(T.nilable(String)) }
       attr_accessor :html_body
 
+      # Per-template strict variable-validation setting. Defaults to `false` for
+      # backward compatibility. When `true`, a send or render that is missing a variable
+      # marked `required: true` in `variable_schema` fails with 422 naming the variable.
+      # Missing optional variables never fail; their schema `default` (when set) is
+      # applied to the render.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :strict_variables
+
+      sig { params(strict_variables: T::Boolean).void }
+      attr_writer :strict_variables
+
       # Liquid template subject.
       sig { returns(T.nilable(String)) }
       attr_accessor :subject
@@ -27,6 +53,22 @@ module Telnyx
       sig { returns(T.nilable(String)) }
       attr_accessor :text_body
 
+      # Structured variable requirements. Required variables cannot define defaults;
+      # invalid combinations return 422. This is independent of the legacy `variables`
+      # array. On render with `strict_variables` enabled: `required` variables must be
+      # supplied as non-empty values — absent, `null`, empty string, empty object `{}`,
+      # and empty array `[]` all fail with 422 naming the variable, while present values
+      # such as `false` and `0` pass (they are present, not empty). Optional variables
+      # fall back to their `default` when absent.
+      sig do
+        returns(
+          T.nilable(
+            T::Hash[Symbol, Telnyx::EmailTemplateCreateParams::VariableSchema]
+          )
+        )
+      end
+      attr_accessor :variable_schema
+
       # Template variables. Auto-extracted from subject/body fields when absent.
       sig { returns(T.nilable(T::Array[String])) }
       attr_reader :variables
@@ -43,9 +85,18 @@ module Telnyx
       sig do
         params(
           name: String,
+          autoescape: T::Boolean,
           html_body: T.nilable(String),
+          strict_variables: T::Boolean,
           subject: T.nilable(String),
           text_body: T.nilable(String),
+          variable_schema:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                Telnyx::EmailTemplateCreateParams::VariableSchema::OrHash
+              ]
+            ),
           variables: T::Array[String],
           idempotency_key: String,
           request_options: Telnyx::RequestOptions::OrHash
@@ -54,12 +105,36 @@ module Telnyx
       def self.new(
         # Letters, numbers, spaces, hyphens, and underscores only.
         name:,
+        # Per-template HTML autoescaping setting. Defaults to `false` for backward
+        # compatibility. When `true`, the rendered `html_body` HTML-escapes each Liquid
+        # expression's output at the output boundary (after its filters run, before
+        # concatenation with literal template markup). Input values are never mutated and
+        # `subject`/`text_body` are never autoescaped. The boundary escape is idempotent:
+        # HTML entities already present in the output (e.g. from an explicit `escape`
+        # filter) are preserved, so an explicit `escape`/`escape_once` is never
+        # double-escaped, and markup introduced by any later filter in the chain is still
+        # escaped.
+        autoescape: nil,
         # Liquid template HTML body.
         html_body: nil,
+        # Per-template strict variable-validation setting. Defaults to `false` for
+        # backward compatibility. When `true`, a send or render that is missing a variable
+        # marked `required: true` in `variable_schema` fails with 422 naming the variable.
+        # Missing optional variables never fail; their schema `default` (when set) is
+        # applied to the render.
+        strict_variables: nil,
         # Liquid template subject.
         subject: nil,
         # Liquid template text body.
         text_body: nil,
+        # Structured variable requirements. Required variables cannot define defaults;
+        # invalid combinations return 422. This is independent of the legacy `variables`
+        # array. On render with `strict_variables` enabled: `required` variables must be
+        # supplied as non-empty values — absent, `null`, empty string, empty object `{}`,
+        # and empty array `[]` all fail with 422 naming the variable, while present values
+        # such as `false` and `0` pass (they are present, not empty). Optional variables
+        # fall back to their `default` when absent.
+        variable_schema: nil,
         # Template variables. Auto-extracted from subject/body fields when absent.
         variables: nil,
         idempotency_key: nil,
@@ -71,9 +146,18 @@ module Telnyx
         override.returns(
           {
             name: String,
+            autoescape: T::Boolean,
             html_body: T.nilable(String),
+            strict_variables: T::Boolean,
             subject: T.nilable(String),
             text_body: T.nilable(String),
+            variable_schema:
+              T.nilable(
+                T::Hash[
+                  Symbol,
+                  Telnyx::EmailTemplateCreateParams::VariableSchema
+                ]
+              ),
             variables: T::Array[String],
             idempotency_key: String,
             request_options: Telnyx::RequestOptions
@@ -82,6 +166,46 @@ module Telnyx
       end
       def to_hash
       end
+
+      class VariableSchema < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailTemplateCreateParams::VariableSchema,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        # Whether the variable must be supplied when strict variable validation is
+        # enabled.
+        sig { returns(T::Boolean) }
+        attr_accessor :required
+
+        # Default value for an optional variable. Rejected when `required` is `true`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :default
+
+        sig { params(default: String).void }
+        attr_writer :default
+
+        sig do
+          params(required: T::Boolean, default: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Whether the variable must be supplied when strict variable validation is
+          # enabled.
+          required:,
+          # Default value for an optional variable. Rejected when `required` is `true`.
+          default: nil
+        )
+        end
+
+        sig { override.returns({ required: T::Boolean, default: String }) }
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/telnyx/models/email_webhook_recipient.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailWebhookRecipient < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::EmailWebhookRecipient, Telnyx::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :email
+
+      sig do
+        returns(T.nilable(Telnyx::EmailWebhookRecipient::Kind::TaggedSymbol))
+      end
+      attr_reader :kind
+
+      sig { params(kind: Telnyx::EmailWebhookRecipient::Kind::OrSymbol).void }
+      attr_writer :kind
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      sig do
+        params(
+          email: String,
+          kind: Telnyx::EmailWebhookRecipient::Kind::OrSymbol,
+          name: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(email:, kind: nil, name: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            email: String,
+            kind: Telnyx::EmailWebhookRecipient::Kind::TaggedSymbol,
+            name: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Kind
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Telnyx::EmailWebhookRecipient::Kind) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TO = T.let(:to, Telnyx::EmailWebhookRecipient::Kind::TaggedSymbol)
+        CC = T.let(:cc, Telnyx::EmailWebhookRecipient::Kind::TaggedSymbol)
+        BCC = T.let(:bcc, Telnyx::EmailWebhookRecipient::Kind::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Telnyx::EmailWebhookRecipient::Kind::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/inbound_message_webhook_event.rbi

@@ -8,192 +8,23 @@ module Telnyx
           T.any(Telnyx::InboundMessageWebhookEvent, Telnyx::Internal::AnyHash)
         end
 
-      sig { returns(T.nilable(Telnyx::InboundMessageWebhookEvent::Data)) }
+      sig { returns(T.nilable(Telnyx::MessagingInboundMessage)) }
       attr_reader :data
 
-      sig do
-        params(data: Telnyx::InboundMessageWebhookEvent::Data::OrHash).void
-      end
+      sig { params(data: Telnyx::MessagingInboundMessage::OrHash).void }
       attr_writer :data
 
       sig do
-        params(data: Telnyx::InboundMessageWebhookEvent::Data::OrHash).returns(
+        params(data: Telnyx::MessagingInboundMessage::OrHash).returns(
           T.attached_class
         )
       end
       def self.new(data: nil)
       end
 
-      sig do
-        override.returns({ data: Telnyx::InboundMessageWebhookEvent::Data })
-      end
+      sig { override.returns({ data: Telnyx::MessagingInboundMessage }) }
       def to_hash
       end
-
-      class Data < Telnyx::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Telnyx::InboundMessageWebhookEvent::Data,
-              Telnyx::Internal::AnyHash
-            )
-          end
-
-        # Identifies the type of resource.
-        sig { returns(T.nilable(String)) }
-        attr_reader :id
-
-        sig { params(id: String).void }
-        attr_writer :id
-
-        # The type of event being delivered.
-        sig do
-          returns(
-            T.nilable(
-              Telnyx::InboundMessageWebhookEvent::Data::EventType::TaggedSymbol
-            )
-          )
-        end
-        attr_reader :event_type
-
-        sig do
-          params(
-            event_type:
-              Telnyx::InboundMessageWebhookEvent::Data::EventType::OrSymbol
-          ).void
-        end
-        attr_writer :event_type
-
-        # ISO 8601 formatted date indicating when the resource was created.
-        sig { returns(T.nilable(Time)) }
-        attr_reader :occurred_at
-
-        sig { params(occurred_at: Time).void }
-        attr_writer :occurred_at
-
-        sig { returns(T.nilable(Telnyx::MessagingInboundMessagePayload)) }
-        attr_reader :payload
-
-        sig do
-          params(payload: Telnyx::MessagingInboundMessagePayload::OrHash).void
-        end
-        attr_writer :payload
-
-        # Identifies the type of the resource.
-        sig do
-          returns(
-            T.nilable(
-              Telnyx::InboundMessageWebhookEvent::Data::RecordType::TaggedSymbol
-            )
-          )
-        end
-        attr_reader :record_type
-
-        sig do
-          params(
-            record_type:
-              Telnyx::InboundMessageWebhookEvent::Data::RecordType::OrSymbol
-          ).void
-        end
-        attr_writer :record_type
-
-        sig do
-          params(
-            id: String,
-            event_type:
-              Telnyx::InboundMessageWebhookEvent::Data::EventType::OrSymbol,
-            occurred_at: Time,
-            payload: Telnyx::MessagingInboundMessagePayload::OrHash,
-            record_type:
-              Telnyx::InboundMessageWebhookEvent::Data::RecordType::OrSymbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Identifies the type of resource.
-          id: nil,
-          # The type of event being delivered.
-          event_type: nil,
-          # ISO 8601 formatted date indicating when the resource was created.
-          occurred_at: nil,
-          payload: nil,
-          # Identifies the type of the resource.
-          record_type: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              id: String,
-              event_type:
-                Telnyx::InboundMessageWebhookEvent::Data::EventType::TaggedSymbol,
-              occurred_at: Time,
-              payload: Telnyx::MessagingInboundMessagePayload,
-              record_type:
-                Telnyx::InboundMessageWebhookEvent::Data::RecordType::TaggedSymbol
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # The type of event being delivered.
-        module EventType
-          extend Telnyx::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, Telnyx::InboundMessageWebhookEvent::Data::EventType)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          MESSAGE_RECEIVED =
-            T.let(
-              :"message.received",
-              Telnyx::InboundMessageWebhookEvent::Data::EventType::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                Telnyx::InboundMessageWebhookEvent::Data::EventType::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-
-        # Identifies the type of the resource.
-        module RecordType
-          extend Telnyx::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                Telnyx::InboundMessageWebhookEvent::Data::RecordType
-              )
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          EVENT =
-            T.let(
-              :event,
-              Telnyx::InboundMessageWebhookEvent::Data::RecordType::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                Telnyx::InboundMessageWebhookEvent::Data::RecordType::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-      end
     end
   end
 end

data/rbi/telnyx/models/machine_payment_account_credit_params.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class MachinePaymentAccountCreditParams < Telnyx::Internal::Type::BaseModel
+      extend Telnyx::Internal::Type::RequestParameters::Converter
+      include Telnyx::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Telnyx::MachinePaymentAccountCreditParams,
+            Telnyx::Internal::AnyHash
+          )
+        end
+
+      # Amount to credit in USD, as a decimal string with up to two fractional digits
+      # (by default between 5.00 and 500.00). The request body is required on the
+      # initial challenge request and remains required on a paid retry, where you
+      # re-send the identical body plus the payment credential — the credential, not the
+      # body, selects the payment, and the retried body is not re-validated.
+      sig { returns(String) }
+      attr_accessor :amount_usd
+
+      sig do
+        params(
+          amount_usd: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Amount to credit in USD, as a decimal string with up to two fractional digits
+        # (by default between 5.00 and 500.00). The request body is required on the
+        # initial challenge request and remains required on a paid retry, where you
+        # re-send the identical body plus the payment credential — the credential, not the
+        # body, selects the payment, and the retried body is not re-validated.
+        amount_usd:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { amount_usd: String, request_options: Telnyx::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end