ark-email 0.5.1

data/rbi/ark_email/models/domain_verify_response.rbi

@@ -0,0 +1,193 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainVerifyResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::DomainVerifyResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::DomainVerifyResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(data: ArkEmail::Models::DomainVerifyResponse::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::DomainVerifyResponse::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::DomainVerifyResponse::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::DomainVerifyResponse::Data,
+              ArkEmail::Internal::AnyHash
+            )
+          end
+
+        # Domain ID
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        sig do
+          returns(ArkEmail::Models::DomainVerifyResponse::Data::DNSRecords)
+        end
+        attr_reader :dns_records
+
+        sig do
+          params(
+            dns_records:
+              ArkEmail::Models::DomainVerifyResponse::Data::DNSRecords::OrHash
+          ).void
+        end
+        attr_writer :dns_records
+
+        # Domain name
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { returns(String) }
+        attr_accessor :uuid
+
+        # Whether DNS is verified
+        sig { returns(T::Boolean) }
+        attr_accessor :verified
+
+        # When the domain was verified (null if not verified)
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :verified_at
+
+        sig do
+          params(
+            id: String,
+            created_at: Time,
+            dns_records:
+              ArkEmail::Models::DomainVerifyResponse::Data::DNSRecords::OrHash,
+            name: String,
+            uuid: String,
+            verified: T::Boolean,
+            verified_at: T.nilable(Time)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Domain ID
+          id:,
+          created_at:,
+          dns_records:,
+          # Domain name
+          name:,
+          uuid:,
+          # Whether DNS is verified
+          verified:,
+          # When the domain was verified (null if not verified)
+          verified_at: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Time,
+              dns_records:
+                ArkEmail::Models::DomainVerifyResponse::Data::DNSRecords,
+              name: String,
+              uuid: String,
+              verified: T::Boolean,
+              verified_at: T.nilable(Time)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class DNSRecords < ArkEmail::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ArkEmail::Models::DomainVerifyResponse::Data::DNSRecords,
+                ArkEmail::Internal::AnyHash
+              )
+            end
+
+          sig { returns(ArkEmail::DNSRecord) }
+          attr_reader :dkim
+
+          sig { params(dkim: ArkEmail::DNSRecord::OrHash).void }
+          attr_writer :dkim
+
+          sig { returns(ArkEmail::DNSRecord) }
+          attr_reader :return_path
+
+          sig { params(return_path: ArkEmail::DNSRecord::OrHash).void }
+          attr_writer :return_path
+
+          sig { returns(ArkEmail::DNSRecord) }
+          attr_reader :spf
+
+          sig { params(spf: ArkEmail::DNSRecord::OrHash).void }
+          attr_writer :spf
+
+          sig do
+            params(
+              dkim: ArkEmail::DNSRecord::OrHash,
+              return_path: ArkEmail::DNSRecord::OrHash,
+              spf: ArkEmail::DNSRecord::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(dkim:, return_path:, spf:)
+          end
+
+          sig do
+            override.returns(
+              {
+                dkim: ArkEmail::DNSRecord,
+                return_path: ArkEmail::DNSRecord,
+                spf: ArkEmail::DNSRecord
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/email_list_params.rbi

@@ -0,0 +1,172 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailListParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::EmailListParams, ArkEmail::Internal::AnyHash)
+        end
+
+      # Return emails sent after this timestamp (Unix seconds or ISO 8601)
+      sig { returns(T.nilable(String)) }
+      attr_reader :after
+
+      sig { params(after: String).void }
+      attr_writer :after
+
+      # Return emails sent before this timestamp
+      sig { returns(T.nilable(String)) }
+      attr_reader :before
+
+      sig { params(before: String).void }
+      attr_writer :before
+
+      # Filter by sender email address
+      sig { returns(T.nilable(String)) }
+      attr_reader :from
+
+      sig { params(from: String).void }
+      attr_writer :from
+
+      # Page number (starts at 1)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page
+
+      sig { params(page: Integer).void }
+      attr_writer :page
+
+      # Results per page (max 100)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :per_page
+
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
+
+      # Filter by delivery status:
+      #
+      # - `pending` - Email accepted, waiting to be processed
+      # - `sent` - Email transmitted to recipient's mail server
+      # - `softfail` - Temporary delivery failure, will retry
+      # - `hardfail` - Permanent delivery failure
+      # - `bounced` - Email bounced back
+      # - `held` - Held for manual review
+      sig { returns(T.nilable(ArkEmail::EmailListParams::Status::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: ArkEmail::EmailListParams::Status::OrSymbol).void }
+      attr_writer :status
+
+      # Filter by tag
+      sig { returns(T.nilable(String)) }
+      attr_reader :tag
+
+      sig { params(tag: String).void }
+      attr_writer :tag
+
+      # Filter by recipient email address
+      sig { returns(T.nilable(String)) }
+      attr_reader :to
+
+      sig { params(to: String).void }
+      attr_writer :to
+
+      sig do
+        params(
+          after: String,
+          before: String,
+          from: String,
+          page: Integer,
+          per_page: Integer,
+          status: ArkEmail::EmailListParams::Status::OrSymbol,
+          tag: String,
+          to: String,
+          request_options: ArkEmail::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Return emails sent after this timestamp (Unix seconds or ISO 8601)
+        after: nil,
+        # Return emails sent before this timestamp
+        before: nil,
+        # Filter by sender email address
+        from: nil,
+        # Page number (starts at 1)
+        page: nil,
+        # Results per page (max 100)
+        per_page: nil,
+        # Filter by delivery status:
+        #
+        # - `pending` - Email accepted, waiting to be processed
+        # - `sent` - Email transmitted to recipient's mail server
+        # - `softfail` - Temporary delivery failure, will retry
+        # - `hardfail` - Permanent delivery failure
+        # - `bounced` - Email bounced back
+        # - `held` - Held for manual review
+        status: nil,
+        # Filter by tag
+        tag: nil,
+        # Filter by recipient email address
+        to: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after: String,
+            before: String,
+            from: String,
+            page: Integer,
+            per_page: Integer,
+            status: ArkEmail::EmailListParams::Status::OrSymbol,
+            tag: String,
+            to: String,
+            request_options: ArkEmail::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by delivery status:
+      #
+      # - `pending` - Email accepted, waiting to be processed
+      # - `sent` - Email transmitted to recipient's mail server
+      # - `softfail` - Temporary delivery failure, will retry
+      # - `hardfail` - Permanent delivery failure
+      # - `bounced` - Email bounced back
+      # - `held` - Held for manual review
+      module Status
+        extend ArkEmail::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ArkEmail::EmailListParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING =
+          T.let(:pending, ArkEmail::EmailListParams::Status::TaggedSymbol)
+        SENT = T.let(:sent, ArkEmail::EmailListParams::Status::TaggedSymbol)
+        SOFTFAIL =
+          T.let(:softfail, ArkEmail::EmailListParams::Status::TaggedSymbol)
+        HARDFAIL =
+          T.let(:hardfail, ArkEmail::EmailListParams::Status::TaggedSymbol)
+        BOUNCED =
+          T.let(:bounced, ArkEmail::EmailListParams::Status::TaggedSymbol)
+        HELD = T.let(:held, ArkEmail::EmailListParams::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[ArkEmail::EmailListParams::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/email_list_response.rbi

@@ -0,0 +1,164 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailListResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::EmailListResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      # Internal message ID
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :token
+
+      sig { returns(String) }
+      attr_accessor :from
+
+      # Current delivery status:
+      #
+      # - `pending` - Email accepted, waiting to be processed
+      # - `sent` - Email transmitted to recipient's mail server
+      # - `softfail` - Temporary delivery failure, will retry
+      # - `hardfail` - Permanent delivery failure
+      # - `bounced` - Email bounced back
+      # - `held` - Held for manual review
+      sig { returns(ArkEmail::Models::EmailListResponse::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      sig { returns(String) }
+      attr_accessor :subject
+
+      sig { returns(Float) }
+      attr_accessor :timestamp
+
+      sig { returns(Time) }
+      attr_accessor :timestamp_iso
+
+      sig { returns(String) }
+      attr_accessor :to
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :tag
+
+      sig { params(tag: String).void }
+      attr_writer :tag
+
+      sig do
+        params(
+          id: String,
+          token: String,
+          from: String,
+          status: ArkEmail::Models::EmailListResponse::Status::OrSymbol,
+          subject: String,
+          timestamp: Float,
+          timestamp_iso: Time,
+          to: String,
+          tag: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Internal message ID
+        id:,
+        token:,
+        from:,
+        # Current delivery status:
+        #
+        # - `pending` - Email accepted, waiting to be processed
+        # - `sent` - Email transmitted to recipient's mail server
+        # - `softfail` - Temporary delivery failure, will retry
+        # - `hardfail` - Permanent delivery failure
+        # - `bounced` - Email bounced back
+        # - `held` - Held for manual review
+        status:,
+        subject:,
+        timestamp:,
+        timestamp_iso:,
+        to:,
+        tag: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            token: String,
+            from: String,
+            status: ArkEmail::Models::EmailListResponse::Status::TaggedSymbol,
+            subject: String,
+            timestamp: Float,
+            timestamp_iso: Time,
+            to: String,
+            tag: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Current delivery status:
+      #
+      # - `pending` - Email accepted, waiting to be processed
+      # - `sent` - Email transmitted to recipient's mail server
+      # - `softfail` - Temporary delivery failure, will retry
+      # - `hardfail` - Permanent delivery failure
+      # - `bounced` - Email bounced back
+      # - `held` - Held for manual review
+      module Status
+        extend ArkEmail::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, ArkEmail::Models::EmailListResponse::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING =
+          T.let(
+            :pending,
+            ArkEmail::Models::EmailListResponse::Status::TaggedSymbol
+          )
+        SENT =
+          T.let(
+            :sent,
+            ArkEmail::Models::EmailListResponse::Status::TaggedSymbol
+          )
+        SOFTFAIL =
+          T.let(
+            :softfail,
+            ArkEmail::Models::EmailListResponse::Status::TaggedSymbol
+          )
+        HARDFAIL =
+          T.let(
+            :hardfail,
+            ArkEmail::Models::EmailListResponse::Status::TaggedSymbol
+          )
+        BOUNCED =
+          T.let(
+            :bounced,
+            ArkEmail::Models::EmailListResponse::Status::TaggedSymbol
+          )
+        HELD =
+          T.let(
+            :held,
+            ArkEmail::Models::EmailListResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[ArkEmail::Models::EmailListResponse::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/email_retrieve_deliveries_params.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class EmailRetrieveDeliveriesParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::EmailRetrieveDeliveriesParams,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: ArkEmail::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: ArkEmail::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end