openemail 0.0.1

data/lib/openemail/resources/billing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Billing < Resource
+      def get(api_key: nil)
+        request(ApiPaths::BILLING, api_key:)
+      end
+
+      def list_plans(api_key: nil)
+        request(ApiPaths::BILLING_PLANS, api_key:)
+      end
+
+      def get_usage(days: nil, api_key: nil)
+        request(ApiPaths::BILLING_USAGE, query: query_params(days:), api_key:)
+      end
+
+      def list_alerts(api_key: nil)
+        request(ApiPaths::BILLING_ALERTS, api_key:)
+      end
+
+      def list_countries(api_key: nil)
+        request(ApiPaths::BILLING_COUNTRIES, api_key:)
+      end
+
+      def get_pay_as_you_go(api_key: nil)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO, api_key:)
+      end
+
+      def set_pay_as_you_go(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO, method: :patch, body: payload(body, fields), api_key:)
+      end
+
+      def set_pay_as_you_go_limit(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO_LIMIT, method: :put, body: payload(body, fields), api_key:)
+      end
+
+      def confirm_pay_as_you_go(api_key: nil)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO_CONFIRM, method: :post, api_key:)
+      end
+
+      def start_checkout(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_CHECKOUT, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def open_portal(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_PORTAL, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_invoices(page: nil, limit: nil, sort: nil, search: nil, api_key: nil)
+        request(ApiPaths::BILLING_INVOICES, query: query_params(page:, limit:, sort:, search:), api_key:)
+      end
+
+      def get_invoice(order_id, api_key: nil)
+        request(fill(ApiPaths::BILLING_INVOICE, orderId: order_id), api_key:)
+      end
+
+      def save_invoice_details(order_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BILLING_INVOICE_DETAILS, orderId: order_id), method: :put, body: payload(body, fields),
+          api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/branding.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Branding < Resource
+      def get(api_key: nil)
+        request(ApiPaths::BRANDING, api_key:)
+      end
+
+      def update(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BRANDING, method: :patch, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def upload_image(variant, data, content_type: nil, api_key: nil)
+        request(fill(ApiPaths::BRANDING_IMAGE, variant:), method: :put, raw: data,
+          content_type: raw_content_type(data, content_type), repeatable: true, api_key:)
+      end
+
+      def remove_image(variant, api_key: nil)
+        request(fill(ApiPaths::BRANDING_IMAGE, variant:), method: :delete, repeatable: true, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/broadcasts.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Broadcasts < Resource
+      def preview(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BROADCASTS_PREVIEW, method: :post, body: payload(body, fields).slice("audienceIds"),
+          repeatable: true, api_key:)
+      end
+
+      def send(body = nil, idempotency_key: nil, api_key: nil, **fields)
+        wire = payload(body, fields)
+        wire["scheduledAt"] = instant(wire["scheduledAt"]) if wire.key?("scheduledAt")
+        request(ApiPaths::BROADCASTS, method: :post, body: wire, idempotent: true, idempotency_key:, repeatable: true,
+          api_key:)
+      end
+
+      def list(audience_id: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::BROADCASTS, query_params(audience_id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(audience_id: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::BROADCASTS, query_params(audience_id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(audience_id: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::BROADCASTS, query_params(audience_id:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST, id:), api_key:)
+      end
+
+      def list_recipients(id, filter: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::BROADCAST_RECIPIENTS, id:), query_params(filter:, q:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_recipients(id, filter: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::BROADCAST_RECIPIENTS, id:), query_params(filter:, q:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_recipients(id, filter: nil, q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::BROADCAST_RECIPIENTS, id:), query_params(filter:, q:), limit:, cursor:, api_key:, &)
+      end
+
+      def get_recipient(id, email_id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST_RECIPIENT, id:, emailId: email_id), api_key:)
+      end
+
+      def stats(id, grain: nil, offset_minutes: nil, days: nil, minutes: nil, api_key: nil)
+        request(fill(ApiPaths::BROADCAST_STATS, id:), query: query_params(grain:, offset_minutes:, days:, minutes:),
+          api_key:)
+      end
+
+      def analytics(broadcast_ids: nil, days: nil, minutes: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        query = query_params(broadcast_ids: joined(broadcast_ids), days:, minutes:, grain:, offset_minutes:)
+        request(ApiPaths::BROADCASTS_ANALYTICS, query:, api_key:)
+      end
+
+      def cancel(id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST_CANCEL, id:), method: :post, repeatable: true, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/calendar.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Calendar < Resource
+      def list_events(from:, to:, timezone: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CALENDAR_EVENTS, range_query(from, to, timezone), limit:, cursor:, api_key:)
+      end
+
+      def list_all_events(from:, to:, timezone: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CALENDAR_EVENTS, range_query(from, to, timezone), limit:, cursor:, api_key:)
+      end
+
+      def iterate_events(from:, to:, timezone: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CALENDAR_EVENTS, range_query(from, to, timezone), limit:, cursor:, api_key:, &)
+      end
+
+      def get_event(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT, id:), api_key:)
+      end
+
+      def get_event_ics(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT_ICS, id:), accept: Protocol::CONTENT_TYPES[:CALENDAR], api_key:)
+      end
+
+      def create_event(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_EVENTS, method: :post, body: event_wire(payload(body, fields)), api_key:)
+      end
+
+      def update_event(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_EVENT, id:), method: :patch, body: event_wire(payload(patch, fields)), api_key:)
+      end
+
+      def delete_event(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT, id:), method: :delete, api_key:)
+      end
+
+      def cancel_event(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_EVENT_CANCEL, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def respond_to_event(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_EVENT_RESPOND, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      private
+
+      def range_query(from, to, timezone)
+        query_params(from: instant(from), to: instant(to), timezone:)
+      end
+
+      def event_wire(wire)
+        wire["start"] = instant(wire["start"]) if wire.key?("start")
+        wire["end"] = instant(wire["end"]) if wire.key?("end")
+        wire
+      end
+    end
+  end
+end

data/lib/openemail/resources/chats.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Chats < Resource
+      def list(q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CHATS, query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CHATS, query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CHATS, query_params(q:, sort:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::CHAT, id:), api_key:)
+      end
+
+      def rename(id, title, api_key: nil)
+        request(fill(ApiPaths::CHAT, id:), method: :patch, body: {"title" => title}, repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::CHAT, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/contacts.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Contacts < Resource
+      def list(source: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CONTACTS, query_params(source:, q:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(source: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONTACTS, query_params(source:, q:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(source: nil, q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONTACTS, query_params(source:, q:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT, email:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CONTACTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(email, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT, email:), method: :patch, body: payload(patch, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT, email:), method: :delete, api_key:)
+      end
+
+      def set_audiences(email, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT_AUDIENCES, email:), method: :put, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      def list_people(q: nil, email: nil, sort: nil, blocked: nil, limit: nil, cursor: nil, api_key: nil)
+        query = Pagination.page_query(people_query(q, email, sort, blocked), CURSOR, limit, cursor)
+        envelope = request(ApiPaths::CONTACTS_PEOPLE, query:, api_key:)
+        envelope = {} unless envelope.is_a?(Hash)
+        next_cursor = Pagination.cursor_of(envelope[:nextCursor])
+
+        PeoplePage.new(
+          items: Pagination.items_of(envelope),
+          has_more: Pagination.more?(envelope, next_cursor),
+          next_cursor:,
+          seen: envelope[:seen] == true
+        )
+      end
+
+      def list_all_people(q: nil, email: nil, sort: nil, blocked: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONTACTS_PEOPLE, people_query(q, email, sort, blocked), limit:, cursor:, api_key:)
+      end
+
+      def iterate_people(q: nil, email: nil, sort: nil, blocked: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONTACTS_PEOPLE, people_query(q, email, sort, blocked), limit:, cursor:, api_key:, &)
+      end
+
+      def save(email, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT, email:), method: :put, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def delete_many(emails, api_key: nil)
+        request(ApiPaths::CONTACTS_BATCH_DELETE, method: :post, body: {"emails" => emails}, repeatable: true, api_key:)
+      end
+
+      def set_photo(email, data, content_type: nil, api_key: nil)
+        request(fill(ApiPaths::CONTACT_PHOTO, email:), method: :put, raw: data,
+          content_type: raw_content_type(data, content_type), repeatable: true, api_key:)
+      end
+
+      def remove_photo(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT_PHOTO, email:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def block(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT_BLOCK, email:), method: :post, repeatable: true, api_key:)
+      end
+
+      def unblock(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT_BLOCK, email:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def list_threads(email, q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::CONTACT_THREADS, email:), query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_threads(email, q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::CONTACT_THREADS, email:), query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_threads(email, q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::CONTACT_THREADS, email:), query_params(q:, sort:), limit:, cursor:, api_key:, &)
+      end
+
+      def activity(email, minutes: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        request(fill(ApiPaths::CONTACT_ACTIVITY, email:), query: query_params(minutes:, grain:, offset_minutes:),
+          api_key:)
+      end
+
+      private
+
+      def people_query(q, email, sort, blocked)
+        query_params(q:, email:, sort:, blocked: flag(blocked))
+      end
+    end
+  end
+end

data/lib/openemail/resources/dns_connections.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class DnsConnections < Resource
+      def list(api_key: nil)
+        request(ApiPaths::DNS_CONNECTIONS, api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::DNS_CONNECTION, id:), api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::DNS_CONNECTION, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/domains.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Domains < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::DOMAINS, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::DOMAINS, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::DOMAINS, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::DOMAINS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def verify(id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_VERIFY, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN, id:), method: :delete, api_key:)
+      end
+
+      def get_logo(id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_LOGO, id:), api_key:)
+      end
+
+      def set_logo(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_LOGO, id:), method: :put, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def remove_logo(id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_LOGO, id:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def set_logo_certificate(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_LOGO_CERTIFICATE, id:), method: :put, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def remove_logo_certificate(id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_LOGO_CERTIFICATE, id:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def list_addresses(id, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::DOMAIN_ADDRESSES, id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_addresses(id, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::DOMAIN_ADDRESSES, id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_addresses(id, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::DOMAIN_ADDRESSES, id:), limit:, cursor:, api_key:, &)
+      end
+
+      def create_address(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESSES, id:), method: :post, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      def get_address(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS, id:, addressId: address_id), api_key:)
+      end
+
+      def update_address(id, address_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS, id:, addressId: address_id), method: :patch,
+          body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def set_address_photo(id, address_id, data, content_type: nil, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_PHOTO, id:, addressId: address_id), method: :put, raw: data,
+          content_type: raw_content_type(data, content_type), repeatable: true, api_key:)
+      end
+
+      def remove_address_photo(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_PHOTO, id:, addressId: address_id), method: :delete, repeatable: true,
+          api_key:)
+      end
+
+      def delete_address(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS, id:, addressId: address_id), method: :delete, api_key:)
+      end
+
+      def list_address_forwards(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_FORWARDS, id:, addressId: address_id), api_key:)
+      end
+
+      def add_address_forwards(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_FORWARDS, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
+      def update_address_forward(id, address_id, forward_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_FORWARD, id:, addressId: address_id, forwardId: forward_id),
+          method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete_address_forward(id, address_id, forward_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_FORWARD, id:, addressId: address_id, forwardId: forward_id),
+          method: :delete, api_key:)
+      end
+
+      def resend_address_forward_consent(id, address_id, forward_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_FORWARD_RESEND, id:, addressId: address_id, forwardId: forward_id),
+          method: :post, api_key:)
+      end
+
+      def list_address_members(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MEMBERS, id:, addressId: address_id), api_key:)
+      end
+
+      def get_address_login(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_LOGIN, id:, addressId: address_id), api_key:)
+      end
+
+      def set_address_login(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_LOGIN, id:, addressId: address_id), method: :put,
+          body: payload(body, fields), api_key:)
+      end
+
+      def delete_address_login(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_LOGIN, id:, addressId: address_id), method: :delete, api_key:)
+      end
+
+      def get_dns(id, refresh: nil, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_DNS, id:), query: query_params(refresh:), api_key:)
+      end
+
+      def set_dns_zone(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_DNS, id:), method: :put, body: payload(body, fields), api_key:)
+      end
+
+      def sync_dns(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_DNS_SYNC, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/drafts.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Drafts < Resource
+      def list(query: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::DRAFTS, query_params(query:), style: PAGE_TOKEN, limit:, cursor:, api_key:)
+      end
+
+      def list_all(query: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::DRAFTS, query_params(query:), style: PAGE_TOKEN, limit:, cursor:, api_key:)
+      end
+
+      def iterate(query: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::DRAFTS, query_params(query:), style: PAGE_TOKEN, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::DRAFT, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::DRAFTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DRAFT, id:), method: :patch, body: payload(body, fields), api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::DRAFT, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/emails.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Emails < Resource
+      def send(body = nil, idempotency_key: nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS, method: :post, body: Wire.email(payload(body, fields)), idempotent: true,
+          idempotency_key:, repeatable: true, api_key:)
+      end
+
+      def send_batch(emails, idempotency_key: nil, api_key: nil)
+        wire = emails.map { |email| Wire.email(payload(email, {})) }
+        result = request(ApiPaths::EMAILS_BATCH, method: :post, body: {"emails" => wire}, idempotent: true,
+          idempotency_key:, repeatable: true, api_key:)
+        envelope = result.is_a?(Hash) ? result : {}
+
+        BatchResult.new(items: Pagination.items_of(envelope), sent: envelope[:sent], failed: envelope[:failed])
+      end
+
+      def translate(body = nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS_TRANSLATE, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def check(body = nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS_CHECK, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list(status: nil, from: nil, broadcast_id: nil, scheduled_from: nil, scheduled_to: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::EMAILS, list_query(status, from, broadcast_id, scheduled_from, scheduled_to), limit:,
+          cursor:, api_key:)
+      end
+
+      def list_all(status: nil, from: nil, broadcast_id: nil, scheduled_from: nil, scheduled_to: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        collect_all(ApiPaths::EMAILS, list_query(status, from, broadcast_id, scheduled_from, scheduled_to), limit:,
+          cursor:, api_key:)
+      end
+
+      def iterate(status: nil, from: nil, broadcast_id: nil, scheduled_from: nil, scheduled_to: nil, limit: nil,
+        cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::EMAILS, list_query(status, from, broadcast_id, scheduled_from, scheduled_to), limit:,
+          cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::EMAIL, id:), api_key:)
+      end
+
+      def list_events(id, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::EMAIL_EVENTS, id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_events(id, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::EMAIL_EVENTS, id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_events(id, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::EMAIL_EVENTS, id:), limit:, cursor:, api_key:, &)
+      end
+
+      def get_tracking(id, api_key: nil)
+        request(fill(ApiPaths::EMAIL_TRACKING, id:), api_key:)
+      end
+
+      def cancel(id, api_key: nil)
+        request(fill(ApiPaths::EMAIL_CANCEL, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def reschedule(id, scheduled_at, api_key: nil)
+        request(fill(ApiPaths::EMAIL, id:), method: :patch, body: {"scheduledAt" => instant(scheduled_at)},
+          repeatable: true, api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::EMAIL, id:), method: :patch, body: Wire.recipients(payload(patch, fields)),
+          repeatable: true, api_key:)
+      end
+
+      def compose(body = nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS_COMPOSE, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def rewrite(body = nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS_REWRITE, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def suggest_subject(body = nil, api_key: nil, **fields)
+        request(ApiPaths::EMAILS_SUBJECT, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      private
+
+      def list_query(status, from, broadcast_id, scheduled_from, scheduled_to)
+        query_params(status: joined(status), from:, broadcast_id:, scheduled_from: instant(scheduled_from),
+          scheduled_to: instant(scheduled_to))
+      end
+    end
+  end
+end

data/lib/openemail/resources/encryption.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Encryption < Resource
+      def list_keys(api_key: nil)
+        fetch_list(ApiPaths::ENCRYPTION_KEYS, api_key:)
+      end
+
+      def publish_key(body = nil, api_key: nil, **fields)
+        request(ApiPaths::ENCRYPTION_KEYS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def lookup_keys(addresses:, api_key: nil)
+        fetch_list(ApiPaths::ENCRYPTION_KEYS_LOOKUP, query_params(addresses: joined(addresses)), api_key:)
+      end
+    end
+  end
+end