openemail 0.0.1

data/lib/openemail/resources/exports.rb

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  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, api_key: nil)
+        body = (domain.nil? || domain == "") ? {} : {"domain" => domain}
+        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
+
+      def upload_name(data, filename)
+        name = (filename.nil? ? RawBody.file_name(data) : filename).to_s.strip
+        raise ArgumentError, Defaults::MESSAGES[:FILENAME_REQUIRED] if name.empty?
+
+        name
+      end
+
+      def upload_timeout(timeout)
+        return timeout unless timeout.nil?
+
+        base = @transport.timeout
+        base.to_f.positive? ? [base, Defaults::UPLOAD_TIMEOUT].max : base
+      end
+    end
+  end
+end

data/lib/openemail/resources/forms.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  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, grain: nil, offset_minutes: nil, api_key: nil)
+        request(fill(ApiPaths::FORM_ANALYTICS, id:), query: query_params(days:, minutes:, grain:, offset_minutes:),
+          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/openemail/resources/imports.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Imports < Resource
+      def list(address_id: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::IMPORTS, {"addressId" => address_id}, limit:, cursor:, api_key:)
+      end
+
+      def list_all(address_id: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::IMPORTS, {"addressId" => address_id}, limit:, cursor:, api_key:)
+      end
+
+      def iterate(address_id: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::IMPORTS, {"addressId" => address_id}, 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 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 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/openemail/resources/keys.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Keys < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::KEYS, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::KEYS, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::KEYS, 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, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = request_query(since, binding.local_variable_get(:until), failed_only)
+        fetch_page(fill(ApiPaths::KEY_REQUESTS, id:), query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_requests(id, failed_only: nil, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
+        query = request_query(since, binding.local_variable_get(:until), failed_only)
+        collect_all(fill(ApiPaths::KEY_REQUESTS, id:), query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_requests(id, failed_only: nil, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil, &)
+        query = request_query(since, binding.local_variable_get(:until), failed_only)
+        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 = 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 = 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 = 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, since: nil, until: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = workspace_request_query(since, binding.local_variable_get(:until), failed_only, key_ids)
+        fetch_page(ApiPaths::KEYS_REQUESTS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_workspace_requests(key_ids: nil, failed_only: nil, since: nil, until: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        query = workspace_request_query(since, binding.local_variable_get(:until), failed_only, key_ids)
+        collect_all(ApiPaths::KEYS_REQUESTS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_workspace_requests(key_ids: nil, failed_only: nil, since: nil, until: nil, limit: nil, cursor: nil,
+        api_key: nil, &)
+        query = workspace_request_query(since, binding.local_variable_get(:until), failed_only, 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 = window_query(since, binding.local_variable_get(:until)).merge(query_params(key_ids: joined(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 = window_query(since, binding.local_variable_get(:until)).merge(query_params(key_ids: joined(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 = window_query(since, binding.local_variable_get(:until)).merge(query_params(key_ids: joined(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 = 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 window_query(since, until_value)
+        query_params(since: instant(since), until: instant(until_value))
+      end
+
+      def request_query(since, until_value, failed_only)
+        window_query(since, until_value).merge(query_params(failed_only: flag(failed_only)))
+      end
+
+      def workspace_request_query(since, until_value, failed_only, key_ids)
+        request_query(since, until_value, failed_only).merge(query_params(key_ids: joined(key_ids)))
+      end
+    end
+  end
+end

data/lib/openemail/resources/labels.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  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 delete(id, api_key: nil)
+        request(fill(ApiPaths::LABEL, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/languages.rb

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

data/lib/openemail/resources/me.rb

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

data/lib/openemail/resources/members.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Members < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::MEMBERS, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::MEMBERS, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::MEMBERS, limit:, cursor:, api_key:, &)
+      end
+
+      def get(user_id, api_key: nil)
+        request(fill(ApiPaths::MEMBER, userId: user_id), api_key:)
+      end
+
+      def add(body = nil, api_key: nil, **fields)
+        request(ApiPaths::MEMBERS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(user_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::MEMBER, userId: user_id), method: :patch, body: payload(patch, fields),
+          repeatable: true, api_key:)
+      end
+
+      def remove(user_id, api_key: nil)
+        request(fill(ApiPaths::MEMBER, userId: user_id), method: :delete, api_key:)
+      end
+
+      def grant_address(user_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::MEMBER_ADDRESSES, userId: user_id), method: :post, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def revoke_address(user_id, address_id, api_key: nil)
+        request(fill(ApiPaths::MEMBER_ADDRESS, userId: user_id, addressId: address_id), method: :delete, api_key:)
+      end
+
+      def grant_domain(user_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::MEMBER_DOMAINS, userId: user_id), method: :post, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def revoke_domain(user_id, domain_id, api_key: nil)
+        request(fill(ApiPaths::MEMBER_DOMAIN, userId: user_id, domainId: domain_id), method: :delete, api_key:)
+      end
+
+      def list_invitations(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::MEMBER_INVITATIONS, limit:, cursor:, api_key:)
+      end
+
+      def list_all_invitations(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::MEMBER_INVITATIONS, limit:, cursor:, api_key:)
+      end
+
+      def iterate_invitations(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::MEMBER_INVITATIONS, limit:, cursor:, api_key:, &)
+      end
+
+      def revoke_invitation(invitation_id, api_key: nil)
+        request(fill(ApiPaths::MEMBER_INVITATION, invitationId: invitation_id), method: :delete, api_key:)
+      end
+
+      def resend_invitation(invitation_id, api_key: nil)
+        request(fill(ApiPaths::MEMBER_INVITATION_RESEND, invitationId: invitation_id), method: :post, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/provider_imports.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class ProviderImports < Resource
+      NOT_GIVEN = Object.new.freeze
+      private_constant :NOT_GIVEN
+
+      def inspect(provider_key = NOT_GIVEN, api_key: nil)
+        return super() if provider_key.equal?(NOT_GIVEN)
+
+        request(ApiPaths::PROVIDER_IMPORTS_INSPECT, method: :post, body: {"apiKey" => provider_key}, api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::PROVIDER_IMPORTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::PROVIDER_IMPORTS, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::PROVIDER_IMPORTS, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::PROVIDER_IMPORTS, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::PROVIDER_IMPORT, id:), api_key:)
+      end
+
+      def cancel(id, api_key: nil)
+        request(fill(ApiPaths::PROVIDER_IMPORT_CANCEL, id:), method: :post, api_key:)
+      end
+    end
+  end
+end

data/lib/openemail/resources/roles.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class Roles < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::ROLES, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::ROLES, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::ROLES, limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::ROLE, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::ROLES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::ROLE, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete(id, reassign_to: nil, api_key: nil)
+        request(fill(ApiPaths::ROLE, id:), method: :delete, query: query_params(reassign_to:), api_key:)
+      end
+
+      def list_permissions(api_key: nil)
+        fetch_list(ApiPaths::ROLE_PERMISSIONS, api_key:)
+      end
+    end
+  end
+end