telnyx 5.158.0 → 5.159.0

data/rbi/telnyx/models/email_inboxes/messages/label_delete_all_response.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      module Messages
+        class LabelDeleteAllResponse < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::EmailInboxes::Messages::LabelDeleteAllResponse,
+                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
+end

data/rbi/telnyx/models/email_inboxes/messages/label_mutation_request.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      module Messages
+        class LabelMutationRequest < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::EmailInboxes::Messages::LabelMutationRequest,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # One or more labels. Each label is a freeform, case-sensitive string of at most
+          # 255 characters; a message or thread may carry at most 50 labels. The `telnyx:`
+          # prefix is a reserved system namespace and is rejected on customer writes.
+          sig { returns(T::Array[String]) }
+          attr_accessor :labels
+
+          # Labels to add or remove. Both operations are idempotent set operations, so a
+          # retried request converges instead of failing.
+          sig { params(labels: T::Array[String]).returns(T.attached_class) }
+          def self.new(
+            # One or more labels. Each label is a freeform, case-sensitive string of at most
+            # 255 characters; a message or thread may carry at most 50 labels. The `telnyx:`
+            # prefix is a reserved system namespace and is rejected on customer writes.
+            labels:
+          )
+          end
+
+          sig { override.returns({ labels: T::Array[String] }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/messages/reply_email_inbox_message_request.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      module Messages
+        class ReplyEmailInboxMessageRequest < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::EmailInboxes::Messages::ReplyEmailInboxMessageRequest,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # HTML reply body.
+          sig { returns(T.nilable(String)) }
+          attr_reader :html
+
+          sig { params(html: String).void }
+          attr_writer :html
+
+          # Plain-text reply body.
+          sig { returns(T.nilable(String)) }
+          attr_reader :text
+
+          sig { params(text: String).void }
+          attr_writer :text
+
+          # At least one of `text` or `html` must contain a non-whitespace body. Recipients
+          # are derived from the source message; caller-supplied `to`, `cc`, or `bcc` values
+          # are ignored.
+          sig { params(html: String, text: String).returns(T.attached_class) }
+          def self.new(
+            # HTML reply body.
+            html: nil,
+            # Plain-text reply body.
+            text: nil
+          )
+          end
+
+          sig { override.returns({ html: String, text: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/mutate_inbox_filters_request.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class MutateInboxFiltersRequest < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::MutateInboxFiltersRequest,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :entries
+
+        # The list to change.
+        sig do
+          returns(
+            Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::OrSymbol
+          )
+        end
+        attr_accessor :type
+
+        sig do
+          params(
+            entries: T::Array[String],
+            type:
+              Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          entries:,
+          # The list to change.
+          type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              entries: T::Array[String],
+              type:
+                Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The list to change.
+        module Type
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ALLOWLIST =
+            T.let(
+              :allowlist,
+              Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::TaggedSymbol
+            )
+          BLOCKLIST =
+            T.let(
+              :blocklist,
+              Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/thread_list_params.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class ThreadListParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::ThreadListParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :inbox_id
+
+        # Returns only threads carrying this label. Thread labels are independent of the
+        # labels on the thread's messages.
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_label
+
+        sig { params(filter_label: String).void }
+        attr_writer :filter_label
+
+        # 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_label: String,
+            page_after: String,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          inbox_id:,
+          # Returns only threads carrying this label. Thread labels are independent of the
+          # labels on the thread's messages.
+          filter_label: 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_label: String,
+              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/thread_message.rbi

@@ -0,0 +1,318 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class ThreadMessage < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::ThreadMessage,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Array[T::Hash[Symbol, T.anything]]) }
+        attr_accessor :attachments
+
+        sig { returns(T::Array[Telnyx::EmailInboxes::InboundEmailAddress]) }
+        attr_accessor :bcc
+
+        sig { returns(T::Array[Telnyx::EmailInboxes::InboundEmailAddress]) }
+        attr_accessor :cc
+
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        sig do
+          returns(Telnyx::EmailInboxes::ThreadMessage::Direction::TaggedSymbol)
+        end
+        attr_accessor :direction
+
+        sig { returns(Telnyx::EmailInboxes::InboundEmailAddress) }
+        attr_reader :from
+
+        sig do
+          params(from: Telnyx::EmailInboxes::InboundEmailAddress::OrHash).void
+        end
+        attr_writer :from
+
+        # Whether conservative plain-text extraction detected a quoted tail. False does
+        # not prove that the source contains no quoted content.
+        sig { returns(T::Boolean) }
+        attr_accessor :has_quoted_text
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :headers
+
+        # URL for an offloaded HTML body. Null means the body is not offloaded to a URL;
+        # an inline HTML body may still exist but is not returned on list reads. Reply
+        # extraction uses only the plain-text body during ingest.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :html_body_url
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :in_reply_to
+
+        sig { returns(String) }
+        attr_accessor :inbox_id
+
+        sig { returns(T::Array[T::Hash[Symbol, T.anything]]) }
+        attr_accessor :inline_files
+
+        # Mutable message labels used for agent workflow state (for example `spam`,
+        # `needs_review`, `processed`). Distinct from the immutable send-time `tags` on
+        # outbound messages: labels are never propagated to Email Detail Records or
+        # Mission Control reporting. Always empty for outbound messages. Labels on a
+        # message are independent of the labels on its thread.
+        sig { returns(T::Array[String]) }
+        attr_accessor :labels
+
+        # RFC Message-ID header. Null is possible for legacy outbound messages.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :message_id
+
+        # Time the inbound message was marked read. Null means unread.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :read_at
+
+        # Receipt time for inbound messages; null for outbound messages.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :received_at
+
+        sig do
+          returns(Telnyx::EmailInboxes::ThreadMessage::RecordType::TaggedSymbol)
+        end
+        attr_accessor :record_type
+
+        # Ordered RFC Message-ID values from the References header.
+        sig { returns(T::Array[String]) }
+        attr_accessor :references
+
+        # Conservatively extracted new-reply content persisted from the plain-text body
+        # during ingest. Null means no plain-text extraction input was available or
+        # extraction was skipped or failed; HTML bodies are not parsed.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reply_text
+
+        sig { returns(T::Array[Telnyx::EmailInboxes::InboundEmailAddress]) }
+        attr_accessor :reply_to
+
+        # Creation/send-acceptance time for outbound messages; null for inbound messages.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :sent_at
+
+        # Received for inbound messages; the current send status for outbound messages.
+        sig { returns(String) }
+        attr_accessor :status
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :subject
+
+        # URL for an offloaded plain-text body. Null means the body is not offloaded to a
+        # URL; an inline plain-text body may still exist but is not returned on list
+        # reads. `reply_text` and `has_quoted_text` are persisted during ingest before any
+        # body offload.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :text_body_url
+
+        sig { returns(String) }
+        attr_accessor :thread_id
+
+        sig { returns(T::Array[Telnyx::EmailInboxes::InboundEmailAddress]) }
+        attr_accessor :to
+
+        sig { returns(Time) }
+        attr_accessor :updated_at
+
+        sig do
+          params(
+            id: String,
+            attachments: T::Array[T::Hash[Symbol, T.anything]],
+            bcc: T::Array[Telnyx::EmailInboxes::InboundEmailAddress::OrHash],
+            cc: T::Array[Telnyx::EmailInboxes::InboundEmailAddress::OrHash],
+            created_at: Time,
+            direction: Telnyx::EmailInboxes::ThreadMessage::Direction::OrSymbol,
+            from: Telnyx::EmailInboxes::InboundEmailAddress::OrHash,
+            has_quoted_text: T::Boolean,
+            headers: T::Hash[Symbol, T.anything],
+            html_body_url: T.nilable(String),
+            in_reply_to: T.nilable(String),
+            inbox_id: String,
+            inline_files: T::Array[T::Hash[Symbol, T.anything]],
+            labels: T::Array[String],
+            message_id: T.nilable(String),
+            read_at: T.nilable(Time),
+            received_at: T.nilable(Time),
+            record_type:
+              Telnyx::EmailInboxes::ThreadMessage::RecordType::OrSymbol,
+            references: T::Array[String],
+            reply_text: T.nilable(String),
+            reply_to:
+              T::Array[Telnyx::EmailInboxes::InboundEmailAddress::OrHash],
+            sent_at: T.nilable(Time),
+            status: String,
+            subject: T.nilable(String),
+            text_body_url: T.nilable(String),
+            thread_id: String,
+            to: T::Array[Telnyx::EmailInboxes::InboundEmailAddress::OrHash],
+            updated_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          attachments:,
+          bcc:,
+          cc:,
+          created_at:,
+          direction:,
+          from:,
+          # Whether conservative plain-text extraction detected a quoted tail. False does
+          # not prove that the source contains no quoted content.
+          has_quoted_text:,
+          headers:,
+          # URL for an offloaded HTML body. Null means the body is not offloaded to a URL;
+          # an inline HTML body may still exist but is not returned on list reads. Reply
+          # extraction uses only the plain-text body during ingest.
+          html_body_url:,
+          in_reply_to:,
+          inbox_id:,
+          inline_files:,
+          # Mutable message labels used for agent workflow state (for example `spam`,
+          # `needs_review`, `processed`). Distinct from the immutable send-time `tags` on
+          # outbound messages: labels are never propagated to Email Detail Records or
+          # Mission Control reporting. Always empty for outbound messages. Labels on a
+          # message are independent of the labels on its thread.
+          labels:,
+          # RFC Message-ID header. Null is possible for legacy outbound messages.
+          message_id:,
+          # Time the inbound message was marked read. Null means unread.
+          read_at:,
+          # Receipt time for inbound messages; null for outbound messages.
+          received_at:,
+          record_type:,
+          # Ordered RFC Message-ID values from the References header.
+          references:,
+          # Conservatively extracted new-reply content persisted from the plain-text body
+          # during ingest. Null means no plain-text extraction input was available or
+          # extraction was skipped or failed; HTML bodies are not parsed.
+          reply_text:,
+          reply_to:,
+          # Creation/send-acceptance time for outbound messages; null for inbound messages.
+          sent_at:,
+          # Received for inbound messages; the current send status for outbound messages.
+          status:,
+          subject:,
+          # URL for an offloaded plain-text body. Null means the body is not offloaded to a
+          # URL; an inline plain-text body may still exist but is not returned on list
+          # reads. `reply_text` and `has_quoted_text` are persisted during ingest before any
+          # body offload.
+          text_body_url:,
+          thread_id:,
+          to:,
+          updated_at:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              attachments: T::Array[T::Hash[Symbol, T.anything]],
+              bcc: T::Array[Telnyx::EmailInboxes::InboundEmailAddress],
+              cc: T::Array[Telnyx::EmailInboxes::InboundEmailAddress],
+              created_at: Time,
+              direction:
+                Telnyx::EmailInboxes::ThreadMessage::Direction::TaggedSymbol,
+              from: Telnyx::EmailInboxes::InboundEmailAddress,
+              has_quoted_text: T::Boolean,
+              headers: T::Hash[Symbol, T.anything],
+              html_body_url: T.nilable(String),
+              in_reply_to: T.nilable(String),
+              inbox_id: String,
+              inline_files: T::Array[T::Hash[Symbol, T.anything]],
+              labels: T::Array[String],
+              message_id: T.nilable(String),
+              read_at: T.nilable(Time),
+              received_at: T.nilable(Time),
+              record_type:
+                Telnyx::EmailInboxes::ThreadMessage::RecordType::TaggedSymbol,
+              references: T::Array[String],
+              reply_text: T.nilable(String),
+              reply_to: T::Array[Telnyx::EmailInboxes::InboundEmailAddress],
+              sent_at: T.nilable(Time),
+              status: String,
+              subject: T.nilable(String),
+              text_body_url: T.nilable(String),
+              thread_id: String,
+              to: T::Array[Telnyx::EmailInboxes::InboundEmailAddress],
+              updated_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Direction
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::EmailInboxes::ThreadMessage::Direction)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          INBOUND =
+            T.let(
+              :inbound,
+              Telnyx::EmailInboxes::ThreadMessage::Direction::TaggedSymbol
+            )
+          OUTBOUND =
+            T.let(
+              :outbound,
+              Telnyx::EmailInboxes::ThreadMessage::Direction::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::EmailInboxes::ThreadMessage::Direction::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module RecordType
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::EmailInboxes::ThreadMessage::RecordType)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EMAIL_MESSAGE =
+            T.let(
+              :email_message,
+              Telnyx::EmailInboxes::ThreadMessage::RecordType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::EmailInboxes::ThreadMessage::RecordType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/email_inboxes/thread_retrieve_params.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module EmailInboxes
+      class ThreadRetrieveParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::EmailInboxes::ThreadRetrieveParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :inbox_id
+
+        sig { returns(String) }
+        attr_accessor :thread_id
+
+        # Opaque message cursor returned by the previous thread-detail page.
+        sig { returns(T.nilable(String)) }
+        attr_reader :page_after
+
+        sig { params(page_after: String).void }
+        attr_writer :page_after
+
+        # Number of thread messages 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,
+            thread_id: String,
+            page_after: String,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          inbox_id:,
+          thread_id:,
+          # Opaque message cursor returned by the previous thread-detail page.
+          page_after: nil,
+          # Number of thread messages to return. Defaults to 25; maximum is 100.
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              inbox_id: String,
+              thread_id: String,
+              page_after: String,
+              page_size: Integer,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end