telnyx 5.158.0 → 5.159.0

data/rbi/telnyx/models/email_inboxes/inbound_thread.rbi

@@ -0,0 +1,146 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class InboundThread < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::InboundThread,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        sig { returns(String) }
+        attr_accessor :inbox_id
+
+        # Mutable thread labels used for agent workflow state. Independent of the labels
+        # on the thread's messages, and distinct from the send-time `tags` on outbound
+        # messages.
+        sig { returns(T::Array[String]) }
+        attr_accessor :labels
+
+        sig { returns(Time) }
+        attr_accessor :last_message_at
+
+        sig { returns(String) }
+        attr_accessor :last_message_id
+
+        # Total inbound and outbound messages in the thread.
+        sig { returns(Integer) }
+        attr_accessor :message_count
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :preview
+
+        sig do
+          returns(Telnyx::EmailInboxes::InboundThread::RecordType::TaggedSymbol)
+        end
+        attr_accessor :record_type
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :subject
+
+        # Unread inbound messages; outbound messages never increment this count.
+        sig { returns(Integer) }
+        attr_accessor :unread_count
+
+        sig { returns(Time) }
+        attr_accessor :updated_at
+
+        sig do
+          params(
+            id: String,
+            created_at: Time,
+            inbox_id: String,
+            labels: T::Array[String],
+            last_message_at: Time,
+            last_message_id: String,
+            message_count: Integer,
+            preview: T.nilable(String),
+            record_type:
+              Telnyx::EmailInboxes::InboundThread::RecordType::OrSymbol,
+            subject: T.nilable(String),
+            unread_count: Integer,
+            updated_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          created_at:,
+          inbox_id:,
+          # Mutable thread labels used for agent workflow state. Independent of the labels
+          # on the thread's messages, and distinct from the send-time `tags` on outbound
+          # messages.
+          labels:,
+          last_message_at:,
+          last_message_id:,
+          # Total inbound and outbound messages in the thread.
+          message_count:,
+          preview:,
+          record_type:,
+          subject:,
+          # Unread inbound messages; outbound messages never increment this count.
+          unread_count:,
+          updated_at:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Time,
+              inbox_id: String,
+              labels: T::Array[String],
+              last_message_at: Time,
+              last_message_id: String,
+              message_count: Integer,
+              preview: T.nilable(String),
+              record_type:
+                Telnyx::EmailInboxes::InboundThread::RecordType::TaggedSymbol,
+              subject: T.nilable(String),
+              unread_count: Integer,
+              updated_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module RecordType
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::EmailInboxes::InboundThread::RecordType)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_THREAD =
+            T.let(
+              :email_thread,
+              Telnyx::EmailInboxes::InboundThread::RecordType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::EmailInboxes::InboundThread::RecordType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/inbound_thread_detail.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class InboundThreadDetail < Telnyx::Models::EmailInboxes::InboundThread
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::InboundThreadDetail,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Array[Telnyx::EmailInboxes::ThreadMessage]) }
+        attr_accessor :messages
+
+        sig do
+          params(
+            messages: T::Array[Telnyx::EmailInboxes::ThreadMessage::OrHash]
+          ).returns(T.attached_class)
+        end
+        def self.new(messages:)
+        end
+
+        sig do
+          override.returns(
+            { messages: T::Array[Telnyx::EmailInboxes::ThreadMessage] }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/inbound_thread_list_response.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class InboundThreadListResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::InboundThreadListResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Array[Telnyx::EmailInboxes::InboundThread]) }
+        attr_accessor :data
+
+        sig { returns(Telnyx::EmailInboxes::EmailPaginationMeta) }
+        attr_reader :meta
+
+        sig do
+          params(meta: Telnyx::EmailInboxes::EmailPaginationMeta::OrHash).void
+        end
+        attr_writer :meta
+
+        sig do
+          params(
+            data: T::Array[Telnyx::EmailInboxes::InboundThread::OrHash],
+            meta: Telnyx::EmailInboxes::EmailPaginationMeta::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(data:, meta:)
+        end
+
+        sig do
+          override.returns(
+            {
+              data: T::Array[Telnyx::EmailInboxes::InboundThread],
+              meta: Telnyx::EmailInboxes::EmailPaginationMeta
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/message_drafts_params.rbi

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

data/rbi/telnyx/models/email_inboxes/message_list_params.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class MessageListParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::MessageListParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :inbox_id
+
+        # Case-insensitive literal substring of the sender address.
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_from
+
+        sig { params(filter_from: String).void }
+        attr_writer :filter_from
+
+        # Returns only messages carrying this label. Matching is exact and case-sensitive.
+        # Reserved `telnyx:` labels can be filtered on even though they cannot be written
+        # by customers.
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_label
+
+        sig { params(filter_label: String).void }
+        attr_writer :filter_label
+
+        # Whether the message has a read timestamp.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :filter_read
+
+        sig { params(filter_read: T::Boolean).void }
+        attr_writer :filter_read
+
+        # Inclusive ISO 8601 lower bound for the received timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :filter_received_after
+
+        sig { params(filter_received_after: Time).void }
+        attr_writer :filter_received_after
+
+        # Inclusive ISO 8601 upper bound for the received timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :filter_received_before
+
+        sig { params(filter_received_before: Time).void }
+        attr_writer :filter_received_before
+
+        # Full-text query over subject and body, up to 500 characters.
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_search
+
+        sig { params(filter_search: String).void }
+        attr_writer :filter_search
+
+        # Case-insensitive literal substring of the subject.
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_subject
+
+        sig { params(filter_subject: String).void }
+        attr_writer :filter_subject
+
+        # Whether the message has no read timestamp. Set to `true` to return only unread
+        # messages.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :filter_unread
+
+        sig { params(filter_unread: T::Boolean).void }
+        attr_writer :filter_unread
+
+        # Opaque cursor returned by the previous page.
+        sig { returns(T.nilable(String)) }
+        attr_reader :page_after
+
+        sig { params(page_after: String).void }
+        attr_writer :page_after
+
+        # Number of results to return. Defaults to 25; maximum is 100.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        sig do
+          params(
+            inbox_id: String,
+            filter_from: String,
+            filter_label: String,
+            filter_read: T::Boolean,
+            filter_received_after: Time,
+            filter_received_before: Time,
+            filter_search: String,
+            filter_subject: String,
+            filter_unread: T::Boolean,
+            page_after: String,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          inbox_id:,
+          # Case-insensitive literal substring of the sender address.
+          filter_from: nil,
+          # Returns only messages carrying this label. Matching is exact and case-sensitive.
+          # Reserved `telnyx:` labels can be filtered on even though they cannot be written
+          # by customers.
+          filter_label: nil,
+          # Whether the message has a read timestamp.
+          filter_read: nil,
+          # Inclusive ISO 8601 lower bound for the received timestamp.
+          filter_received_after: nil,
+          # Inclusive ISO 8601 upper bound for the received timestamp.
+          filter_received_before: nil,
+          # Full-text query over subject and body, up to 500 characters.
+          filter_search: nil,
+          # Case-insensitive literal substring of the subject.
+          filter_subject: nil,
+          # Whether the message has no read timestamp. Set to `true` to return only unread
+          # messages.
+          filter_unread: nil,
+          # Opaque cursor returned by the previous page.
+          page_after: nil,
+          # Number of results to return. Defaults to 25; maximum is 100.
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              inbox_id: String,
+              filter_from: String,
+              filter_label: String,
+              filter_read: T::Boolean,
+              filter_received_after: Time,
+              filter_received_before: Time,
+              filter_search: String,
+              filter_subject: String,
+              filter_unread: T::Boolean,
+              page_after: String,
+              page_size: Integer,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/message_list_response.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class MessageListResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::EmailInboxes::MessageListResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Array[Telnyx::InboundMessage]) }
+        attr_accessor :data
+
+        sig { returns(Telnyx::EmailInboxes::EmailPaginationMeta) }
+        attr_reader :meta
+
+        sig do
+          params(meta: Telnyx::EmailInboxes::EmailPaginationMeta::OrHash).void
+        end
+        attr_writer :meta
+
+        sig do
+          params(
+            data: T::Array[Telnyx::InboundMessage::OrHash],
+            meta: Telnyx::EmailInboxes::EmailPaginationMeta::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(data:, meta:)
+        end
+
+        sig do
+          override.returns(
+            {
+              data: T::Array[Telnyx::InboundMessage],
+              meta: Telnyx::EmailInboxes::EmailPaginationMeta
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/message_update_params.rbi

@@ -0,0 +1,124 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class MessageUpdateParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::MessageUpdateParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :inbox_id
+
+        sig { returns(String) }
+        attr_accessor :message_id
+
+        # Set to `true` for server time, an ISO 8601 timestamp for an explicit read time,
+        # or `null` to mark unread.
+        sig do
+          returns(
+            T.nilable(
+              T.any(
+                Telnyx::EmailInboxes::MessageUpdateParams::ReadAt::OrBoolean,
+                Time
+              )
+            )
+          )
+        end
+        attr_accessor :read_at
+
+        sig do
+          params(
+            inbox_id: String,
+            message_id: String,
+            read_at:
+              T.nilable(
+                T.any(
+                  Telnyx::EmailInboxes::MessageUpdateParams::ReadAt::OrBoolean,
+                  Time
+                )
+              ),
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          inbox_id:,
+          message_id:,
+          # Set to `true` for server time, an ISO 8601 timestamp for an explicit read time,
+          # or `null` to mark unread.
+          read_at:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              inbox_id: String,
+              message_id: String,
+              read_at:
+                T.nilable(
+                  T.any(
+                    Telnyx::EmailInboxes::MessageUpdateParams::ReadAt::OrBoolean,
+                    Time
+                  )
+                ),
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Set to `true` for server time, an ISO 8601 timestamp for an explicit read time,
+        # or `null` to mark unread.
+        module ReadAt
+          extend Telnyx::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.nilable(
+                T.any(
+                  Telnyx::EmailInboxes::MessageUpdateParams::ReadAt::TaggedBoolean,
+                  Time
+                )
+              )
+            end
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::EmailInboxes::MessageUpdateParams::ReadAt::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+
+          TaggedBoolean =
+            T.type_alias do
+              T.all(
+                T::Boolean,
+                Telnyx::EmailInboxes::MessageUpdateParams::ReadAt
+              )
+            end
+          OrBoolean = T.type_alias { T::Boolean }
+
+          TRUE =
+            T.let(
+              true,
+              Telnyx::EmailInboxes::MessageUpdateParams::ReadAt::TaggedBoolean
+            )
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/message_update_response.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class MessageUpdateResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::EmailInboxes::MessageUpdateResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Telnyx::InboundMessage) }
+        attr_reader :data
+
+        sig { params(data: Telnyx::InboundMessage::OrHash).void }
+        attr_writer :data
+
+        sig do
+          params(data: Telnyx::InboundMessage::OrHash).returns(T.attached_class)
+        end
+        def self.new(data:)
+        end
+
+        sig { override.returns({ data: Telnyx::InboundMessage }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end