nextmail 0.0.1

data/lib/nextmail/resources/temp_mail.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class TempMail < Resource
+      def list_domains(inbox_token: nil)
+        envelope = request(ApiPaths::TEMP_MAIL_DOMAINS, anonymous: true)
+        Pagination.items_of(envelope.is_a?(Hash) ? envelope : {})
+      end
+
+      def create(body = nil, inbox_token: nil, **fields)
+        request(ApiPaths::TEMP_MAIL_INBOXES, method: :post, body: payload(body, fields), anonymous: true)
+      end
+
+      def get(inbox_id, inbox_token: nil)
+        request(fill(ApiPaths::TEMP_MAIL_INBOX, id: inbox_id), inbox_token:)
+      end
+
+      def extend(inbox_id, *modules, inbox_token: nil)
+        return super(inbox_id, *modules) if inbox_id.is_a?(Module)
+
+        request(fill(ApiPaths::TEMP_MAIL_INBOX_EXTEND, id: inbox_id), method: :post, inbox_token:)
+      end
+
+      def delete(inbox_id, inbox_token: nil)
+        request(fill(ApiPaths::TEMP_MAIL_INBOX, id: inbox_id), method: :delete, inbox_token:)
+      end
+
+      def list_messages(inbox_id, limit: nil, cursor: nil, inbox_token: nil)
+        envelope = request(fill(ApiPaths::TEMP_MAIL_MESSAGES, id: inbox_id), query: query_params(limit:, cursor:),
+          inbox_token:)
+        envelope = {} unless envelope.is_a?(Hash)
+        next_cursor = Pagination.cursor_of(envelope[:nextCursor])
+
+        TempMessagesPage.new(
+          items: Pagination.items_of(envelope),
+          has_more: Pagination.more?(envelope, next_cursor),
+          next_cursor:,
+          expires_at: envelope[:expiresAt]
+        )
+      end
+
+      def list_all_messages(inbox_id, limit: nil, cursor: nil, inbox_token: nil)
+        iterate_messages(inbox_id, limit:, cursor:, inbox_token:).to_a
+      end
+
+      def iterate_messages(inbox_id, limit: nil, cursor: nil, inbox_token: nil, &)
+        pages = Pagination.walk(cursor) { |current| list_messages(inbox_id, limit:, cursor: current, inbox_token:) }
+        each_or_enumerator(pages, &)
+      end
+
+      def get_message(inbox_id, message_id, inbox_token: nil)
+        request(fill(ApiPaths::TEMP_MAIL_MESSAGE, id: inbox_id, messageId: message_id), inbox_token:)
+      end
+
+      def delete_message(inbox_id, message_id, inbox_token: nil)
+        request(fill(ApiPaths::TEMP_MAIL_MESSAGE, id: inbox_id, messageId: message_id), method: :delete, inbox_token:)
+      end
+
+      def list_attachments(inbox_id, message_id, inbox_token: nil)
+        envelope = request(fill(ApiPaths::TEMP_MAIL_MESSAGE_ATTACHMENTS, id: inbox_id, messageId: message_id),
+          inbox_token:)
+        Pagination.items_of(envelope.is_a?(Hash) ? envelope : {})
+      end
+    end
+  end
+end

