telnyx 5.158.0 → 5.159.0

data/rbi/telnyx/models/email_event_retrieve_stats_response.rbi

@@ -0,0 +1,339 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailEventRetrieveStatsResponse < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Telnyx::Models::EmailEventRetrieveStatsResponse,
+            Telnyx::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Telnyx::Models::EmailEventRetrieveStatsResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(
+          data: Telnyx::Models::EmailEventRetrieveStatsResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      sig do
+        params(
+          data: Telnyx::Models::EmailEventRetrieveStatsResponse::Data::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig do
+        override.returns(
+          { data: Telnyx::Models::EmailEventRetrieveStatsResponse::Data }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        # Recipient-level outcome counts for the queried time range. Each to, cc, and bcc
+        # recipient counts separately; repeated events of the same type for the same
+        # message and recipient count once. Partial MTA injection results count successful
+        # recipients as sent and unsuccessful recipients as failed. Only the ten listed
+        # event types are counted; other valid event types (scheduled, cancelled, sandbox,
+        # sending, rejected) are not included in stats.
+        sig do
+          returns(Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Counts)
+        end
+        attr_reader :counts
+
+        sig do
+          params(
+            counts:
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Counts::OrHash
+          ).void
+        end
+        attr_writer :counts
+
+        # Recipient-level event rates as percentages, rounded to 2 decimal places.
+        sig do
+          returns(Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Rates)
+        end
+        attr_reader :rates
+
+        sig do
+          params(
+            rates:
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Rates::OrHash
+          ).void
+        end
+        attr_writer :rates
+
+        sig do
+          returns(
+            Telnyx::Models::EmailEventRetrieveStatsResponse::Data::RecordType::TaggedSymbol
+          )
+        end
+        attr_accessor :record_type
+
+        sig { returns(Telnyx::TimeRange) }
+        attr_reader :time_range
+
+        sig { params(time_range: Telnyx::TimeRange::OrHash).void }
+        attr_writer :time_range
+
+        sig do
+          params(
+            counts:
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Counts::OrHash,
+            rates:
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Rates::OrHash,
+            record_type:
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data::RecordType::OrSymbol,
+            time_range: Telnyx::TimeRange::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Recipient-level outcome counts for the queried time range. Each to, cc, and bcc
+          # recipient counts separately; repeated events of the same type for the same
+          # message and recipient count once. Partial MTA injection results count successful
+          # recipients as sent and unsuccessful recipients as failed. Only the ten listed
+          # event types are counted; other valid event types (scheduled, cancelled, sandbox,
+          # sending, rejected) are not included in stats.
+          counts:,
+          # Recipient-level event rates as percentages, rounded to 2 decimal places.
+          rates:,
+          record_type:,
+          time_range:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              counts:
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Counts,
+              rates:
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Rates,
+              record_type:
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::RecordType::TaggedSymbol,
+              time_range: Telnyx::TimeRange
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Counts < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Counts,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Integer) }
+          attr_accessor :bounced
+
+          sig { returns(Integer) }
+          attr_accessor :clicked
+
+          sig { returns(Integer) }
+          attr_accessor :complained
+
+          sig { returns(Integer) }
+          attr_accessor :deferred
+
+          sig { returns(Integer) }
+          attr_accessor :delivered
+
+          sig { returns(Integer) }
+          attr_accessor :failed
+
+          sig { returns(Integer) }
+          attr_accessor :opened
+
+          sig { returns(Integer) }
+          attr_accessor :queued
+
+          sig { returns(Integer) }
+          attr_accessor :sent
+
+          sig { returns(Integer) }
+          attr_accessor :unsubscribed
+
+          # Recipient-level outcome counts for the queried time range. Each to, cc, and bcc
+          # recipient counts separately; repeated events of the same type for the same
+          # message and recipient count once. Partial MTA injection results count successful
+          # recipients as sent and unsuccessful recipients as failed. Only the ten listed
+          # event types are counted; other valid event types (scheduled, cancelled, sandbox,
+          # sending, rejected) are not included in stats.
+          sig do
+            params(
+              bounced: Integer,
+              clicked: Integer,
+              complained: Integer,
+              deferred: Integer,
+              delivered: Integer,
+              failed: Integer,
+              opened: Integer,
+              queued: Integer,
+              sent: Integer,
+              unsubscribed: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            bounced:,
+            clicked:,
+            complained:,
+            deferred:,
+            delivered:,
+            failed:,
+            opened:,
+            queued:,
+            sent:,
+            unsubscribed:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                bounced: Integer,
+                clicked: Integer,
+                complained: Integer,
+                deferred: Integer,
+                delivered: Integer,
+                failed: Integer,
+                opened: Integer,
+                queued: Integer,
+                sent: Integer,
+                unsubscribed: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class Rates < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::Rates,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Bounced recipients / queued recipients as a percentage.
+          sig { returns(Float) }
+          attr_accessor :bounce_rate
+
+          # Recipients clicked / recipients opened as a percentage.
+          sig { returns(Float) }
+          attr_accessor :click_rate
+
+          # Recipients with a complaint feedback report / delivered recipients as a
+          # percentage.
+          sig { returns(Float) }
+          attr_accessor :complaint_rate
+
+          # Deferred recipients / queued recipients as a percentage.
+          sig { returns(Float) }
+          attr_accessor :deferred_rate
+
+          # Delivered recipients / queued recipients as a percentage.
+          sig { returns(Float) }
+          attr_accessor :delivery_rate
+
+          # Recipients opened / recipients delivered as a percentage.
+          sig { returns(Float) }
+          attr_accessor :open_rate
+
+          # Recipient-level event rates as percentages, rounded to 2 decimal places.
+          sig do
+            params(
+              bounce_rate: Float,
+              click_rate: Float,
+              complaint_rate: Float,
+              deferred_rate: Float,
+              delivery_rate: Float,
+              open_rate: Float
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Bounced recipients / queued recipients as a percentage.
+            bounce_rate:,
+            # Recipients clicked / recipients opened as a percentage.
+            click_rate:,
+            # Recipients with a complaint feedback report / delivered recipients as a
+            # percentage.
+            complaint_rate:,
+            # Deferred recipients / queued recipients as a percentage.
+            deferred_rate:,
+            # Delivered recipients / queued recipients as a percentage.
+            delivery_rate:,
+            # Recipients opened / recipients delivered as a percentage.
+            open_rate:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                bounce_rate: Float,
+                click_rate: Float,
+                complaint_rate: Float,
+                deferred_rate: Float,
+                delivery_rate: Float,
+                open_rate: Float
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        module RecordType
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::RecordType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_EVENT_STATS =
+            T.let(
+              :email_event_stats,
+              Telnyx::Models::EmailEventRetrieveStatsResponse::Data::RecordType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::Models::EmailEventRetrieveStatsResponse::Data::RecordType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_event_type.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailEventType
+      extend Telnyx::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Telnyx::EmailEventType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      QUEUED = T.let(:queued, Telnyx::EmailEventType::TaggedSymbol)
+      DEFERRED = T.let(:deferred, Telnyx::EmailEventType::TaggedSymbol)
+      SCHEDULED = T.let(:scheduled, Telnyx::EmailEventType::TaggedSymbol)
+      CANCELLED = T.let(:cancelled, Telnyx::EmailEventType::TaggedSymbol)
+      SANDBOX = T.let(:sandbox, Telnyx::EmailEventType::TaggedSymbol)
+      SENDING = T.let(:sending, Telnyx::EmailEventType::TaggedSymbol)
+      SENT = T.let(:sent, Telnyx::EmailEventType::TaggedSymbol)
+      FAILED = T.let(:failed, Telnyx::EmailEventType::TaggedSymbol)
+      DELIVERED = T.let(:delivered, Telnyx::EmailEventType::TaggedSymbol)
+      BOUNCED = T.let(:bounced, Telnyx::EmailEventType::TaggedSymbol)
+      COMPLAINED = T.let(:complained, Telnyx::EmailEventType::TaggedSymbol)
+      REJECTED = T.let(:rejected, Telnyx::EmailEventType::TaggedSymbol)
+      OPENED = T.let(:opened, Telnyx::EmailEventType::TaggedSymbol)
+      CLICKED = T.let(:clicked, Telnyx::EmailEventType::TaggedSymbol)
+      UNSUBSCRIBED = T.let(:unsubscribed, Telnyx::EmailEventType::TaggedSymbol)
+      DAILY_LIMIT_EXCEEDED =
+        T.let(:daily_limit_exceeded, Telnyx::EmailEventType::TaggedSymbol)
+
+      sig { override.returns(T::Array[Telnyx::EmailEventType::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inbox.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailInbox < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Telnyx::EmailInbox, Telnyx::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :address
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Domain name used by the inbox address.
+      sig { returns(String) }
+      attr_accessor :domain
+
+      sig { returns(String) }
+      attr_accessor :domain_id
+
+      sig { returns(Telnyx::EmailInbox::RecordType::TaggedSymbol) }
+      attr_accessor :record_type
+
+      sig { returns(T::Hash[Symbol, T.anything]) }
+      attr_accessor :settings
+
+      sig { returns(Telnyx::EmailInbox::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      sig do
+        params(
+          id: String,
+          address: String,
+          created_at: Time,
+          domain: String,
+          domain_id: String,
+          record_type: Telnyx::EmailInbox::RecordType::OrSymbol,
+          settings: T::Hash[Symbol, T.anything],
+          status: Telnyx::EmailInbox::Status::OrSymbol,
+          updated_at: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        address:,
+        created_at:,
+        # Domain name used by the inbox address.
+        domain:,
+        domain_id:,
+        record_type:,
+        settings:,
+        status:,
+        updated_at:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            address: String,
+            created_at: Time,
+            domain: String,
+            domain_id: String,
+            record_type: Telnyx::EmailInbox::RecordType::TaggedSymbol,
+            settings: T::Hash[Symbol, T.anything],
+            status: Telnyx::EmailInbox::Status::TaggedSymbol,
+            updated_at: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module RecordType
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Telnyx::EmailInbox::RecordType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EMAIL_INBOX =
+          T.let(:email_inbox, Telnyx::EmailInbox::RecordType::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Telnyx::EmailInbox::RecordType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Status
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Telnyx::EmailInbox::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE = T.let(:active, Telnyx::EmailInbox::Status::TaggedSymbol)
+        PAUSED = T.let(:paused, Telnyx::EmailInbox::Status::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Telnyx::EmailInbox::Status::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inbox_create_params.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailInboxCreateParams < Telnyx::Internal::Type::BaseModel
+      extend Telnyx::Internal::Type::RequestParameters::Converter
+      include Telnyx::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::EmailInboxCreateParams, Telnyx::Internal::AnyHash)
+        end
+
+      # Account-owned, inbound-enabled domain UUID. The account's shared inbound
+      # subdomain is allocated when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_reader :domain_id
+
+      sig { params(domain_id: String).void }
+      attr_writer :domain_id
+
+      # Inbox local part. Trimmed and lowercased before validation; the normalized value
+      # must be 1-64 characters, start and end with a letter or digit, and contain only
+      # letters, digits, dots, hyphens, and underscores. Generated when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_reader :username
+
+      sig { params(username: String).void }
+      attr_writer :username
+
+      sig do
+        params(
+          domain_id: String,
+          username: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Account-owned, inbound-enabled domain UUID. The account's shared inbound
+        # subdomain is allocated when omitted.
+        domain_id: nil,
+        # Inbox local part. Trimmed and lowercased before validation; the normalized value
+        # must be 1-64 characters, start and end with a letter or digit, and contain only
+        # letters, digits, dots, hyphens, and underscores. Generated when omitted.
+        username: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            domain_id: String,
+            username: String,
+            request_options: Telnyx::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inbox_delete_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailInboxDeleteParams < Telnyx::Internal::Type::BaseModel
+      extend Telnyx::Internal::Type::RequestParameters::Converter
+      include Telnyx::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::EmailInboxDeleteParams, 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

data/rbi/telnyx/models/email_inbox_list_params.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class EmailInboxListParams < Telnyx::Internal::Type::BaseModel
+      extend Telnyx::Internal::Type::RequestParameters::Converter
+      include Telnyx::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Telnyx::EmailInboxListParams, Telnyx::Internal::AnyHash)
+        end
+
+      # Opaque cursor returned by the previous inbox page.
+      sig { returns(T.nilable(String)) }
+      attr_reader :page_cursor
+
+      sig { params(page_cursor: String).void }
+      attr_writer :page_cursor
+
+      # Number of results to return. Defaults to 20; maximum is 250.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page_size
+
+      sig { params(page_size: Integer).void }
+      attr_writer :page_size
+
+      sig do
+        params(
+          page_cursor: String,
+          page_size: Integer,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Opaque cursor returned by the previous inbox page.
+        page_cursor: nil,
+        # Number of results to return. Defaults to 20; maximum is 250.
+        page_size: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            page_cursor: String,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end