nextmail 0.0.1

data/lib/nextmail/resources/forms.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Forms < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::FORMS, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::FORMS, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::FORMS, limit:, cursor:, api_key:, &)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::FORMS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def design(body = nil, api_key: nil, **fields)
+        request(ApiPaths::FORMS_DESIGN, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def redesign(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::FORM_REDESIGN, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_starters(api_key: nil)
+        fetch_list(ApiPaths::FORM_STARTERS, api_key:)
+      end
+
+      def get_starter(slug, api_key: nil)
+        request(fill(ApiPaths::FORM_STARTER, slug:), api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::FORM, id:), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::FORM, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::FORM, id:), method: :delete, api_key:)
+      end
+
+      def publish(id, api_key: nil)
+        request(fill(ApiPaths::FORM_PUBLISH, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def pause(id, api_key: nil)
+        request(fill(ApiPaths::FORM_PAUSE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def resume(id, api_key: nil)
+        request(fill(ApiPaths::FORM_RESUME, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def duplicate(id, api_key: nil)
+        request(fill(ApiPaths::FORM_DUPLICATE, id:), method: :post, api_key:)
+      end
+
+      def analytics(id, days: nil, minutes: nil, since: nil, until: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        query = query_params(days:, minutes:, grain:, offset_minutes:)
+          .merge(log_window_query(since, binding.local_variable_get(:until)))
+        request(fill(ApiPaths::FORM_ANALYTICS, id:), query:, api_key:)
+      end
+
+      def list_submissions(id, q: nil, status: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::FORM_SUBMISSIONS, id:), query_params(q:, status:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_submissions(id, q: nil, status: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::FORM_SUBMISSIONS, id:), query_params(q:, status:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_submissions(id, q: nil, status: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::FORM_SUBMISSIONS, id:), query_params(q:, status:), limit:, cursor:, api_key:, &)
+      end
+
+      def get_submission(id, submission_id, api_key: nil)
+        request(fill(ApiPaths::FORM_SUBMISSION, id:, submissionId: submission_id), api_key:)
+      end
+
+      def delete_submission(id, submission_id, api_key: nil)
+        request(fill(ApiPaths::FORM_SUBMISSION, id:, submissionId: submission_id), method: :delete, api_key:)
+      end
+
+      def delete_submissions(id, submission_ids, api_key: nil)
+        request(fill(ApiPaths::FORM_SUBMISSIONS_BATCH_REMOVE, id:), method: :post, body: {"ids" => submission_ids},
+          api_key:)
+      end
+
+      def approve_submission(id, submission_id, api_key: nil)
+        request(fill(ApiPaths::FORM_SUBMISSION_APPROVE, id:, submissionId: submission_id), method: :post,
+          repeatable: true, api_key:)
+      end
+
+      def resend_confirmation(id, submission_id, api_key: nil)
+        request(fill(ApiPaths::FORM_SUBMISSION_RESEND, id:, submissionId: submission_id), method: :post, api_key:)
+      end
+
+      def subscribe(form_id, values = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::SUBSCRIBE_FORM, formId: form_id), method: :post, body: payload(values, fields),
+          anonymous: true, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/imports.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Imports < Resource
+      def list(address_id: nil, source: nil, status: nil, search: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::IMPORTS, list_query(address_id, source, status, search), limit:, cursor:, api_key:)
+      end
+
+      def list_all(address_id: nil, source: nil, status: nil, search: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::IMPORTS, list_query(address_id, source, status, search), limit:, cursor:, api_key:)
+      end
+
+      def iterate(address_id: nil, source: nil, status: nil, search: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::IMPORTS, list_query(address_id, source, status, search), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::IMPORT, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::IMPORTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def upload_state(id, api_key: nil)
+        request(fill(ApiPaths::IMPORT_UPLOAD, id:), api_key:)
+      end
+
+      def upload_chunk(id, file, chunk, data, api_key: nil)
+        request(fill(ApiPaths::IMPORT_FILE_CHUNK, id:, file:, chunk:), method: :put, raw: data, repeatable: true,
+          api_key:)
+      end
+
+      def start(id, api_key: nil)
+        request(fill(ApiPaths::IMPORT_START, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def cancel(id, api_key: nil)
+        request(fill(ApiPaths::IMPORT_CANCEL, id:), method: :post, api_key:)
+      end
+
+      def list_failures(id, after: nil, limit: nil, api_key: nil)
+        request(fill(ApiPaths::IMPORT_FAILURES, id:), query: {"after" => after, "limit" => limit}, api_key:)
+      end
+
+      def delete_upload(id, api_key: nil)
+        request(fill(ApiPaths::IMPORT_UPLOAD, id:), method: :delete, api_key:)
+      end
+
+      def discover_mailbox(email, api_key: nil)
+        request(ApiPaths::IMPORT_MAILBOX_SETTINGS, query: query_params(email:), api_key:)
+      end
+
+      def check_mailbox(body = nil, api_key: nil, **fields)
+        request(ApiPaths::IMPORT_MAILBOX_CHECK, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def connect_mailbox(body = nil, api_key: nil, **fields)
+        request(ApiPaths::IMPORT_MAILBOX, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def resume(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::IMPORT_RESUME, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def import_files(input = nil, api_key: nil, **fields, &on_progress)
+        spec = payload(input, fields)
+        files = Array(spec["files"]).map { |file| file.to_h.transform_keys(&:to_s) }
+        created = create(import_body(spec, files), api_key:)
+        return created if files.empty?
+
+        upload_files(created, files, on_progress || spec["onProgress"], api_key)
+        start(created[:id], api_key:)
+      end
+
+      private
+
+      def list_query(address_id, source, status, search)
+        {"addressId" => address_id}.merge(query_params(source:, status:, search:))
+      end
+
+      def import_body(spec, files)
+        sizes = files.map { |file| {"name" => file["name"], "bytes" => RawBody.size(file["data"])} }
+        spec.slice("addressId", "options").merge("files" => sizes)
+      end
+
+      def upload_files(created, files, progress, api_key)
+        uploaded = 0
+
+        files.each_with_index do |file, index|
+          size = RawBody.size(file["data"])
+          chunks = created.dig(:files, index, :chunks) || 1
+
+          chunks.times do |chunk|
+            offset = chunk * created[:chunkBytes]
+            length = [size, offset + created[:chunkBytes]].min - offset
+            upload_chunk(created[:id], index, chunk, RawBody.slice(file["data"], offset, length), api_key:)
+            uploaded += length
+            progress&.call(uploaded, created[:totalBytes])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nextmail/resources/keys.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Keys < Resource
+      def list(q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::KEYS, query_params(q:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::KEYS, query_params(q:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::KEYS, query_params(q:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::KEY, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::KEYS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::KEY, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::KEY, id:), method: :delete, api_key:)
+      end
+
+      def rotate(id, api_key: nil)
+        request(fill(ApiPaths::KEY_ROTATE, id:), method: :post, api_key:)
+      end
+
+      def revoke(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::KEY_REVOKE, id:), method: :post, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      def list_requests(id, failed_only: nil, statuses: nil, path: nil, since: nil, until: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        query = log_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path)
+        fetch_page(fill(ApiPaths::KEY_REQUESTS, id:), query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_requests(id, failed_only: nil, statuses: nil, path: nil, since: nil, until: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        query = log_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path)
+        collect_all(fill(ApiPaths::KEY_REQUESTS, id:), query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_requests(id, failed_only: nil, statuses: nil, path: nil, since: nil, until: nil, limit: nil,
+        cursor: nil, api_key: nil, &)
+        query = log_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path)
+        iterate_pages(fill(ApiPaths::KEY_REQUESTS, id:), query, limit:, cursor:, api_key:, &)
+      end
+
+      def list_activity(id, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        fetch_page(fill(ApiPaths::KEY_ACTIVITY, id:), query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_activity(id, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        collect_all(fill(ApiPaths::KEY_ACTIVITY, id:), query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_activity(id, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil, &)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        iterate_pages(fill(ApiPaths::KEY_ACTIVITY, id:), query, limit:, cursor:, api_key:, &)
+      end
+
+      def list_workspace_requests(key_ids: nil, failed_only: nil, statuses: nil, path: nil, since: nil, until: nil,
+        limit: nil, cursor: nil, api_key: nil)
+        query = workspace_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path, key_ids)
+        fetch_page(ApiPaths::KEYS_REQUESTS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_workspace_requests(key_ids: nil, failed_only: nil, statuses: nil, path: nil, since: nil, until: nil,
+        limit: nil, cursor: nil, api_key: nil)
+        query = workspace_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path, key_ids)
+        collect_all(ApiPaths::KEYS_REQUESTS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_workspace_requests(key_ids: nil, failed_only: nil, statuses: nil, path: nil, since: nil, until: nil,
+        limit: nil, cursor: nil, api_key: nil, &)
+        query = workspace_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path, key_ids)
+        iterate_pages(ApiPaths::KEYS_REQUESTS, query, limit:, cursor:, api_key:, &)
+      end
+
+      def list_workspace_activity(key_ids: nil, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = workspace_activity_query(since, binding.local_variable_get(:until), key_ids)
+        fetch_page(ApiPaths::KEYS_ACTIVITY, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_workspace_activity(key_ids: nil, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = workspace_activity_query(since, binding.local_variable_get(:until), key_ids)
+        collect_all(ApiPaths::KEYS_ACTIVITY, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_workspace_activity(key_ids: nil, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil, &)
+        query = workspace_activity_query(since, binding.local_variable_get(:until), key_ids)
+        iterate_pages(ApiPaths::KEYS_ACTIVITY, query, limit:, cursor:, api_key:, &)
+      end
+
+      def stats(key_ids: nil, since: nil, until: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until))
+          .merge(query_params(key_ids: joined(key_ids), grain:, offset_minutes:))
+        request(ApiPaths::KEYS_STATS, query:, api_key:)
+      end
+
+      private
+
+      def workspace_request_query(since, until_value, failed_only, statuses, path, key_ids)
+        log_request_query(since, until_value, failed_only, statuses, path).merge(query_params(key_ids: joined(key_ids)))
+      end
+
+      def workspace_activity_query(since, until_value, key_ids)
+        log_window_query(since, until_value).merge(query_params(key_ids: joined(key_ids)))
+      end
+    end
+  end
+end

data/lib/nextmail/resources/knowledge.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Knowledge < Resource
+      def list(scope: nil, level: nil, kind: nil, status: nil, pinned: nil, q: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        fetch_page(ApiPaths::KNOWLEDGE, list_query(scope, level, kind, status, pinned, q), limit:, cursor:, api_key:)
+      end
+
+      def list_all(scope: nil, level: nil, kind: nil, status: nil, pinned: nil, q: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        collect_all(ApiPaths::KNOWLEDGE, list_query(scope, level, kind, status, pinned, q), limit:, cursor:, api_key:)
+      end
+
+      def iterate(scope: nil, level: nil, kind: nil, status: nil, pinned: nil, q: nil, limit: nil, cursor: nil,
+        api_key: nil, &)
+        iterate_pages(ApiPaths::KNOWLEDGE, list_query(scope, level, kind, status, pinned, q), limit:, cursor:,
+          api_key:, &)
+      end
+
+      def levels(api_key: nil)
+        fetch_list(ApiPaths::KNOWLEDGE_LEVELS, api_key:)
+      end
+
+      def usage(api_key: nil)
+        request(ApiPaths::KNOWLEDGE_USAGE, api_key:)
+      end
+
+      def search(body = nil, api_key: nil, **fields)
+        request(ApiPaths::KNOWLEDGE_SEARCH, method: :post, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def create_note(body = nil, api_key: nil, **fields)
+        request(ApiPaths::KNOWLEDGE_NOTES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def add_link(body = nil, api_key: nil, **fields)
+        request(ApiPaths::KNOWLEDGE_LINKS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def upload_file(data, filename: nil, content_type: nil, scope: nil, title: nil, timeout: nil, api_key: nil)
+        query = query_params(filename: upload_name(data, filename), scope:, title:)
+        request(ApiPaths::KNOWLEDGE_FILES, method: :post, query:, raw: data,
+          content_type: raw_content_type(data, content_type), timeout: upload_timeout(timeout), api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_ITEM, id:), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::KNOWLEDGE_ITEM, id:), method: :patch, body: payload(patch, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_ITEM, id:), method: :delete, api_key:)
+      end
+
+      def refresh(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_ITEM_REFRESH, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def stats(days: nil, api_key: nil)
+        request(ApiPaths::KNOWLEDGE_STATS, query: query_params(days:), api_key:)
+      end
+
+      def list_suggestions(kind: nil, status: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::KNOWLEDGE_SUGGESTIONS, suggestion_query(kind, status), limit:, cursor:, api_key:)
+      end
+
+      def list_all_suggestions(kind: nil, status: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::KNOWLEDGE_SUGGESTIONS, suggestion_query(kind, status), limit:, cursor:, api_key:)
+      end
+
+      def iterate_suggestions(kind: nil, status: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::KNOWLEDGE_SUGGESTIONS, suggestion_query(kind, status), limit:, cursor:, api_key:, &)
+      end
+
+      def accept_suggestion(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::KNOWLEDGE_SUGGESTION_ACCEPT, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def dismiss_suggestion(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_SUGGESTION_DISMISS, id:), method: :post, api_key:)
+      end
+
+      def list_flags(item_id: nil, limit: nil, api_key: nil)
+        fetch_list(ApiPaths::KNOWLEDGE_FLAGS, query_params(item_id:, limit:), api_key:)
+      end
+
+      def dismiss_flag(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_FLAG_DISMISS, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def list_connectors(api_key: nil)
+        fetch_list(ApiPaths::KNOWLEDGE_CONNECTORS, api_key:)
+      end
+
+      def add_connector(body = nil, api_key: nil, **fields)
+        request(ApiPaths::KNOWLEDGE_CONNECTORS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def get_connector(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_CONNECTOR, id:), api_key:)
+      end
+
+      def update_connector(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::KNOWLEDGE_CONNECTOR, id:), method: :patch, body: payload(patch, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete_connector(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_CONNECTOR, id:), method: :delete, api_key:)
+      end
+
+      def sync_connector(id, api_key: nil)
+        request(fill(ApiPaths::KNOWLEDGE_CONNECTOR_SYNC, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def draft_from_thread(body = nil, api_key: nil, **fields)
+        request(ApiPaths::KNOWLEDGE_DRAFTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      private
+
+      def list_query(scope, level, kind, status, pinned, q)
+        query_params(scope:, level:, kind:, status:, pinned: flag(pinned), q:)
+      end
+
+      def suggestion_query(kind, status)
+        query_params(kind:, status:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/labels.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Labels < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::LABELS, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::LABELS, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::LABELS, limit:, cursor:, api_key:, &)
+      end
+
+      def list_colors(api_key: nil)
+        fetch_list(ApiPaths::LABEL_COLORS, api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::LABEL, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::LABELS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::LABEL, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def test(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::LABEL_TEST, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::LABEL, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/languages.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Languages < Resource
+      def list(api_key: nil)
+        fetch_list(ApiPaths::LANGUAGES, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/me.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Me < Resource
+      def get(api_key: nil)
+        request(ApiPaths::KEY_SELF, api_key:)
+      end
+
+      def ping(api_key: nil)
+        request(ApiPaths::PING, api_key:)
+      end
+
+      def rotate(api_key: nil)
+        request(ApiPaths::KEY_SELF_ROTATE, method: :post, api_key:)
+      end
+
+      def list_requests(failed_only: nil, statuses: nil, path: nil, since: nil, until: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = log_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path)
+        fetch_page(ApiPaths::KEY_SELF_REQUESTS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_requests(failed_only: nil, statuses: nil, path: nil, since: nil, until: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = log_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path)
+        collect_all(ApiPaths::KEY_SELF_REQUESTS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_requests(failed_only: nil, statuses: nil, path: nil, since: nil, until: nil, limit: nil, cursor: nil,
+        api_key: nil, &)
+        query = log_request_query(since, binding.local_variable_get(:until), failed_only, statuses, path)
+        iterate_pages(ApiPaths::KEY_SELF_REQUESTS, query, limit:, cursor:, api_key:, &)
+      end
+
+      def list_activity(since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        fetch_page(ApiPaths::KEY_SELF_ACTIVITY, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_activity(since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        collect_all(ApiPaths::KEY_SELF_ACTIVITY, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_activity(since: nil, until: nil, limit: nil, cursor: nil, api_key: nil, &)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        iterate_pages(ApiPaths::KEY_SELF_ACTIVITY, query, limit:, cursor:, api_key:, &)
+      end
+
+      def stats(since: nil, until: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until)).merge(query_params(grain:, offset_minutes:))
+        request(ApiPaths::KEY_SELF_STATS, query:, api_key:)
+      end
+    end
+  end
+end