nextmail 0.0.1

data/lib/nextmail/resources/domains.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Domains < Resource
+      def list(q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::DOMAINS, query_params(q:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::DOMAINS, query_params(q:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::DOMAINS, query_params(q:), 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, crop: nil, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_PHOTO, id:, addressId: address_id), method: :put,
+          query: crop_query(crop), raw: data, content_type: raw_content_type(data, content_type), repeatable: true,
+          timeout: upload_timeout, 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 start_gravatar_publish(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_PHOTO_GRAVATAR, id:, addressId: address_id), method: :post, 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_mail_app_settings(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APPS, id:, addressId: address_id), api_key:)
+      end
+
+      def update_mail_app_settings(id, address_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APPS, id:, addressId: address_id), method: :patch,
+          body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def get_address_limits(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_LIMITS, id:, addressId: address_id), api_key:)
+      end
+
+      def update_address_limits(id, address_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_LIMITS, id:, addressId: address_id), method: :patch,
+          body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def list_app_passwords(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORDS, id:, addressId: address_id), api_key:)
+      end
+
+      def create_app_password(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORDS, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
+      def update_app_password(id, address_id, password_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORD, id:, addressId: address_id, passwordId: password_id),
+          method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete_app_password(id, address_id, password_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORD, id:, addressId: address_id, passwordId: password_id),
+          method: :delete, api_key:)
+      end
+
+      def send_mail_app_setup(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APP_SETUP, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
+      def create_mail_app_profile_link(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APP_PROFILE_LINK, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), 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
+
+      def list_routes(id, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::DOMAIN_ROUTES, id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_routes(id, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::DOMAIN_ROUTES, id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_routes(id, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::DOMAIN_ROUTES, id:), limit:, cursor:, api_key:, &)
+      end
+
+      def create_route(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ROUTES, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def get_route(id, route_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ROUTE, id:, routeId: route_id), api_key:)
+      end
+
+      def update_route(id, route_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ROUTE, id:, routeId: route_id), method: :patch, body: payload(patch, fields),
+          api_key:)
+      end
+
+      def test_route(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ROUTE_TEST, id:), method: :post, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete_route(id, route_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ROUTE, id:, routeId: route_id), method: :delete, api_key:)
+      end
+
+      def list_group_members(id, address_id, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::DOMAIN_ADDRESS_GROUP_MEMBERS, id:, addressId: address_id), limit:, cursor:,
+          api_key:)
+      end
+
+      def list_all_group_members(id, address_id, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::DOMAIN_ADDRESS_GROUP_MEMBERS, id:, addressId: address_id), limit:, cursor:,
+          api_key:)
+      end
+
+      def iterate_group_members(id, address_id, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::DOMAIN_ADDRESS_GROUP_MEMBERS, id:, addressId: address_id), limit:, cursor:,
+          api_key:, &)
+      end
+
+      def add_group_members(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_GROUP_MEMBERS, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
+      def remove_group_member(id, address_id, member_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_GROUP_MEMBER, id:, addressId: address_id, memberId: member_id),
+          method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/drafts.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Nextmail
+  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: Wire.with_attachments(payload(body, fields)), api_key:)
+      end
+
+      def update(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DRAFT, id:), method: :patch, body: Wire.with_attachments(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/nextmail/resources/emails.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Nextmail
+  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, since: nil,
+        until: nil, recipient: nil, tag: nil, limit: nil, cursor: nil, api_key: nil)
+        query = list_query(status, from, broadcast_id, scheduled_from, scheduled_to)
+          .merge(sent_query(since, binding.local_variable_get(:until), recipient, tag))
+        fetch_page(ApiPaths::EMAILS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all(status: nil, from: nil, broadcast_id: nil, scheduled_from: nil, scheduled_to: nil, since: nil,
+        until: nil, recipient: nil, tag: nil, limit: nil, cursor: nil, api_key: nil)
+        query = list_query(status, from, broadcast_id, scheduled_from, scheduled_to)
+          .merge(sent_query(since, binding.local_variable_get(:until), recipient, tag))
+        collect_all(ApiPaths::EMAILS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate(status: nil, from: nil, broadcast_id: nil, scheduled_from: nil, scheduled_to: nil, since: nil,
+        until: nil, recipient: nil, tag: nil, limit: nil, cursor: nil, api_key: nil, &)
+        query = list_query(status, from, broadcast_id, scheduled_from, scheduled_to)
+          .merge(sent_query(since, binding.local_variable_get(:until), recipient, tag))
+        iterate_pages(ApiPaths::EMAILS, query, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::EMAIL, id:), api_key:)
+      end
+
+      def list_events(id, address: nil, message_id: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::EMAIL_EVENTS, id:), query_params(address:, message_id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_events(id, address: nil, message_id: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::EMAIL_EVENTS, id:), query_params(address:, message_id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_events(id, address: nil, message_id: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::EMAIL_EVENTS, id:), query_params(address:, message_id:), limit:, cursor:,
+          api_key:, &)
+      end
+
+      def list_events_by_message_id(message_id, address: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::EMAILS_EVENTS, query_params(address:, message_id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_events_by_message_id(message_id, address: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::EMAILS_EVENTS, query_params(address:, message_id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_events_by_message_id(message_id, address: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::EMAILS_EVENTS, query_params(address:, message_id:), limit:, cursor:, api_key:, &)
+      end
+
+      def get_tracking(id, address: nil, api_key: nil)
+        request(fill(ApiPaths::EMAIL_TRACKING, id:), query: query_params(address:), 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
+
+      def sent_query(since, until_value, recipient, tag)
+        query_params(since: instant(since), until: instant(until_value), recipient:, tag:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/encryption.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nextmail
+  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

data/lib/nextmail/resources/events.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Events < Resource
+      def send(body = nil, idempotency_key: nil, api_key: nil, **fields)
+        request(ApiPaths::EVENTS, method: :post, body: payload(body, fields), idempotent: true, idempotency_key:,
+          repeatable: true, api_key:)
+      end
+
+      def send_batch(events, idempotency_key: nil, api_key: nil)
+        wire = events.map { |event| payload(event, {}) }
+        request(ApiPaths::EVENTS_BATCH, method: :post, body: {"events" => wire}, idempotent: true, idempotency_key:,
+          repeatable: true, api_key:)
+      end
+
+      def list_names(api_key: nil)
+        fetch_list(ApiPaths::EVENT_NAMES, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/exports.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Exports < Resource
+      def preview(api_key: nil)
+        request(ApiPaths::MAILBOX_EXPORTS_PREVIEW, api_key:)
+      end
+
+      def list(limit: nil, offset: nil, api_key: nil)
+        request(ApiPaths::MAILBOX_EXPORTS, query: query_params(limit:, offset:), api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::MAILBOX_EXPORT, id:), api_key:)
+      end
+
+      def start(api_key: nil)
+        request(ApiPaths::MAILBOX_EXPORTS, method: :post, api_key:)
+      end
+
+      def download(id, api_key: nil)
+        request(fill(ApiPaths::MAILBOX_EXPORT_CONTENT, id:), binary: true, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/files.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Files < Resource
+      def list(q: nil, kind: nil, direction: nil, address: nil, since: nil, until: nil, sort: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        query = list_query(q, kind, direction, address, since, binding.local_variable_get(:until), sort)
+        fetch_page(ApiPaths::FILES, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all(q: nil, kind: nil, direction: nil, address: nil, since: nil, until: nil, sort: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        query = list_query(q, kind, direction, address, since, binding.local_variable_get(:until), sort)
+        collect_all(ApiPaths::FILES, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate(q: nil, kind: nil, direction: nil, address: nil, since: nil, until: nil, sort: nil, limit: nil,
+        cursor: nil, api_key: nil, &)
+        query = list_query(q, kind, direction, address, since, binding.local_variable_get(:until), sort)
+        iterate_pages(ApiPaths::FILES, query, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::FILE, id:), api_key:)
+      end
+
+      def stats(api_key: nil)
+        request(ApiPaths::FILES_STATS, api_key:)
+      end
+
+      def download(id, api_key: nil)
+        request(fill(ApiPaths::FILE_CONTENT, id:), binary: true, api_key:)
+      end
+
+      def list_links(id, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::FILE_LINKS, id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_links(id, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::FILE_LINKS, id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_links(id, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::FILE_LINKS, id:), limit:, cursor:, api_key:, &)
+      end
+
+      def create_link(id, domain: nil, reuse: nil, api_key: nil)
+        body = (domain.nil? || domain == "") ? {} : {"domain" => domain}
+        body["reuse"] = reuse unless reuse.nil?
+        request(fill(ApiPaths::FILE_LINKS, id:), method: :post, body:, api_key:)
+      end
+
+      def revoke_link(id, link_id, api_key: nil)
+        request(fill(ApiPaths::FILE_LINK, id:, linkId: link_id), method: :delete, repeatable: true, api_key:)
+      end
+
+      def revoke_all_links(id, api_key: nil)
+        request(fill(ApiPaths::FILE_LINKS, id:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def upload(data, filename: nil, content_type: nil, timeout: nil, api_key: nil)
+        request(ApiPaths::FILES, method: :post, query: query_params(filename: upload_name(data, filename)), raw: data,
+          content_type: raw_content_type(data, content_type), timeout: upload_timeout(timeout), api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::FILE, id:), method: :delete, api_key:)
+      end
+
+      def delete_many(ids, api_key: nil)
+        request(ApiPaths::FILES_BATCH_DELETE, method: :post, body: {"ids" => ids}, api_key:)
+      end
+
+      private
+
+      def list_query(q, kind, direction, address, since, until_value, sort)
+        query_params(q:, kind:, direction:, address:, since: instant(since), until: instant(until_value), sort:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/follow_ups.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class FollowUps < Resource
+      def list(status: nil, thread_id: nil, limit: nil, api_key: nil)
+        fetch_list(ApiPaths::FOLLOW_UPS, query_params(status:, thread_id:, limit:), api_key:)
+      end
+
+      def set(body = nil, api_key: nil, **fields)
+        wire = payload(body, fields).slice("threadId", "remindAt")
+        wire["remindAt"] = instant(wire["remindAt"]) if wire.key?("remindAt")
+        request(ApiPaths::FOLLOW_UPS, method: :post, body: wire, repeatable: true, api_key:)
+      end
+
+      def cancel(id, api_key: nil)
+        request(fill(ApiPaths::FOLLOW_UP, id:), method: :delete, repeatable: true, api_key:)
+      end
+    end
+  end
+end