telnyx 5.169.0 → 5.171.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

@@ -2,102 +2,20 @@
 
 module Telnyx
   module Models
-    class EmailTemplate < Telnyx::Internal::Type::BaseModel
+    class EmailTemplate < Telnyx::Models::EmailTemplateCommon
       OrHash =
         T.type_alias { T.any(Telnyx::EmailTemplate, Telnyx::Internal::AnyHash) }
 
-      sig { returns(String) }
-      attr_accessor :id
-
-      sig { returns(Time) }
-      attr_accessor :created_at
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :html_body
-
-      sig { returns(String) }
-      attr_accessor :name
-
-      sig { returns(Telnyx::EmailTemplate::RecordType::TaggedSymbol) }
-      attr_accessor :record_type
-
       sig { returns(T.nilable(String)) }
       attr_accessor :subject
 
-      sig { returns(T.nilable(String)) }
-      attr_accessor :text_body
-
-      sig { returns(Time) }
-      attr_accessor :updated_at
-
-      sig { returns(T::Array[String]) }
-      attr_accessor :variables
-
-      sig do
-        params(
-          id: String,
-          created_at: Time,
-          html_body: T.nilable(String),
-          name: String,
-          record_type: Telnyx::EmailTemplate::RecordType::OrSymbol,
-          subject: T.nilable(String),
-          text_body: T.nilable(String),
-          updated_at: Time,
-          variables: T::Array[String]
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        id:,
-        created_at:,
-        html_body:,
-        name:,
-        record_type:,
-        subject:,
-        text_body:,
-        updated_at:,
-        variables:
-      )
+      sig { params(subject: T.nilable(String)).returns(T.attached_class) }
+      def self.new(subject:)
       end
 
-      sig do
-        override.returns(
-          {
-            id: String,
-            created_at: Time,
-            html_body: T.nilable(String),
-            name: String,
-            record_type: Telnyx::EmailTemplate::RecordType::TaggedSymbol,
-            subject: T.nilable(String),
-            text_body: T.nilable(String),
-            updated_at: Time,
-            variables: T::Array[String]
-          }
-        )
-      end
+      sig { override.returns({ subject: T.nilable(String) }) }
       def to_hash
       end
-
-      module RecordType
-        extend Telnyx::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, Telnyx::EmailTemplate::RecordType) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        EMAIL_TEMPLATE =
-          T.let(
-            :email_template,
-            Telnyx::EmailTemplate::RecordType::TaggedSymbol
-          )
-
-        sig do
-          override.returns(
-            T::Array[Telnyx::EmailTemplate::RecordType::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
-      end
     end
   end
 end

data/rbi/telnyx/models/email_template_common.rbi

@@ -0,0 +1,238 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailTemplateCommon < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::EmailTemplateCommon, Telnyx::Internal::AnyHash)
+        end
+
+      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
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :html_body
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Telnyx::EmailTemplateCommon::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 :text_body
+
+      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::EmailTemplateCommon::VariableSchema]
+          )
+        )
+      end
+      attr_accessor :variable_schema
+
+      # Persisted variable names. In `explicit` mode this array preserves the exact
+      # provided order, duplicates, and string contents; in `automatic` mode it is
+      # derived from the stored subject and bodies.
+      sig { returns(T::Array[String]) }
+      attr_accessor :variables
+
+      # `automatic` when variable names are derived from template content; `explicit`
+      # when `variables` is the exact manually managed array.
+      sig { returns(Telnyx::EmailTemplateCommon::VariablesMode::TaggedSymbol) }
+      attr_accessor :variables_mode
+
+      sig do
+        params(
+          id: String,
+          autoescape: T::Boolean,
+          created_at: Time,
+          html_body: T.nilable(String),
+          name: String,
+          record_type: Telnyx::EmailTemplateCommon::RecordType::OrSymbol,
+          strict_variables: T::Boolean,
+          text_body: T.nilable(String),
+          updated_at: Time,
+          variable_schema:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                Telnyx::EmailTemplateCommon::VariableSchema::OrHash
+              ]
+            ),
+          variables: T::Array[String],
+          variables_mode: Telnyx::EmailTemplateCommon::VariablesMode::OrSymbol
+        ).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:,
+        text_body:,
+        updated_at:,
+        # Structured variable requirements, or `null` when the template uses only the
+        # legacy `variables` array.
+        variable_schema:,
+        # Persisted variable names. In `explicit` mode this array preserves the exact
+        # provided order, duplicates, and string contents; in `automatic` mode it is
+        # derived from the stored subject and bodies.
+        variables:,
+        # `automatic` when variable names are derived from template content; `explicit`
+        # when `variables` is the exact manually managed array.
+        variables_mode:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            autoescape: T::Boolean,
+            created_at: Time,
+            html_body: T.nilable(String),
+            name: String,
+            record_type: Telnyx::EmailTemplateCommon::RecordType::TaggedSymbol,
+            strict_variables: T::Boolean,
+            text_body: T.nilable(String),
+            updated_at: Time,
+            variable_schema:
+              T.nilable(
+                T::Hash[Symbol, Telnyx::EmailTemplateCommon::VariableSchema]
+              ),
+            variables: T::Array[String],
+            variables_mode:
+              Telnyx::EmailTemplateCommon::VariablesMode::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module RecordType
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Telnyx::EmailTemplateCommon::RecordType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EMAIL_TEMPLATE =
+          T.let(
+            :email_template,
+            Telnyx::EmailTemplateCommon::RecordType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Telnyx::EmailTemplateCommon::RecordType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class VariableSchema < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailTemplateCommon::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
+
+      # `automatic` when variable names are derived from template content; `explicit`
+      # when `variables` is the exact manually managed array.
+      module VariablesMode
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Telnyx::EmailTemplateCommon::VariablesMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AUTOMATIC =
+          T.let(
+            :automatic,
+            Telnyx::EmailTemplateCommon::VariablesMode::TaggedSymbol
+          )
+        EXPLICIT =
+          T.let(
+            :explicit,
+            Telnyx::EmailTemplateCommon::VariablesMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Telnyx::EmailTemplateCommon::VariablesMode::TaggedSymbol]
+          )
+        end
+        def self.values
+        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,12 +53,48 @@ module Telnyx
       sig { returns(T.nilable(String)) }
       attr_accessor :text_body
 
