ark-email 0.5.1

data/rbi/ark_email/models/email_send_batch_response.rbi

@@ -0,0 +1,159 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailSendBatchResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::EmailSendBatchResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::EmailSendBatchResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(
+          data: ArkEmail::Models::EmailSendBatchResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      sig { returns(ArkEmail::APIMeta) }
+      attr_reader :meta
+
+      sig { params(meta: ArkEmail::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      sig do
+        params(
+          data: ArkEmail::Models::EmailSendBatchResponse::Data::OrHash,
+          meta: ArkEmail::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(data:, meta:, success: true)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: ArkEmail::Models::EmailSendBatchResponse::Data,
+            meta: ArkEmail::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < ArkEmail::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ArkEmail::Models::EmailSendBatchResponse::Data,
+              ArkEmail::Internal::AnyHash
+            )
+          end
+
+        # Successfully accepted emails
+        sig { returns(Integer) }
+        attr_accessor :accepted
+
+        # Failed emails
+        sig { returns(Integer) }
+        attr_accessor :failed
+
+        # Map of recipient email to message info
+        sig do
+          returns(
+            T::Hash[
+              Symbol,
+              ArkEmail::Models::EmailSendBatchResponse::Data::Message
+            ]
+          )
+        end
+        attr_accessor :messages
+
+        # Total emails in the batch
+        sig { returns(Integer) }
+        attr_accessor :total
+
+        sig do
+          params(
+            accepted: Integer,
+            failed: Integer,
+            messages:
+              T::Hash[
+                Symbol,
+                ArkEmail::Models::EmailSendBatchResponse::Data::Message::OrHash
+              ],
+            total: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Successfully accepted emails
+          accepted:,
+          # Failed emails
+          failed:,
+          # Map of recipient email to message info
+          messages:,
+          # Total emails in the batch
+          total:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              accepted: Integer,
+              failed: Integer,
+              messages:
+                T::Hash[
+                  Symbol,
+                  ArkEmail::Models::EmailSendBatchResponse::Data::Message
+                ],
+              total: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Message < ArkEmail::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ArkEmail::Models::EmailSendBatchResponse::Data::Message,
+                ArkEmail::Internal::AnyHash
+              )
+            end
+
+          # Message ID
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(String) }
+          attr_accessor :token
+
+          sig { params(id: String, token: String).returns(T.attached_class) }
+          def self.new(
+            # Message ID
+            id:,
+            token:
+          )
+          end
+
+          sig { override.returns({ id: String, token: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/email_send_params.rbi

@@ -0,0 +1,229 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailSendParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::EmailSendParams, ArkEmail::Internal::AnyHash)
+        end
+
+      # Sender email address. Must be from a verified domain.
+      #
+      # **Supported formats:**
+      #
+      # - Email only: `hello@yourdomain.com`
+      # - With display name: `Acme <hello@yourdomain.com>`
+      # - With quoted name: `"Acme Support" <support@yourdomain.com>`
+      #
+      # The domain portion must match a verified sending domain in your account.
+      sig { returns(String) }
+      attr_accessor :from
+
+      # Email subject line
+      sig { returns(String) }
+      attr_accessor :subject
+
+      # Recipient email addresses (max 50)
+      sig { returns(T::Array[String]) }
+      attr_accessor :to
+
+      # File attachments
+      sig do
+        returns(T.nilable(T::Array[ArkEmail::EmailSendParams::Attachment]))
+      end
+      attr_reader :attachments
+
+      sig do
+        params(
+          attachments: T::Array[ArkEmail::EmailSendParams::Attachment::OrHash]
+        ).void
+      end
+      attr_writer :attachments
+
+      # BCC recipients
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :bcc
+
+      sig { params(bcc: T::Array[String]).void }
+      attr_writer :bcc
+
+      # CC recipients
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :cc
+
+      sig { params(cc: T::Array[String]).void }
+      attr_writer :cc
+
+      # Custom email headers
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :headers
+
+      sig { params(headers: T::Hash[Symbol, String]).void }
+      attr_writer :headers
+
+      # HTML body content. Maximum 5MB (5,242,880 characters). Combined with
+      # attachments, the total message must not exceed 14MB.
+      sig { returns(T.nilable(String)) }
+      attr_reader :html
+
+      sig { params(html: String).void }
+      attr_writer :html
+
+      # Reply-to address
+      sig { returns(T.nilable(String)) }
+      attr_reader :reply_to
+
+      sig { params(reply_to: String).void }
+      attr_writer :reply_to
+
+      # Tag for categorization and filtering
+      sig { returns(T.nilable(String)) }
+      attr_reader :tag
+
+      sig { params(tag: String).void }
+      attr_writer :tag
+
+      # Plain text body (auto-generated from HTML if not provided). Maximum 5MB
+      # (5,242,880 characters).
+      sig { returns(T.nilable(String)) }
+      attr_reader :text
+
+      sig { params(text: String).void }
+      attr_writer :text
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      sig do
+        params(
+          from: String,
+          subject: String,
+          to: T::Array[String],
+          attachments: T::Array[ArkEmail::EmailSendParams::Attachment::OrHash],
+          bcc: T::Array[String],
+          cc: T::Array[String],
+          headers: T::Hash[Symbol, String],
+          html: String,
+          reply_to: String,
+          tag: String,
+          text: String,
+          idempotency_key: String,
+          request_options: ArkEmail::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Sender email address. Must be from a verified domain.
+        #
+        # **Supported formats:**
+        #
+        # - Email only: `hello@yourdomain.com`
+        # - With display name: `Acme <hello@yourdomain.com>`
+        # - With quoted name: `"Acme Support" <support@yourdomain.com>`
+        #
+        # The domain portion must match a verified sending domain in your account.
+        from:,
+        # Email subject line
+        subject:,
+        # Recipient email addresses (max 50)
+        to:,
+        # File attachments
+        attachments: nil,
+        # BCC recipients
+        bcc: nil,
+        # CC recipients
+        cc: nil,
+        # Custom email headers
+        headers: nil,
+        # HTML body content. Maximum 5MB (5,242,880 characters). Combined with
+        # attachments, the total message must not exceed 14MB.
+        html: nil,
+        # Reply-to address
+        reply_to: nil,
+        # Tag for categorization and filtering
+        tag: nil,
+        # Plain text body (auto-generated from HTML if not provided). Maximum 5MB
+        # (5,242,880 characters).
+        text: nil,
+        idempotency_key: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            from: String,
+            subject: String,
+            to: T::Array[String],
+            attachments: T::Array[ArkEmail::EmailSendParams::Attachment],
+            bcc: T::Array[String],
+            cc: T::Array[String],
+            headers: T::Hash[Symbol, String],
+            html: String,
+            reply_to: String,
+            tag: String,
+            text: String,
+            idempotency_key: String,
+            request_options: ArkEmail::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Attachment < ArkEmail::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ArkEmail::EmailSendParams::Attachment,
+              ArkEmail::Internal::AnyHash
+            )
+          end
+
+        # Base64-encoded file content
+        sig { returns(String) }
+        attr_accessor :content
+
+        # MIME type
+        sig { returns(String) }
+        attr_accessor :content_type
+
+        # Attachment filename
+        sig { returns(String) }
+        attr_accessor :filename
+
+        sig do
+          params(
+            content: String,
+            content_type: String,
+            filename: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Base64-encoded file content
+          content:,
+          # MIME type
+          content_type:,
+          # Attachment filename
+          filename:
+        )
+        end
+
+        sig do
+          override.returns(
+            { content: String, content_type: String, filename: String }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/email_send_raw_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailSendRawParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::EmailSendRawParams, ArkEmail::Internal::AnyHash)
+        end
+
+      # Base64-encoded RFC 2822 message
+      sig { returns(String) }
+      attr_accessor :data
+
+      # Envelope sender address
+      sig { returns(String) }
+      attr_accessor :mail_from
+
+      # Envelope recipient addresses
+      sig { returns(T::Array[String]) }
+      attr_accessor :rcpt_to
+
+      sig do
+        params(
+          data: String,
+          mail_from: String,
+          rcpt_to: T::Array[String],
+          request_options: ArkEmail::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Base64-encoded RFC 2822 message
+        data:,
+        # Envelope sender address
+        mail_from:,
+        # Envelope recipient addresses
+        rcpt_to:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: String,
+            mail_from: String,
+            rcpt_to: T::Array[String],
+            request_options: ArkEmail::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/ark_email/models/email_send_raw_response.rbi

@@ -0,0 +1,157 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailSendRawResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::EmailSendRawResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::EmailSendRawResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(data: ArkEmail::Models::EmailSendRawResponse::Data::OrHash).void
+      end
+      attr_writer :data
+
+      sig { returns(ArkEmail::APIMeta) }
+      attr_reader :meta
+
+      sig { params(meta: ArkEmail::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      sig do
+        params(
+          data: ArkEmail::Models::EmailSendRawResponse::Data::OrHash,
+          meta: ArkEmail::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(data:, meta:, success: true)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: ArkEmail::Models::EmailSendRawResponse::Data,
+            meta: ArkEmail::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < ArkEmail::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              ArkEmail::Models::EmailSendRawResponse::Data,
+              ArkEmail::Internal::AnyHash
+            )
+          end
+
+        # Unique message ID (format: msg*{id}*{token})
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Current delivery status
+        sig do
+          returns(
+            ArkEmail::Models::EmailSendRawResponse::Data::Status::TaggedSymbol
+          )
+        end
+        attr_accessor :status
+
+        # List of recipient addresses
+        sig { returns(T::Array[String]) }
+        attr_accessor :to
+
+        # SMTP Message-ID header value
+        sig { returns(T.nilable(String)) }
+        attr_reader :message_id
+
+        sig { params(message_id: String).void }
+        attr_writer :message_id
+
+        sig do
+          params(
+            id: String,
+            status:
+              ArkEmail::Models::EmailSendRawResponse::Data::Status::OrSymbol,
+            to: T::Array[String],
+            message_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique message ID (format: msg*{id}*{token})
+          id:,
+          # Current delivery status
+          status:,
+          # List of recipient addresses
+          to:,
+          # SMTP Message-ID header value
+          message_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              status:
+                ArkEmail::Models::EmailSendRawResponse::Data::Status::TaggedSymbol,
+              to: T::Array[String],
+              message_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Current delivery status
+        module Status
+          extend ArkEmail::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                ArkEmail::Models::EmailSendRawResponse::Data::Status
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PENDING =
+            T.let(
+              :pending,
+              ArkEmail::Models::EmailSendRawResponse::Data::Status::TaggedSymbol
+            )
+          SENT =
+            T.let(
+              :sent,
+              ArkEmail::Models::EmailSendRawResponse::Data::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                ArkEmail::Models::EmailSendRawResponse::Data::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end