telnyx 5.170.0 → 5.173.0

data/rbi/telnyx/models/email/dedicated_ips/action_complete_warmup_params.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      module DedicatedIPs
+        class ActionCompleteWarmupParams < Telnyx::Internal::Type::BaseModel
+          extend Telnyx::Internal::Type::RequestParameters::Converter
+          include Telnyx::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Email::DedicatedIPs::ActionCompleteWarmupParams,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              { id: String, request_options: Telnyx::RequestOptions }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/dedicated_ips/action_pause_warmup_params.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      module DedicatedIPs
+        class ActionPauseWarmupParams < Telnyx::Internal::Type::BaseModel
+          extend Telnyx::Internal::Type::RequestParameters::Converter
+          include Telnyx::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Email::DedicatedIPs::ActionPauseWarmupParams,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              { id: String, request_options: Telnyx::RequestOptions }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/dedicated_ips/action_resume_warmup_params.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      module DedicatedIPs
+        class ActionResumeWarmupParams < Telnyx::Internal::Type::BaseModel
+          extend Telnyx::Internal::Type::RequestParameters::Converter
+          include Telnyx::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Email::DedicatedIPs::ActionResumeWarmupParams,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              { id: String, request_options: Telnyx::RequestOptions }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/dedicated_ips/action_start_warmup_params.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      module DedicatedIPs
+        class ActionStartWarmupParams < Telnyx::Internal::Type::BaseModel
+          extend Telnyx::Internal::Type::RequestParameters::Converter
+          include Telnyx::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Email::DedicatedIPs::ActionStartWarmupParams,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, request_options: {})
+          end
+
+          sig do
+            override.returns(
+              { id: String, request_options: Telnyx::RequestOptions }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool.rbi

@@ -0,0 +1,167 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPool < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::Email::IPPool, Telnyx::Internal::AnyHash)
+          end
+
+        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
+
+        # Email domain this pool is scoped to. The pool carries that domain's mail. Null
+        # when the pool is not domain-scoped.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :domain_id
+
+        # Member IPs with their routing weights. Populated by Retrieve an IP pool; list,
+        # create, and update responses return an empty array.
+        sig { returns(T.nilable(T::Array[Telnyx::Email::IPPool::IP])) }
+        attr_reader :ips
+
+        sig { params(ips: T::Array[Telnyx::Email::IPPool::IP::OrHash]).void }
+        attr_writer :ips
+
+        # Whether this is the account's default pool. The default pool carries mail for
+        # sending domains that have no domain-scoped pool. At most one per account.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_default
+
+        sig { params(is_default: T::Boolean).void }
+        attr_writer :is_default
+
+        # Pool name, unique within the account.
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        sig do
+          returns(T.nilable(Telnyx::Email::IPPool::RecordType::TaggedSymbol))
+        end
+        attr_reader :record_type
+
+        sig do
+          params(record_type: Telnyx::Email::IPPool::RecordType::OrSymbol).void
+        end
+        attr_writer :record_type
+
+        sig { returns(T.nilable(Time)) }
+        attr_reader :updated_at
+
+        sig { params(updated_at: Time).void }
+        attr_writer :updated_at
+
+        # An account-scoped pool of dedicated IPs. Mail uses a pool only when the pool is
+        # scoped to the sending domain (`domain_id`) or is the account default
+        # (`is_default`).
+        sig do
+          params(
+            id: String,
+            created_at: Time,
+            domain_id: T.nilable(String),
+            ips: T::Array[Telnyx::Email::IPPool::IP::OrHash],
+            is_default: T::Boolean,
+            name: String,
+            record_type: Telnyx::Email::IPPool::RecordType::OrSymbol,
+            updated_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id: nil,
+          created_at: nil,
+          # Email domain this pool is scoped to. The pool carries that domain's mail. Null
+          # when the pool is not domain-scoped.
+          domain_id: nil,
+          # Member IPs with their routing weights. Populated by Retrieve an IP pool; list,
+          # create, and update responses return an empty array.
+          ips: nil,
+          # Whether this is the account's default pool. The default pool carries mail for
+          # sending domains that have no domain-scoped pool. At most one per account.
+          is_default: nil,
+          # Pool name, unique within the account.
+          name: nil,
+          record_type: nil,
+          updated_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Time,
+              domain_id: T.nilable(String),
+              ips: T::Array[Telnyx::Email::IPPool::IP],
+              is_default: T::Boolean,
+              name: String,
+              record_type: Telnyx::Email::IPPool::RecordType::TaggedSymbol,
+              updated_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class IP < Telnyx::Models::Email::DedicatedIP
+          OrHash =
+            T.type_alias do
+              T.any(Telnyx::Email::IPPool::IP, Telnyx::Internal::AnyHash)
+            end
+
+          # Relative routing weight of this IP within the pool.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :weight
+
+          sig { params(weight: Integer).void }
+          attr_writer :weight
+
+          # A dedicated IP as a member of a pool, with its routing weight in this pool.
+          # Weight is a positive integer (default 100).
+          sig { params(weight: Integer).returns(T.attached_class) }
+          def self.new(
+            # Relative routing weight of this IP within the pool.
+            weight: nil
+          )
+          end
+
+          sig { override.returns({ weight: Integer }) }
+          def to_hash
+          end
+        end
+
+        module RecordType
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Telnyx::Email::IPPool::RecordType) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          IP_POOL =
+            T.let(:ip_pool, Telnyx::Email::IPPool::RecordType::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Telnyx::Email::IPPool::RecordType::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool_create_params.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPoolCreateParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::Email::IPPoolCreateParams, Telnyx::Internal::AnyHash)
+          end
+
+        # Pool name: 1-64 characters of lowercase letters, digits, `.`, `_`, and `-`,
+        # starting and ending with a letter or digit. Must be unique within the account
+        # and must not start with `dip_`.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Scope the pool to one of the account's email domains; the pool then carries that
+        # domain's mail. Scope at most one pool to each domain.
+        sig { returns(T.nilable(String)) }
+        attr_reader :domain_id
+
+        sig { params(domain_id: String).void }
+        attr_writer :domain_id
+
+        # Make this the account's default pool, which carries mail for sending domains
+        # without a domain-scoped pool. An account can have one default pool. Defaults to
+        # `false`.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :is_default
+
+        sig { params(is_default: T::Boolean).void }
+        attr_writer :is_default
+
+        sig do
+          params(
+            name: String,
+            domain_id: String,
+            is_default: T::Boolean,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Pool name: 1-64 characters of lowercase letters, digits, `.`, `_`, and `-`,
+          # starting and ending with a letter or digit. Must be unique within the account
+          # and must not start with `dip_`.
+          name:,
+          # Scope the pool to one of the account's email domains; the pool then carries that
+          # domain's mail. Scope at most one pool to each domain.
+          domain_id: nil,
+          # Make this the account's default pool, which carries mail for sending domains
+          # without a domain-scoped pool. An account can have one default pool. Defaults to
+          # `false`.
+          is_default: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              domain_id: String,
+              is_default: T::Boolean,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool_delete_params.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPoolDeleteParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::Email::IPPoolDeleteParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Set together with `force=true` to delete a pool that still has IPs. Acknowledges
+        # deletion while the pool still has members; this flag does not reroute already
+        # queued messages.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :drain
+
+        sig { params(drain: T::Boolean).void }
+        attr_writer :drain
+
+        # Set together with `drain=true` to delete a pool that still has IPs. Either flag
+        # alone has no effect.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :force
+
+        sig { params(force: T::Boolean).void }
+        attr_writer :force
+
+        sig do
+          params(
+            id: String,
+            drain: T::Boolean,
+            force: T::Boolean,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          # Set together with `force=true` to delete a pool that still has IPs. Acknowledges
+          # deletion while the pool still has members; this flag does not reroute already
+          # queued messages.
+          drain: nil,
+          # Set together with `drain=true` to delete a pool that still has IPs. Either flag
+          # alone has no effect.
+          force: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              drain: T::Boolean,
+              force: T::Boolean,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool_list_params.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPoolListParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::Email::IPPoolListParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig do
+          params(request_options: Telnyx::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
+        end
+
+        sig { override.returns({ request_options: Telnyx::RequestOptions }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool_list_response.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPoolListResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::Email::IPPoolListResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Array[Telnyx::Email::IPPool]) }
+        attr_accessor :data
+
+        sig do
+          params(data: T::Array[Telnyx::Email::IPPool::OrHash]).returns(
+            T.attached_class
+          )
+        end
+        def self.new(data:)
+        end
+
+        sig { override.returns({ data: T::Array[Telnyx::Email::IPPool] }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool_retrieve_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPoolRetrieveParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Email::IPPoolRetrieveParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          params(
+            id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { id: String, request_options: Telnyx::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email/ip_pool_show_response.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Email
+      class IPPoolShowResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::Email::IPPoolShowResponse, Telnyx::Internal::AnyHash)
+          end
+
+        # An account-scoped pool of dedicated IPs. Mail uses a pool only when the pool is
+        # scoped to the sending domain (`domain_id`) or is the account default
+        # (`is_default`).
+        sig { returns(Telnyx::Email::IPPool) }
+        attr_reader :data
+
+        sig { params(data: Telnyx::Email::IPPool::OrHash).void }
+        attr_writer :data
+
+        sig do
+          params(data: Telnyx::Email::IPPool::OrHash).returns(T.attached_class)
+        end
+        def self.new(
+          # An account-scoped pool of dedicated IPs. Mail uses a pool only when the pool is
+          # scoped to the sending domain (`domain_id`) or is the account default
+          # (`is_default`).
+          data:
+        )
+        end
+
+        sig { override.returns({ data: Telnyx::Email::IPPool }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end