-      # Template variables. Auto-extracted from subject/body fields when absent.
+      # 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
+
+      # Persisted variable names. In `automatic` mode a non-null array is rejected; in
+      # `explicit` mode this is the exact manual array and each item is limited to 255
+      # Unicode code points.
       sig { returns(T.nilable(T::Array[String])) }
-      attr_reader :variables
+      attr_accessor :variables
 
-      sig { params(variables: T::Array[String]).void }
-      attr_writer :variables
+      # Controls how `variables` is maintained. If both fields are omitted (or
+      # `variables` is null), the template uses `automatic` mode and extracts variable
+      # names from the effective subject, HTML body, and text body. A non-null
+      # `variables` array with no mode selects `explicit`. `automatic` rejects a
+      # simultaneous non-null array; `explicit` requires a non-null array, including
+      # valid `[]`, and preserves its exact order, duplicates, and string contents.
+      sig do
+        returns(
+          T.nilable(Telnyx::EmailTemplateCreateParams::VariablesMode::OrSymbol)
+        )
+      end
+      attr_reader :variables_mode
+
+      sig do
+        params(
+          variables_mode:
+            Telnyx::EmailTemplateCreateParams::VariablesMode::OrSymbol
+        ).void
+      end
+      attr_writer :variables_mode
 
       sig { returns(T.nilable(String)) }
       attr_reader :idempotency_key
@@ -43,10 +105,21 @@ 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),
-          variables: T::Array[String],
+          variable_schema:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                Telnyx::EmailTemplateCreateParams::VariableSchema::OrHash
+              ]
+            ),
+          variables: T.nilable(T::Array[String]),
+          variables_mode:
+            Telnyx::EmailTemplateCreateParams::VariablesMode::OrSymbol,
           idempotency_key: String,
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(T.attached_class)
@@ -54,14 +127,47 @@ 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,
-        # Template variables. Auto-extracted from subject/body fields when absent.
+        # 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,
+        # Persisted variable names. In `automatic` mode a non-null array is rejected; in
+        # `explicit` mode this is the exact manual array and each item is limited to 255
+        # Unicode code points.
         variables: nil,
+        # Controls how `variables` is maintained. If both fields are omitted (or
+        # `variables` is null), the template uses `automatic` mode and extracts variable
+        # names from the effective subject, HTML body, and text body. A non-null
+        # `variables` array with no mode selects `explicit`. `automatic` rejects a
+        # simultaneous non-null array; `explicit` requires a non-null array, including
+        # valid `[]`, and preserves its exact order, duplicates, and string contents.
+        variables_mode: nil,
         idempotency_key: nil,
         request_options: {}
       )
@@ -71,10 +177,21 @@ 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),
-            variables: T::Array[String],
+            variable_schema:
+              T.nilable(
+                T::Hash[
+                  Symbol,
+                  Telnyx::EmailTemplateCreateParams::VariableSchema
+                ]
+              ),
+            variables: T.nilable(T::Array[String]),
+            variables_mode:
+              Telnyx::EmailTemplateCreateParams::VariablesMode::OrSymbol,
             idempotency_key: String,
             request_options: Telnyx::RequestOptions
           }
@@ -82,6 +199,83 @@ 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
+
+      # Controls how `variables` is maintained. If both fields are omitted (or
+      # `variables` is null), the template uses `automatic` mode and extracts variable
+      # names from the effective subject, HTML body, and text body. A non-null
+      # `variables` array with no mode selects `explicit`. `automatic` rejects a
+      # simultaneous non-null array; `explicit` requires a non-null array, including
+      # valid `[]`, and preserves its exact order, duplicates, and string contents.
+      module VariablesMode
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Telnyx::EmailTemplateCreateParams::VariablesMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AUTOMATIC =
+          T.let(
+            :automatic,
+            Telnyx::EmailTemplateCreateParams::VariablesMode::TaggedSymbol
+          )
+        EXPLICIT =
+          T.let(
+            :explicit,
+            Telnyx::EmailTemplateCreateParams::VariablesMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Telnyx::EmailTemplateCreateParams::VariablesMode::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end