openemail 0.0.1

data/lib/openemail/resources/rules.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Rules < Resource
+      def list(enabled: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::RULES, query_params(enabled: flag(enabled)), limit:, cursor:, api_key:)
+      end
+
+      def list_all(enabled: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::RULES, query_params(enabled: flag(enabled)), limit:, cursor:, api_key:)
+      end
+
+      def iterate(enabled: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::RULES, query_params(enabled: flag(enabled)), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::RULE, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::RULES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::RULE, id:), method: :patch, body: payload(patch, fields), api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::RULE, id:), method: :delete, api_key:)
+      end
+
+      def reorder(rule_ids, api_key: nil)
+        envelope = request(ApiPaths::RULES_REORDER, method: :post, body: {"ruleIds" => rule_ids}, repeatable: true,
+          api_key:)
+        Pagination.items_of(envelope.is_a?(Hash) ? envelope : {})
+      end
+
+      def test(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::RULE_TEST, id:), method: :post, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def list_runs(rule_id: nil, thread_id: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::RULE_RUNS, query_params(rule_id:, thread_id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_runs(rule_id: nil, thread_id: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::RULE_RUNS, query_params(rule_id:, thread_id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_runs(rule_id: nil, thread_id: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::RULE_RUNS, query_params(rule_id:, thread_id:), limit:, cursor:, api_key:, &)
+      end
+    end
+  end
+end

data/lib/openemail/resources/security.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Security < Resource
+      def step_up_status(api_key: nil)
+        request(ApiPaths::SECURITY_STEP_UP, api_key:)
+      end
+
+      def begin_step_up(body = nil, api_key: nil, **fields)
+        request(ApiPaths::SECURITY_STEP_UP, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def verify_step_up(body = nil, api_key: nil, **fields)
+        request(ApiPaths::SECURITY_STEP_UP_VERIFY, method: :post, body: payload(body, fields), api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/senders.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Senders < Resource
+      def get(email, api_key: nil)
+        request(fill(ApiPaths::SENDER, email:), api_key:)
+      end
+
+      def research(email, api_key: nil)
+        request(fill(ApiPaths::SENDER_RESEARCH, email:), method: :post, repeatable: true, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/settings.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Settings < Resource
+      def get(address: nil, api_key: nil)
+        request(ApiPaths::SETTINGS, query: query_params(address:), api_key:)
+      end
+
+      def update(patch = nil, address: nil, api_key: nil, **fields)
+        request(ApiPaths::SETTINGS, method: :patch, query: query_params(address:), body: payload(patch, fields),
+          repeatable: true, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/subscriptions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Subscriptions < Resource
+      def list(status: nil, q: nil, sort: nil, limit: nil, offset: nil, address: nil, api_key: nil)
+        request(ApiPaths::SUBSCRIPTIONS, query: query_params(status:, q:, sort:, limit:, offset:, address:), api_key:)
+      end
+
+      def list_domains(status: nil, q: nil, sort: nil, limit: nil, offset: nil, address: nil, api_key: nil)
+        request(ApiPaths::SUBSCRIPTION_DOMAINS, query: query_params(status:, q:, sort:, limit:, offset:, address:),
+          api_key:)
+      end
+
+      def unsubscribe(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::SUBSCRIPTION_UNSUBSCRIBE, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def unsubscribe_domain(domain, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::SUBSCRIPTION_DOMAIN_UNSUBSCRIBE, domain:), method: :post, body: payload(body, fields),
+          api_key:)
+      end
+
+      def move(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::SUBSCRIPTION_MOVE, id:), method: :post, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/support.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Support < Resource
+      def send(body = nil, api_key: nil, **fields)
+        request(ApiPaths::SUPPORT, method: :post, body: payload(body, fields), api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/suppressions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Suppressions < Resource
+      def list(q: nil, reason: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::SUPPRESSIONS, query_params(q:, reason:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(q: nil, reason: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::SUPPRESSIONS, query_params(q:, reason:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(q: nil, reason: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::SUPPRESSIONS, query_params(q:, reason:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::SUPPRESSION, id:), api_key:)
+      end
+
+      def add(body = nil, api_key: nil, **fields)
+        request(ApiPaths::SUPPRESSIONS, method: :post, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def remove(id, api_key: nil)
+        request(fill(ApiPaths::SUPPRESSION, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/temp_mail.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  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/openemail/resources/templates.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  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, api_key: nil)
+        request(fill(ApiPaths::TEMPLATE_VERSIONS, id: id_or_slug), method: :post, 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, api_key: nil)
+        request(ApiPaths::TEMPLATE_IMAGES, method: :post, raw: data, content_type: raw_content_type(data, content_type),
+          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/openemail/resources/threads.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  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,
+        limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::THREADS, list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts),
+          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, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::THREADS, list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts),
+          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,
+        limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::THREADS, list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts),
+          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 list_attachments(id, message_id, api_key: nil)
+        fetch_list(fill(ApiPaths::THREAD_MESSAGE_ATTACHMENTS, id:, messageId: message_id), 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, api_key: nil)
+        request(ApiPaths::THREADS_COUNTS, query: query_params(address:), api_key:)
+      end
+
+      def summary(id, api_key: nil)
+        request(fill(ApiPaths::THREAD_SUMMARY, 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
+
+      private
+
+      def list_query(folder, query, label_ids, sort, date_from, date_to, from_contacts)
+        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))
+      end
+    end
+  end
+end

data/lib/openemail/resources/tools.rb

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

data/lib/openemail/resources/tracking.rb

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