telnyx 5.158.0 → 5.159.0

data/rbi/telnyx/resources/email_events.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Retrieve account-level email events and event statistics.
+    class EmailEvents
+      # Lists account-level email events sorted oldest first by
+      # `occurred_at asc, id asc`.
+      sig do
+        params(
+          email_id: String,
+          event_type: Telnyx::EmailEventListParams::EventType::Variants,
+          from: Time,
+          page_cursor: String,
+          page_size: Integer,
+          to: Time,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::EmailEventListResponse)
+      end
+      def list(
+        # Filter events for a specific email message UUID. Invalid UUID values are
+        # silently ignored (no filter applied).
+        email_id: nil,
+        # Comma-separated list of event types to include. Also accepts repeated query
+        # parameters (e.g. event_type=delivered&event_type=bounced). Unknown values return
+        # no matches.
+        event_type: nil,
+        # Inclusive ISO 8601 start timestamp. Defaults to 30 days ago when omitted.
+        from: nil,
+        # Opaque URL-safe Base64 cursor returned by a previous list response.
+        page_cursor: nil,
+        # Number of results to return. Defaults to 25; maximum is 100. Invalid values are
+        # clamped to the valid range.
+        page_size: nil,
+        # Inclusive ISO 8601 end timestamp. When `from` is provided without `to`, defaults
+        # to `from + 30 days`.
+        to: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns counts and rates for email events over a time range. The default start
+      # time is 30 days ago.
+      sig do
+        params(
+          from: Time,
+          to: Time,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::EmailEventRetrieveStatsResponse)
+      end
+      def retrieve_stats(
+        # Inclusive ISO 8601 start timestamp. Defaults to 30 days ago when omitted.
+        from: nil,
+        # Inclusive ISO 8601 end timestamp. When `from` is provided without `to`, defaults
+        # to `from + 30 days`.
+        to: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/email_inboxes/drafts.rbi

@@ -0,0 +1,319 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class EmailInboxes
+      # Create, list, retrieve, update, delete, and send unsent draft messages belonging
+      # to an agent inbox.
+      class Drafts
+        # Creates an unsent draft in the inbox. Every field is optional — a draft is a
+        # work-in-progress and may be saved incomplete. Send-time requirements (sender,
+        # subject, at least one recipient) are enforced when the draft is sent, not when
+        # it is created.
+        #
+        # Drafts are unbillable and emit no Email Detail Records until they are sent.
+        sig do
+          params(
+            inbox_id: String,
+            attachments: T::Array[T.anything],
+            bcc:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            cc:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            from_email: String,
+            from_name: String,
+            headers: T::Hash[Symbol, String],
+            html: String,
+            html_body: String,
+            labels: T::Array[String],
+            metadata: T.anything,
+            reply_to: String,
+            subject: String,
+            tags: T::Array[String],
+            text: String,
+            text_body: String,
+            to:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::EmailInboxes::EmailDraftResponse)
+        end
+        def create(
+          # Email inbox UUID.
+          inbox_id,
+          attachments: nil,
+          bcc: nil,
+          cc: nil,
+          from_email: nil,
+          from_name: nil,
+          headers: nil,
+          # Alias for `html_body`, matching the send endpoint.
+          html: nil,
+          html_body: nil,
+          labels: nil,
+          metadata: nil,
+          reply_to: nil,
+          subject: nil,
+          tags: nil,
+          # Alias for `text_body`, matching the send endpoint.
+          text: nil,
+          text_body: nil,
+          to: nil,
+          request_options: {}
+        )
+        end
+
+        # Returns a single draft. Drafts that have been sent remain retrievable, so the
+        # exact content that was sent stays auditable.
+        sig do
+          params(
+            draft_id: String,
+            inbox_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::EmailInboxes::EmailDraftResponse)
+        end
+        def retrieve(
+          # Email draft UUID.
+          draft_id,
+          # Email inbox UUID.
+          inbox_id:,
+          request_options: {}
+        )
+        end
+
+        # Updates the supplied fields on a draft. `account_id` and `inbox_id` are
+        # server-owned and ignored if present in the body, so a draft can never be moved
+        # between accounts or inboxes.
+        #
+        # A draft that is being sent or has already been sent is immutable and returns 422
+        # — modifying it would race with delivery or rewrite the record of what was
+        # actually sent.
+        sig do
+          params(
+            draft_id: String,
+            inbox_id: String,
+            attachments: T::Array[T.anything],
+            bcc:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            cc:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            from_email: String,
+            from_name: String,
+            headers: T::Hash[Symbol, String],
+            html: String,
+            html_body: String,
+            labels: T::Array[String],
+            metadata: T.anything,
+            reply_to: String,
+            subject: String,
+            tags: T::Array[String],
+            text: String,
+            text_body: String,
+            to:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::EmailInboxes::EmailDraftResponse)
+        end
+        def update(
+          # Path param: Email draft UUID.
+          draft_id,
+          # Path param: Email inbox UUID.
+          inbox_id:,
+          # Body param
+          attachments: nil,
+          # Body param
+          bcc: nil,
+          # Body param
+          cc: nil,
+          # Body param
+          from_email: nil,
+          # Body param
+          from_name: nil,
+          # Body param
+          headers: nil,
+          # Body param: Alias for `html_body`, matching the send endpoint.
+          html: nil,
+          # Body param
+          html_body: nil,
+          # Body param
+          labels: nil,
+          # Body param
+          metadata: nil,
+          # Body param
+          reply_to: nil,
+          # Body param
+          subject: nil,
+          # Body param
+          tags: nil,
+          # Body param: Alias for `text_body`, matching the send endpoint.
+          text: nil,
+          # Body param
+          text_body: nil,
+          # Body param
+          to: nil,
+          request_options: {}
+        )
+        end
+
+        # Lists drafts newest first using stable cursor pagination. All access is scoped
+        # to the authenticated account and the given inbox.
+        sig do
+          params(
+            inbox_id: String,
+            filter_status:
+              Telnyx::EmailInboxes::DraftListParams::FilterStatus::OrSymbol,
+            page_after: String,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::EmailInboxes::DraftListResponse)
+        end
+        def list(
+          # Email inbox UUID.
+          inbox_id,
+          # Restrict results to drafts in this state.
+          filter_status: 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
+
+        # Permanently deletes an unsent draft. Drafts that are being sent or have been
+        # sent cannot be deleted; sent drafts are retained for audit.
+        sig do
+          params(
+            draft_id: String,
+            inbox_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).void
+        end
+        def delete(
+          # Email draft UUID.
+          draft_id,
+          # Email inbox UUID.
+          inbox_id:,
+          request_options: {}
+        )
+        end
+
+        # Identical to `PUT`; both apply a partial update to the supplied fields.
+        sig do
+          params(
+            draft_id: String,
+            inbox_id: String,
+            attachments: T::Array[T.anything],
+            bcc:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            cc:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            from_email: String,
+            from_name: String,
+            headers: T::Hash[Symbol, String],
+            html: String,
+            html_body: String,
+            labels: T::Array[String],
+            metadata: T.anything,
+            reply_to: String,
+            subject: String,
+            tags: T::Array[String],
+            text: String,
+            text_body: String,
+            to:
+              T::Array[
+                T.any(String, Telnyx::EmailInboxes::EmailAddress::OrHash)
+              ],
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::EmailInboxes::EmailDraftResponse)
+        end
+        def patch(
+          # Path param: Email draft UUID.
+          draft_id,
+          # Path param: Email inbox UUID.
+          inbox_id:,
+          # Body param
+          attachments: nil,
+          # Body param
+          bcc: nil,
+          # Body param
+          cc: nil,
+          # Body param
+          from_email: nil,
+          # Body param
+          from_name: nil,
+          # Body param
+          headers: nil,
+          # Body param: Alias for `html_body`, matching the send endpoint.
+          html: nil,
+          # Body param
+          html_body: nil,
+          # Body param
+          labels: nil,
+          # Body param
+          metadata: nil,
+          # Body param
+          reply_to: nil,
+          # Body param
+          subject: nil,
+          # Body param
+          tags: nil,
+          # Body param: Alias for `text_body`, matching the send endpoint.
+          text: nil,
+          # Body param
+          text_body: nil,
+          # Body param
+          to: nil,
+          request_options: {}
+        )
+        end
+
+        # Sends the draft through the standard send pipeline — the same domain resolution,
+        # suppression, reputation, daily-quota, persistence and Detail Record behaviour as
+        # `POST /v2/email_messages`. The response body is the created email message.
+        #
+        # If the draft has no explicit `from_email`, the inbox address is used.
+        #
+        # The draft is marked `sent` only after the send is accepted; a send rejected for
+        # suppression, quota or reputation leaves the draft editable so it can be fixed
+        # and retried. A draft that is already `sent` returns 422 rather than sending
+        # twice.
+        sig do
+          params(
+            draft_id: String,
+            inbox_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::EmailInboxes::EmailMessageResponse)
+        end
+        def send_(
+          # Email draft UUID.
+          draft_id,
+          # Email inbox UUID.
+          inbox_id:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/email_inboxes/filters.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class EmailInboxes
+      # Create and manage agent inboxes, retrieve inbound messages and threads, and
+      # reply to or forward messages.
+      class Filters
+        # Returns the inbox's sender allowlist and blocklist. Entries are normalized to
+        # lowercase. A blocklist match takes precedence over an allowlist match; when both
+        # lists are empty, all senders are accepted.
+        sig do
+          params(
+            inbox_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::EmailInboxes::FilterListResponse)
+        end
+        def list(
+          # Email inbox UUID.
+          inbox_id,
+          request_options: {}
+        )
+        end
+
+        # Adds entries to either the allowlist or blocklist. The operation is an
+        # idempotent set union: entries already present remain unchanged.
+        sig do
+          params(
+            inbox_id: String,
+            entries: T::Array[String],
+            type:
+              Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::OrSymbol,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::EmailInboxes::FilterAddResponse)
+        end
+        def add(
+          # Email inbox UUID.
+          inbox_id,
+          entries:,
+          # The list to change.
+          type:,
+          request_options: {}
+        )
+        end
+
+        # Removes entries from either the allowlist or blocklist. The operation is
+        # idempotent: removing an entry that is not present still returns the current
+        # filter lists.
+        sig do
+          params(
+            inbox_id: String,
+            entries: T::Array[String],
+            type:
+              Telnyx::EmailInboxes::MutateInboxFiltersRequest::Type::OrSymbol,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::EmailInboxes::FilterDeleteAllResponse)
+        end
+        def delete_all(
+          # Email inbox UUID.
+          inbox_id,
+          entries:,
+          # The list to change.
+          type:,
+          request_options: {}
+        )
+        end
+
+        # Replaces both sender filter lists atomically. Omitting either list clears that
+        # list. Use `POST` or `DELETE` for incremental changes.
+        sig do
+          params(
+            inbox_id: String,
+            allowlist: T::Array[String],
+            blocklist: T::Array[String],
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::EmailInboxes::FilterReplaceResponse)
+        end
+        def replace(
+          # Email inbox UUID.
+          inbox_id,
+          allowlist: nil,
+          blocklist: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/email_inboxes/messages/actions.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class EmailInboxes
+      class Messages
+        # Create and manage agent inboxes, retrieve inbound messages and threads, and
+        # reply to or forward messages.
+        class Actions
+          # Sends from the inbox address through the standard email send pipeline to
+          # caller-supplied To, Cc, and Bcc recipients. `to` must contain at least one
+          # recipient. Optional `text` and `html` are prepended to a forwarded-message block
+          # containing the original metadata and available body content. The subject is
+          # prefixed with `Fwd:` unless it already has that prefix.
+          #
+          # Threading headers are derived from the original message: `In-Reply-To` is set to
+          # its RFC Message-ID, and `References` contains the original References values
+          # plus that Message-ID, de-duplicated and limited to the most recent 20 values.
+          sig do
+            params(
+              message_id: String,
+              inbox_id: String,
+              to:
+                T.any(
+                  String,
+                  Telnyx::EmailInboxes::Messages::ActionForwardParams::To::UnionMember1::OrHash,
+                  T::Array[
+                    T.any(
+                      String,
+                      Telnyx::EmailInboxes::Messages::InboxActionEmailAddressInput::UnionMember1::OrHash
+                    )
+                  ]
+                ),
+              bcc:
+                T.any(
+                  String,
+                  Telnyx::EmailInboxes::Messages::InboxActionRecipientInput::UnionMember1::OrHash,
+                  T::Array[
+                    T.any(
+                      String,
+                      Telnyx::EmailInboxes::Messages::InboxActionEmailAddressInput::UnionMember1::OrHash
+                    )
+                  ]
+                ),
+              cc:
+                T.any(
+                  String,
+                  Telnyx::EmailInboxes::Messages::InboxActionRecipientInput::UnionMember1::OrHash,
+                  T::Array[
+                    T.any(
+                      String,
+                      Telnyx::EmailInboxes::Messages::InboxActionEmailAddressInput::UnionMember1::OrHash
+                    )
+                  ]
+                ),
+              html: String,
+              text: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::EmailInboxes::EmailMessageResponse)
+          end
+          def forward(
+            # Path param: Inbound email message UUID.
+            message_id,
+            # Path param: Email inbox UUID.
+            inbox_id:,
+            # Body param: One recipient or a non-empty recipient array. Each recipient may be
+            # an email string or an object with `email` and optional `name`.
+            to:,
+            # Body param: One recipient or a recipient array. Each recipient may be an email
+            # string or an object with `email` and optional `name`.
+            bcc: nil,
+            # Body param: One recipient or a recipient array. Each recipient may be an email
+            # string or an object with `email` and optional `name`.
+            cc: nil,
+            # Body param: Optional HTML note prepended to the generated forwarded-message
+            # block. Blank values are treated as omitted.
+            html: nil,
+            # Body param: Optional plain-text note prepended to the generated
+            # forwarded-message block. Blank values are treated as omitted.
+            text: nil,
+            request_options: {}
+          )
+          end
+
+          # Sends from the inbox address through the standard email send pipeline. The
+          # recipient is the original `Reply-To`, falling back to `From`; original Cc
+          # recipients are not included. The subject is prefixed with `Re:` unless it
+          # already has that prefix.
+          #
+          # Threading headers are derived from the original message: `In-Reply-To` is set to
+          # its RFC Message-ID, and `References` contains the original References values
+          # plus that Message-ID, de-duplicated and limited to the most recent 20 values.
+          sig do
+            params(
+              message_id: String,
+              inbox_id: String,
+              html: String,
+              text: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::EmailInboxes::EmailMessageResponse)
+          end
+          def reply(
+            # Path param: Inbound email message UUID.
+            message_id,
+            # Path param: Email inbox UUID.
+            inbox_id:,
+            # Body param: HTML reply body.
+            html: nil,
+            # Body param: Plain-text reply body.
+            text: nil,
+            request_options: {}
+          )
+          end
+
+          # Sends from the inbox address through the standard email send pipeline. The To
+          # list starts with the original `Reply-To` (or `From`) and includes original To
+          # recipients; the Cc list includes original Cc recipients. The inbox address is
+          # excluded, and recipients are de-duplicated case-insensitively across To and Cc.
+          # Bcc is always empty. The subject is prefixed with `Re:` unless it already has
+          # that prefix.
+          #
+          # Threading headers are derived from the original message: `In-Reply-To` is set to
+          # its RFC Message-ID, and `References` contains the original References values
+          # plus that Message-ID, de-duplicated and limited to the most recent 20 values.
+          sig do
+            params(
+              message_id: String,
+              inbox_id: String,
+              html: String,
+              text: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::EmailInboxes::EmailMessageResponse)
+          end
+          def reply_all(
+            # Path param: Inbound email message UUID.
+            message_id,
+            # Path param: Email inbox UUID.
+            inbox_id:,
+            # Body param: HTML reply body.
+            html: nil,
+            # Body param: Plain-text reply body.
+            text: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Telnyx::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end