data/lib/nextmail/resources/templates.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Templates < Resource
+      def list(status: nil, search: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::TEMPLATES, query_params(status:, search:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(status: nil, search: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::TEMPLATES, query_params(status:, search:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(status: nil, search: nil, sort: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::TEMPLATES, query_params(status:, search:, sort:), limit:, cursor:, api_key:, &)
+      end
+
+      def list_starters(api_key: nil)
+        fetch_list(ApiPaths::TEMPLATE_STARTERS, api_key:)
+      end
+
+      def list_fonts(api_key: nil)
+        fetch_list(ApiPaths::TEMPLATE_FONTS, api_key:)
+      end
+
+      def get_starter(slug, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE_STARTER, slug:), api_key:)
+      end
+
+      def render(body = nil, api_key: nil, **fields)
+        request(ApiPaths::TEMPLATE_RENDER, method: :post, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def get(id_or_slug, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE, id: id_or_slug), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::TEMPLATES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id_or_slug, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE, id: id_or_slug), method: :patch, body: payload(patch, fields), api_key:)
+      end
+
+      def delete(id_or_slug, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE, id: id_or_slug), method: :delete, api_key:)
+      end
+
+      def duplicate(id_or_slug, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE_DUPLICATE, id: id_or_slug), method: :post, body: payload(body, fields),
+          api_key:)
+      end
+
+      def replace_content(id_or_slug, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE_CONTENT, id: id_or_slug), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_versions(id_or_slug, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::TEMPLATE_VERSIONS, id: id_or_slug), limit:, cursor:, api_key:)
+      end
+
+      def list_all_versions(id_or_slug, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::TEMPLATE_VERSIONS, id: id_or_slug), limit:, cursor:, api_key:)
+      end
+
+      def iterate_versions(id_or_slug, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::TEMPLATE_VERSIONS, id: id_or_slug), limit:, cursor:, api_key:, &)
+      end
+
+      def get_version(id_or_slug, version, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE_VERSION, id: id_or_slug, version:), api_key:)
+      end
+
+      def delete_version(id_or_slug, version, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE_VERSION, id: id_or_slug, version:), method: :delete, api_key:)
+      end
+
+      def restore_version(id_or_slug, version, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE_VERSION_RESTORE, id: id_or_slug, version:), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
+      def publish(id_or_slug, expected_version: nil, expected_updated_at: nil, api_key: nil)
+        expected = {"expectedVersion" => expected_version, "expectedUpdatedAt" => expected_updated_at}.compact
+        request(fill(ApiPaths::TEMPLATE_VERSIONS, id: id_or_slug), method: :post, body: expected.empty? ? nil : expected,
+          repeatable: true, api_key:)
+      end
+
+      def preview(id_or_slug, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE_PREVIEW, id: id_or_slug), method: :post, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def get_analytics(id_or_slug, days: nil, minutes: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE_ANALYTICS, id: id_or_slug), query: window_query(days, minutes, grain,
+          offset_minutes), api_key:)
+      end
+
+      def list_sends(id_or_slug, page: nil, page_size: nil, search: nil, source: nil, version: nil, opened: nil,
+        clicked: nil, tracked: nil, days: nil, minutes: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        query = window_query(days, minutes, grain, offset_minutes).merge(query_params(page:, page_size:, search:,
+          source:, version:, opened: flag(opened), clicked: flag(clicked), tracked: flag(tracked)))
+        envelope = request(fill(ApiPaths::TEMPLATE_SENDS, id: id_or_slug), query:, api_key:)
+        envelope = {} unless envelope.is_a?(Hash)
+
+        TemplateSends.new(
+          items: Pagination.items_of(envelope),
+          total: envelope[:total] || 0,
+          page: envelope[:page] || 1,
+          page_size: envelope[:pageSize] || 0
+        )
+      end
+
+      def send(id_or_slug, body = nil, idempotency_key: nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE_SEND, id: id_or_slug), method: :post, body: Wire.recipients(payload(body, fields)),
+          idempotent: true, idempotency_key:, repeatable: true, api_key:)
+      end
+
+      def list_images(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::TEMPLATE_IMAGES, limit:, cursor:, api_key:)
+      end
+
+      def list_all_images(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::TEMPLATE_IMAGES, limit:, cursor:, api_key:)
+      end
+
+      def iterate_images(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::TEMPLATE_IMAGES, limit:, cursor:, api_key:, &)
+      end
+
+      def upload_image(data, content_type: nil, crop: nil, api_key: nil)
+        request(ApiPaths::TEMPLATE_IMAGES, method: :post, query: crop_query(crop), raw: data,
+          content_type: raw_content_type(data, content_type), timeout: upload_timeout, api_key:)
+      end
+
+      def design(body = nil, api_key: nil, **fields)
+        request(ApiPaths::TEMPLATES_DESIGN, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def redesign(id_or_slug, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::TEMPLATE_REDESIGN, id: id_or_slug), method: :post, body: payload(body, fields),
+          api_key:)
+      end
+
+      private
+
+      def window_query(days, minutes, grain, offset_minutes)
+        query_params(days:, minutes:, grain:, offset_minutes:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/threads.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Threads < Resource
+      def list(folder: nil, query: nil, label_ids: nil, sort: nil, date_from: nil, date_to: nil, from_contacts: nil,
+        semantic: nil, category: nil, address: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::THREADS,
+          list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts, semantic, category, address),
+          style: PAGE_TOKEN, limit:, cursor:, api_key:)
+      end
+
+      def list_all(folder: nil, query: nil, label_ids: nil, sort: nil, date_from: nil, date_to: nil,
+        from_contacts: nil, semantic: nil, category: nil, address: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::THREADS,
+          list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts, semantic, category, address),
+          style: PAGE_TOKEN, limit:, cursor:, api_key:)
+      end
+
+      def iterate(folder: nil, query: nil, label_ids: nil, sort: nil, date_from: nil, date_to: nil, from_contacts: nil,
+        semantic: nil, category: nil, address: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::THREADS,
+          list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts, semantic, category, address),
+          style: PAGE_TOKEN, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::THREAD, id:), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::THREAD, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def trash(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_TRASH, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def snooze(id, wake_at, api_key: nil)
+        request(fill(ApiPaths::THREAD_SNOOZE, id:), method: :post, body: {"wakeAt" => instant(wake_at)},
+          repeatable: true, api_key:)
+      end
+
+      def unsnooze(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_UNSNOOZE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def mute(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_MUTE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def unmute(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_UNMUTE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def list_messages(id, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_MESSAGES, id:), api_key:)
+      end
+
+      def get_message(id, message_id, api_key: nil)
+        request(fill(ApiPaths::THREAD_MESSAGE, id:, messageId: message_id), api_key:)
+      end
+
+      def get_raw_message(id, message_id, api_key: nil)
+        request(fill(ApiPaths::THREAD_MESSAGE_RAW, id:, messageId: message_id), binary: true, api_key:)
+      end
+
+      def list_attachments(id, message_id, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_MESSAGE_ATTACHMENTS, id:, messageId: message_id), api_key:)
+      end
+
+      def list_file_links(id, message_id, include_revoked: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::THREAD_MESSAGE_FILE_LINKS, id:, messageId: message_id),
+          file_link_query(include_revoked), limit:, cursor:, api_key:)
+      end
+
+      def list_all_file_links(id, message_id, include_revoked: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::THREAD_MESSAGE_FILE_LINKS, id:, messageId: message_id),
+          file_link_query(include_revoked), limit:, cursor:, api_key:)
+      end
+
+      def iterate_file_links(id, message_id, include_revoked: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::THREAD_MESSAGE_FILE_LINKS, id:, messageId: message_id),
+          file_link_query(include_revoked), limit:, cursor:, api_key:, &)
+      end
+
+      def list_tracking(id, address: nil, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_TRACKING, id:), query_params(address:), api_key:)
+      end
+
+      def get_delivery(id, address: nil, api_key: nil)
+        request(fill(ApiPaths::THREAD_DELIVERY, id:), query: query_params(address:), api_key:)
+      end
+
+      def get_event(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_EVENT, id:), api_key:)
+      end
+
+      def list_notes(id, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_NOTES, id:), api_key:)
+      end
+
+      def create_note(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::THREAD_NOTES, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update_note(id, note_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::THREAD_NOTE, id:, noteId: note_id), method: :patch, body: payload(patch, fields),
+          repeatable: true, api_key:)
+      end
+
+      def delete_note(id, note_id, api_key: nil)
+        request(fill(ApiPaths::THREAD_NOTE, id:, noteId: note_id), method: :delete, api_key:)
+      end
+
+      def reorder_notes(id, ids, api_key: nil)
+        envelope = request(fill(ApiPaths::THREAD_NOTES_REORDER, id:), method: :post, body: {"ids" => ids},
+          repeatable: true, api_key:)
+        Pagination.items_of(envelope.is_a?(Hash) ? envelope : {})
+      end
+
+      def counts(address: nil, hide_labelled: nil, api_key: nil)
+        request(ApiPaths::THREADS_COUNTS, query: query_params(address:, hide_labelled: flag(hide_labelled)), api_key:)
+      end
+
+      def summary(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_SUMMARY, id:), api_key:)
+      end
+
+      def reply_suggestions(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_REPLY_SUGGESTIONS, id:), api_key:)
+      end
+
+      def restore(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_RESTORE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::THREAD, id:), method: :delete, api_key:)
+      end
+
+      def unsubscribe(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_UNSUBSCRIBE, id:), method: :post, api_key:)
+      end
+
+      def list_sender_categories(api_key: nil)
+        fetch_list(ApiPaths::SENDER_CATEGORIES, api_key:)
+      end
+
+      def set_sender_category(email, category, api_key: nil)
+        request(fill(ApiPaths::SENDER_CATEGORY, email:), method: :put, body: {"category" => category},
+          repeatable: true, api_key:)
+      end
+
+      def clear_sender_category(email, api_key: nil)
+        request(fill(ApiPaths::SENDER_CATEGORY, email:), method: :delete, api_key:)
+      end
+
+      def get_team(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_TEAM, id:), api_key:)
+      end
+
+      def assign(id, assignee_id, api_key: nil)
+        request(fill(ApiPaths::THREAD_ASSIGNEE, id:), method: :put, body: {"assigneeId" => assignee_id},
+          repeatable: true, api_key:)
+      end
+
+      def unassign(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_ASSIGNEE, id:), method: :delete, api_key:)
+      end
+
+      def set_replying(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_REPLYING, id:), method: :put, repeatable: true, api_key:)
+      end
+
+      def clear_replying(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_REPLYING, id:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def mark_done(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_DONE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def reopen(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_REOPEN, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def list_comments(id, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_COMMENTS, id:), api_key:)
+      end
+
+      def create_comment(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::THREAD_COMMENTS, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update_comment(id, comment_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::THREAD_COMMENT, id:, commentId: comment_id), method: :patch,
+          body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def delete_comment(id, comment_id, api_key: nil)
+        request(fill(ApiPaths::THREAD_COMMENT, id:, commentId: comment_id), method: :delete, api_key:)
+      end
+
+      private
+
+      def list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts, semantic, category, address)
+        query_params(folder:, query:, label_ids: joined(label_ids), sort:, date_from: instant(date_from),
+          date_to: instant(date_to), from_contacts: flag(from_contacts), semantic: flag(semantic), category:,
+          address:)
+      end
+
+      def file_link_query(include_revoked)
+        query_params(include_revoked: flag(include_revoked))
+      end
+    end
+  end
+end

data/lib/nextmail/resources/tools.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Tools < Resource
+      def check_dmarc(domain, api_key: nil)
+        request(ApiPaths::TOOLS_DMARC, query: query_params(domain:), api_key:)
+      end
+
+      def check_bimi(domain, api_key: nil)
+        request(ApiPaths::TOOLS_BIMI, query: query_params(domain:), api_key:)
+      end
+
+      def check_deliverability(domain, api_key: nil)
+        request(ApiPaths::TOOLS_DELIVERABILITY, query: query_params(domain:), api_key:)
+      end
+
+      def read_verification_code(body = nil, api_key: nil, **fields)
+        request(ApiPaths::TOOLS_VERIFICATION_CODE, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def check_address(email, deep: nil, api_key: nil)
+        request(ApiPaths::TOOLS_ADDRESS, query: query_params(email:, deep: flag(deep)), api_key:)
+      end
+
+      def check_addresses(body = nil, api_key: nil, **fields)
+        request(ApiPaths::TOOLS_ADDRESSES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def estimate_cost(sends: nil, domains: nil, people: nil, ai_actions: nil, interval: nil, api_key: nil)
+        request(ApiPaths::TOOLS_COST, query: query_params(sends:, domains:, people:, ai_actions:, interval:), api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/tracking.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Tracking < Resource
+      def list(opened: nil, clicked: nil, days: nil, minutes: nil, grain: nil, offset_minutes: nil, address: nil,
+        limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::TRACKING, list_query(opened, clicked, days, minutes, grain, offset_minutes, address),
+          limit:, cursor:, api_key:)
+      end
+
+      def list_all(opened: nil, clicked: nil, days: nil, minutes: nil, grain: nil, offset_minutes: nil, address: nil,
+        limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::TRACKING, list_query(opened, clicked, days, minutes, grain, offset_minutes, address),
+          limit:, cursor:, api_key:)
+      end
+
+      def iterate(opened: nil, clicked: nil, days: nil, minutes: nil, grain: nil, offset_minutes: nil, address: nil,
+        limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::TRACKING, list_query(opened, clicked, days, minutes, grain, offset_minutes, address),
+          limit:, cursor:, api_key:, &)
+      end
+
+      def get_stats(days: nil, minutes: nil, grain: nil, offset_minutes: nil, address: nil, api_key: nil)
+        request(ApiPaths::TRACKING_STATS, query: query_params(days:, minutes:, grain:, offset_minutes:, address:),
+          api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::TRACKED, id:), api_key:)
+      end
+
+      def list_opens(id, include_machine: nil, address: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::TRACKED_OPENS, id:), hit_query(include_machine, address), limit:, cursor:, api_key:)
+      end
+
+      def list_all_opens(id, include_machine: nil, address: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::TRACKED_OPENS, id:), hit_query(include_machine, address), limit:, cursor:,
+          api_key:)
+      end
+
+      def iterate_opens(id, include_machine: nil, address: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::TRACKED_OPENS, id:), hit_query(include_machine, address), limit:, cursor:,
+          api_key:, &)
+      end
+
+      def list_clicks(id, include_machine: nil, address: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::TRACKED_CLICKS, id:), hit_query(include_machine, address), limit:, cursor:, api_key:)
+      end
+
+      def list_all_clicks(id, include_machine: nil, address: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::TRACKED_CLICKS, id:), hit_query(include_machine, address), limit:, cursor:,
+          api_key:)
+      end
+
+      def iterate_clicks(id, include_machine: nil, address: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::TRACKED_CLICKS, id:), hit_query(include_machine, address), limit:, cursor:,
+          api_key:, &)
+      end
+
+      private
+
+      def list_query(opened, clicked, days, minutes, grain, offset_minutes, address)
+        query_params(opened: flag(opened), clicked: flag(clicked), days:, minutes:, grain:, offset_minutes:, address:)
+      end
+
+      def hit_query(include_machine, address)
+        query_params(include_machine: flag(include_machine), address:)
+      end
+    end
+  end
+end