telnyx 5.173.0 → 5.174.0

data/rbi/telnyx/models/compute/funcs/func_log_export_config.rbi

@@ -0,0 +1,175 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Compute
+      FuncLogExportConfig = Funcs::FuncLogExportConfig
+
+      module Funcs
+        class FuncLogExportConfig < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Compute::Funcs::FuncLogExportConfig,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Configuration record ID
+          sig { returns(T.nilable(String)) }
+          attr_reader :id
+
+          sig { params(id: String).void }
+          attr_writer :id
+
+          sig { returns(T.nilable(Time)) }
+          attr_reader :created_at
+
+          sig { params(created_at: Time).void }
+          attr_writer :created_at
+
+          # Whether export is enabled for this function
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :enabled
+
+          sig { params(enabled: T::Boolean).void }
+          attr_writer :enabled
+
+          # HTTPS OTLP endpoint URL logs are pushed to
+          sig { returns(T.nilable(String)) }
+          attr_reader :endpoint
+
+          sig { params(endpoint: String).void }
+          attr_writer :endpoint
+
+          # Function ID this configuration belongs to
+          sig { returns(T.nilable(String)) }
+          attr_reader :func_id
+
+          sig { params(func_id: String).void }
+          attr_writer :func_id
+
+          # Whether invocation records (one per HTTP request) are exported
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :invocation_export_enabled
+
+          sig { params(invocation_export_enabled: T::Boolean).void }
+          attr_writer :invocation_export_enabled
+
+          sig do
+            returns(
+              T.nilable(
+                Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :record_type
+
+          sig do
+            params(
+              record_type:
+                Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType::OrSymbol
+            ).void
+          end
+          attr_writer :record_type
+
+          # Whether runtime logs (function stdout/stderr) are exported
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :runtime_export_enabled
+
+          sig { params(runtime_export_enabled: T::Boolean).void }
+          attr_writer :runtime_export_enabled
+
+          sig { returns(T.nilable(Time)) }
+          attr_reader :updated_at
+
+          sig { params(updated_at: Time).void }
+          attr_writer :updated_at
+
+          # Metadata-only view of a function's log export destination. Header values are
+          # write-only (encrypted server-side) and never appear in any response.
+          sig do
+            params(
+              id: String,
+              created_at: Time,
+              enabled: T::Boolean,
+              endpoint: String,
+              func_id: String,
+              invocation_export_enabled: T::Boolean,
+              record_type:
+                Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType::OrSymbol,
+              runtime_export_enabled: T::Boolean,
+              updated_at: Time
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Configuration record ID
+            id: nil,
+            created_at: nil,
+            # Whether export is enabled for this function
+            enabled: nil,
+            # HTTPS OTLP endpoint URL logs are pushed to
+            endpoint: nil,
+            # Function ID this configuration belongs to
+            func_id: nil,
+            # Whether invocation records (one per HTTP request) are exported
+            invocation_export_enabled: nil,
+            record_type: nil,
+            # Whether runtime logs (function stdout/stderr) are exported
+            runtime_export_enabled: nil,
+            updated_at: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                created_at: Time,
+                enabled: T::Boolean,
+                endpoint: String,
+                func_id: String,
+                invocation_export_enabled: T::Boolean,
+                record_type:
+                  Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType::TaggedSymbol,
+                runtime_export_enabled: T::Boolean,
+                updated_at: Time
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module RecordType
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            COMPUTE_FUNC_LOG_EXPORT_CONFIG =
+              T.let(
+                :compute_func_log_export_config,
+                Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::Compute::Funcs::FuncLogExportConfig::RecordType::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/compute/funcs/func_log_export_config_response.rbi

@@ -18,26 +18,20 @@ module Telnyx
           # Metadata-only view of a function's log export destination. Header values are
           # write-only (encrypted server-side) and never appear in any response.
           sig do
-            returns(
-              T.nilable(
-                Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data
-              )
-            )
+            returns(T.nilable(Telnyx::Compute::Funcs::FuncLogExportConfig))
           end
           attr_reader :data
 
           sig do
             params(
-              data:
-                Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::OrHash
+              data: Telnyx::Compute::Funcs::FuncLogExportConfig::OrHash
             ).void
           end
           attr_writer :data
 
           sig do
             params(
-              data:
-                Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::OrHash
+              data: Telnyx::Compute::Funcs::FuncLogExportConfig::OrHash
             ).returns(T.attached_class)
           end
           def self.new(
@@ -49,177 +43,11 @@ module Telnyx
 
           sig do
             override.returns(
-              {
-                data: Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data
-              }
+              { data: Telnyx::Compute::Funcs::FuncLogExportConfig }
             )
           end
           def to_hash
           end
-
-          class Data < Telnyx::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data,
-                  Telnyx::Internal::AnyHash
-                )
-              end
-
-            # Configuration record ID
-            sig { returns(T.nilable(String)) }
-            attr_reader :id
-
-            sig { params(id: String).void }
-            attr_writer :id
-
-            sig { returns(T.nilable(Time)) }
-            attr_reader :created_at
-
-            sig { params(created_at: Time).void }
-            attr_writer :created_at
-
-            # Whether export is enabled for this function
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :enabled
-
-            sig { params(enabled: T::Boolean).void }
-            attr_writer :enabled
-
-            # HTTPS OTLP endpoint URL logs are pushed to
-            sig { returns(T.nilable(String)) }
-            attr_reader :endpoint
-
-            sig { params(endpoint: String).void }
-            attr_writer :endpoint
-
-            # Function ID this configuration belongs to
-            sig { returns(T.nilable(String)) }
-            attr_reader :func_id
-
-            sig { params(func_id: String).void }
-            attr_writer :func_id
-
-            # Whether invocation records (one per HTTP request) are exported
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :invocation_export_enabled
-
-            sig { params(invocation_export_enabled: T::Boolean).void }
-            attr_writer :invocation_export_enabled
-
-            sig do
-              returns(
-                T.nilable(
-                  Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType::TaggedSymbol
-                )
-              )
-            end
-            attr_reader :record_type
-
-            sig do
-              params(
-                record_type:
-                  Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType::OrSymbol
-              ).void
-            end
-            attr_writer :record_type
-
-            # Whether runtime logs (function stdout/stderr) are exported
-            sig { returns(T.nilable(T::Boolean)) }
-            attr_reader :runtime_export_enabled
-
-            sig { params(runtime_export_enabled: T::Boolean).void }
-            attr_writer :runtime_export_enabled
-
-            sig { returns(T.nilable(Time)) }
-            attr_reader :updated_at
-
-            sig { params(updated_at: Time).void }
-            attr_writer :updated_at
-
-            # Metadata-only view of a function's log export destination. Header values are
-            # write-only (encrypted server-side) and never appear in any response.
-            sig do
-              params(
-                id: String,
-                created_at: Time,
-                enabled: T::Boolean,
-                endpoint: String,
-                func_id: String,
-                invocation_export_enabled: T::Boolean,
-                record_type:
-                  Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType::OrSymbol,
-                runtime_export_enabled: T::Boolean,
-                updated_at: Time
-              ).returns(T.attached_class)
-            end
-            def self.new(
-              # Configuration record ID
-              id: nil,
-              created_at: nil,
-              # Whether export is enabled for this function
-              enabled: nil,
-              # HTTPS OTLP endpoint URL logs are pushed to
-              endpoint: nil,
-              # Function ID this configuration belongs to
-              func_id: nil,
-              # Whether invocation records (one per HTTP request) are exported
-              invocation_export_enabled: nil,
-              record_type: nil,
-              # Whether runtime logs (function stdout/stderr) are exported
-              runtime_export_enabled: nil,
-              updated_at: nil
-            )
-            end
-
-            sig do
-              override.returns(
-                {
-                  id: String,
-                  created_at: Time,
-                  enabled: T::Boolean,
-                  endpoint: String,
-                  func_id: String,
-                  invocation_export_enabled: T::Boolean,
-                  record_type:
-                    Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType::TaggedSymbol,
-                  runtime_export_enabled: T::Boolean,
-                  updated_at: Time
-                }
-              )
-            end
-            def to_hash
-            end
-
-            module RecordType
-              extend Telnyx::Internal::Type::Enum
-
-              TaggedSymbol =
-                T.type_alias do
-                  T.all(
-                    Symbol,
-                    Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType
-                  )
-                end
-              OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-              COMPUTE_FUNC_LOG_EXPORT_CONFIG =
-                T.let(
-                  :compute_func_log_export_config,
-                  Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType::TaggedSymbol
-                )
-
-              sig do
-                override.returns(
-                  T::Array[
-                    Telnyx::Compute::Funcs::FuncLogExportConfigResponse::Data::RecordType::TaggedSymbol
-                  ]
-                )
-              end
-              def self.values
-              end
-            end
-          end
         end
       end
     end

data/rbi/telnyx/models/email_template_common.rbi

@@ -43,13 +43,7 @@ module Telnyx
 
       # 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
+      sig { returns(T.nilable(T::Hash[Symbol, Telnyx::VariableSchemaEntry])) }
       attr_accessor :variable_schema
 
       # Persisted variable names. In `explicit` mode this array preserves the exact
@@ -75,12 +69,7 @@ module Telnyx
           text_body: T.nilable(String),
           updated_at: Time,
           variable_schema:
-            T.nilable(
-              T::Hash[
-                Symbol,
-                Telnyx::EmailTemplateCommon::VariableSchema::OrHash
-              ]
-            ),
+            T.nilable(T::Hash[Symbol, Telnyx::VariableSchemaEntry::OrHash]),
           variables: T::Array[String],
           variables_mode: Telnyx::EmailTemplateCommon::VariablesMode::OrSymbol
         ).returns(T.attached_class)
@@ -127,9 +116,7 @@ module Telnyx
             text_body: T.nilable(String),
             updated_at: Time,
             variable_schema:
-              T.nilable(
-                T::Hash[Symbol, Telnyx::EmailTemplateCommon::VariableSchema]
-              ),
+              T.nilable(T::Hash[Symbol, Telnyx::VariableSchemaEntry]),
             variables: T::Array[String],
             variables_mode:
               Telnyx::EmailTemplateCommon::VariablesMode::TaggedSymbol
@@ -163,46 +150,6 @@ module Telnyx
         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

data/rbi/telnyx/models/email_template_create_params.rbi

@@ -60,13 +60,7 @@ module Telnyx
       # 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
+      sig { returns(T.nilable(T::Hash[Symbol, Telnyx::VariableSchemaEntry])) }
       attr_accessor :variable_schema
 
       # Persisted variable names. In `automatic` mode a non-null array is rejected; in
@@ -111,12 +105,7 @@ module Telnyx
           subject: T.nilable(String),
           text_body: T.nilable(String),
           variable_schema:
-            T.nilable(
-              T::Hash[
-                Symbol,
-                Telnyx::EmailTemplateCreateParams::VariableSchema::OrHash
-              ]
-            ),
+            T.nilable(T::Hash[Symbol, Telnyx::VariableSchemaEntry::OrHash]),
           variables: T.nilable(T::Array[String]),
           variables_mode:
             Telnyx::EmailTemplateCreateParams::VariablesMode::OrSymbol,
@@ -183,12 +172,7 @@ module Telnyx
             subject: T.nilable(String),
             text_body: T.nilable(String),
             variable_schema:
-              T.nilable(
-                T::Hash[
-                  Symbol,
-                  Telnyx::EmailTemplateCreateParams::VariableSchema
-                ]
-              ),
+              T.nilable(T::Hash[Symbol, Telnyx::VariableSchemaEntry]),
             variables: T.nilable(T::Array[String]),
             variables_mode:
               Telnyx::EmailTemplateCreateParams::VariablesMode::OrSymbol,
@@ -200,46 +184,6 @@ module Telnyx
       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

data/rbi/telnyx/models/messaging_outbound_message_payload.rbi

@@ -42,6 +42,12 @@ module Telnyx
       end
       attr_writer :cc
 
+      # Identifies the next chunk when server-side SMS chunking
+      # (`auto_chunk_long_messages` on the messaging profile) split this message. Always
+      # present; null on non-chunked messages and on the final chunk.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :child_message_id
+
       # ISO 8601 formatted date indicating when the message was finalized.
       sig { returns(T.nilable(Time)) }
       attr_accessor :completed_at
@@ -154,6 +160,13 @@ module Telnyx
       sig { params(organization_id: String).void }
       attr_writer :organization_id
 
+      # Identifies the original request's message when server-side SMS chunking
+      # (`auto_chunk_long_messages` on the messaging profile) split it into chunks. The
+      # first chunk's ID is the original request's message ID. Always present; null when
+      # this message is not part of a chunked send.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :parent_message_id
+
       # Number of parts into which the message's body must be split.
       sig { returns(T.nilable(Integer)) }
       attr_reader :parts
@@ -305,6 +318,7 @@ module Telnyx
           id: String,
           body: Telnyx::MessagingOutboundMessagePayload::Body::OrHash,
           cc: T::Array[Telnyx::MessagingOutboundMessagePayload::Cc::OrHash],
+          child_message_id: T.nilable(String),
           completed_at: T.nilable(Time),
           cost:
             T.nilable(Telnyx::MessagingOutboundMessagePayload::Cost::OrHash),
@@ -322,6 +336,7 @@ module Telnyx
           messaging_profile_id: String,
           num_chars: Integer,
           organization_id: String,
+          parent_message_id: T.nilable(String),
           parts: Integer,
           received_at: Time,
           record_type:
@@ -351,6 +366,10 @@ module Telnyx
         # WhatsApp messages contain the `whatsapp_message` object from the send request.
         body: nil,
         cc: nil,
+        # Identifies the next chunk when server-side SMS chunking
+        # (`auto_chunk_long_messages` on the messaging profile) split this message. Always
+        # present; null on non-chunked messages and on the final chunk.
+        child_message_id: nil,
         # ISO 8601 formatted date indicating when the message was finalized.
         completed_at: nil,
         cost: nil,
@@ -372,6 +391,11 @@ module Telnyx
         num_chars: nil,
         # The id of the organization the messaging profile belongs to.
         organization_id: nil,
+        # Identifies the original request's message when server-side SMS chunking
+        # (`auto_chunk_long_messages` on the messaging profile) split it into chunks. The
+        # first chunk's ID is the original request's message ID. Always present; null when
+        # this message is not part of a chunked send.
+        parent_message_id: nil,
         # Number of parts into which the message's body must be split.
         parts: nil,
         # ISO 8601 formatted date indicating when the message request was received.
@@ -429,6 +453,7 @@ module Telnyx
             id: String,
             body: Telnyx::MessagingOutboundMessagePayload::Body,
             cc: T::Array[Telnyx::MessagingOutboundMessagePayload::Cc],
+            child_message_id: T.nilable(String),
             completed_at: T.nilable(Time),
             cost: T.nilable(Telnyx::MessagingOutboundMessagePayload::Cost),
             cost_breakdown:
@@ -442,6 +467,7 @@ module Telnyx
             messaging_profile_id: String,
             num_chars: Integer,
             organization_id: String,
+            parent_message_id: T.nilable(String),
             parts: Integer,
             received_at: Time,
             record_type:

data/rbi/telnyx/models/messaging_profile_features.rbi

@@ -18,24 +18,55 @@ module Telnyx
       sig { params(ai_opt_out_detection_enabled: T::Boolean).void }
       attr_writer :ai_opt_out_detection_enabled
 
+      # Enables server-side chunking of outbound SMS. When enabled, an outbound message
+      # that exceeds the maximum number of segments allowed for its destination (10
+      # segments by default; some aggregators accept up to 25) is automatically split
+      # into multiple child messages, each within the segment limit, and sent
+      # sequentially in order. Splitting is encoding-aware: GSM-7 bodies split at
+      # 153-character boundaries and UCS-2 bodies at 134-byte (67-character) boundaries.
+      # When disabled (the default), messages exceeding the segment limit are rejected
+      # with an error.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :auto_chunk_long_messages
+
+      sig { params(auto_chunk_long_messages: T::Boolean).void }
+      attr_writer :auto_chunk_long_messages
+
       # Telnyx product features the messaging customer can enable on the messaging
       # profile. Keys map to individual feature flags; unknown keys are accepted and
       # preserved for forward compatibility with rolling deployments.
       sig do
-        params(ai_opt_out_detection_enabled: T::Boolean).returns(
-          T.attached_class
-        )
+        params(
+          ai_opt_out_detection_enabled: T::Boolean,
+          auto_chunk_long_messages: T::Boolean
+        ).returns(T.attached_class)
       end
       def self.new(
         # Enables AI detection of inbound opt-out messages that do not follow the standard
         # STOP/UNSTOP/HELP opt-out keyword pattern. When enabled, the messaging platform
         # applies an AI model to identify non-standard opt-out requests (e.g.
         # natural-language phrases) and treats them as opt-outs.
-        ai_opt_out_detection_enabled: nil
+        ai_opt_out_detection_enabled: nil,
+        # Enables server-side chunking of outbound SMS. When enabled, an outbound message
+        # that exceeds the maximum number of segments allowed for its destination (10
+        # segments by default; some aggregators accept up to 25) is automatically split
+        # into multiple child messages, each within the segment limit, and sent
+        # sequentially in order. Splitting is encoding-aware: GSM-7 bodies split at
+        # 153-character boundaries and UCS-2 bodies at 134-byte (67-character) boundaries.
+        # When disabled (the default), messages exceeding the segment limit are rejected
+        # with an error.
+        auto_chunk_long_messages: nil
       )
       end
 
-      sig { override.returns({ ai_opt_out_detection_enabled: T::Boolean }) }
+      sig do
+        override.returns(
+          {
+            ai_opt_out_detection_enabled: T::Boolean,
+            auto_chunk_long_messages: T::Boolean
+          }
+        )
+      end
       def to_hash
       end
     end