ark-email 0.5.1

data/rbi/ark_email/models/domain_create_response.rbi

@@ -0,0 +1,193 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainCreateResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::DomainCreateResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::DomainCreateResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(data: ArkEmail::Models::DomainCreateResponse::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::DomainCreateResponse::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::DomainCreateResponse::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::DomainCreateResponse::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::DomainCreateResponse::Data::DNSRecords)
+        end
+        attr_reader :dns_records
+
+        sig do
+          params(
+            dns_records:
+              ArkEmail::Models::DomainCreateResponse::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::DomainCreateResponse::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::DomainCreateResponse::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::DomainCreateResponse::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/domain_delete_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainDeleteParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::DomainDeleteParams, 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

data/rbi/ark_email/models/domain_delete_response.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainDeleteResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::DomainDeleteResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::DomainDeleteResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(data: ArkEmail::Models::DomainDeleteResponse::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::DomainDeleteResponse::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::DomainDeleteResponse::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::DomainDeleteResponse::Data,
+              ArkEmail::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :message
+
+        sig { params(message: String).returns(T.attached_class) }
+        def self.new(message:)
+        end
+
+        sig { override.returns({ message: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/domain_list_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainListParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::DomainListParams, 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

data/rbi/ark_email/models/domain_list_response.rbi

@@ -0,0 +1,144 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainListResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::DomainListResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::DomainListResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(data: ArkEmail::Models::DomainListResponse::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::DomainListResponse::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::DomainListResponse::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::DomainListResponse::Data,
+              ArkEmail::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(T::Array[ArkEmail::Models::DomainListResponse::Data::Domain])
+        end
+        attr_accessor :domains
+
+        sig do
+          params(
+            domains:
+              T::Array[
+                ArkEmail::Models::DomainListResponse::Data::Domain::OrHash
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(domains:)
+        end
+
+        sig do
+          override.returns(
+            {
+              domains:
+                T::Array[ArkEmail::Models::DomainListResponse::Data::Domain]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Domain < ArkEmail::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                ArkEmail::Models::DomainListResponse::Data::Domain,
+                ArkEmail::Internal::AnyHash
+              )
+            end
+
+          # Domain ID
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(T::Boolean) }
+          attr_accessor :dns_ok
+
+          sig { returns(String) }
+          attr_accessor :name
+
+          sig { returns(T::Boolean) }
+          attr_accessor :verified
+
+          sig do
+            params(
+              id: String,
+              dns_ok: T::Boolean,
+              name: String,
+              verified: T::Boolean
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Domain ID
+            id:,
+            dns_ok:,
+            name:,
+            verified:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                dns_ok: T::Boolean,
+                name: String,
+                verified: T::Boolean
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/ark_email/models/domain_retrieve_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainRetrieveParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::DomainRetrieveParams, 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

data/rbi/ark_email/models/domain_retrieve_response.rbi

@@ -0,0 +1,195 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainRetrieveResponse < ArkEmail::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            ArkEmail::Models::DomainRetrieveResponse,
+            ArkEmail::Internal::AnyHash
+          )
+        end
+
+      sig { returns(ArkEmail::Models::DomainRetrieveResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(
+          data: ArkEmail::Models::DomainRetrieveResponse::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::DomainRetrieveResponse::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::DomainRetrieveResponse::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::DomainRetrieveResponse::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::DomainRetrieveResponse::Data::DNSRecords)
+        end
+        attr_reader :dns_records
+
+        sig do
+          params(
+            dns_records:
+              ArkEmail::Models::DomainRetrieveResponse::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::DomainRetrieveResponse::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::DomainRetrieveResponse::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::DomainRetrieveResponse::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/domain_verify_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module ArkEmail
+  module Models
+    class DomainVerifyParams < ArkEmail::Internal::Type::BaseModel
+      extend ArkEmail::Internal::Type::RequestParameters::Converter
+      include ArkEmail::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(ArkEmail::DomainVerifyParams, 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