openemail 0.0.1 → 0.0.3

data/lib/openemail/resources/calendar.rb

@@ -40,7 +40,72 @@ module OpenEmail
       end
 
       def respond_to_event(id, body = nil, api_key: nil, **fields)
-        request(fill(ApiPaths::CALENDAR_EVENT_RESPOND, id:), method: :post, body: payload(body, fields), api_key:)
+        request(fill(ApiPaths::CALENDAR_EVENT_RESPOND, id:), method: :post, body: answer_wire(payload(body, fields)), api_key:)
+      end
+
+      def decline_proposal(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_EVENT_DECLINE_PROPOSAL, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_feeds(api_key: nil)
+        fetch_list(ApiPaths::CALENDAR_FEEDS, api_key:)
+      end
+
+      def create_feed(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_FEEDS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def reset_feed(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_FEED_RESET, id:), method: :post, api_key:)
+      end
+
+      def delete_feed(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_FEED, id:), method: :delete, api_key:)
+      end
+
+      def list_subscriptions(api_key: nil)
+        fetch_list(ApiPaths::CALENDAR_SUBSCRIPTIONS, api_key:)
+      end
+
+      def create_subscription(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_SUBSCRIPTIONS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update_subscription(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_SUBSCRIPTION, id:), method: :patch, body: payload(patch, fields), api_key:)
+      end
+
+      def refresh_subscription(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_SUBSCRIPTION_REFRESH, id:), method: :post, api_key:)
+      end
+
+      def delete_subscription(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_SUBSCRIPTION, id:), method: :delete, api_key:)
+      end
+
+      def import_ics(data, filename: nil, api_key: nil)
+        request(ApiPaths::CALENDAR_IMPORTS, method: :post, query: query_params(filename: optional_upload_name(data, filename)),
+          raw: data, content_type: Protocol::CONTENT_TYPES[:CALENDAR], api_key:)
+      end
+
+      def list_imports(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CALENDAR_IMPORTS, limit:, cursor:, api_key:)
+      end
+
+      def list_all_imports(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CALENDAR_IMPORTS, limit:, cursor:, api_key:)
+      end
+
+      def iterate_imports(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CALENDAR_IMPORTS, limit:, cursor:, api_key:, &)
+      end
+
+      def get_import(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_IMPORT, id:), api_key:)
+      end
+
+      def undo_import(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_IMPORT_UNDO, id:), method: :post, api_key:)
       end
 
       private
@@ -54,6 +119,12 @@ module OpenEmail
         wire["end"] = instant(wire["end"]) if wire.key?("end")
         wire
       end
+
+      def answer_wire(wire)
+        wire["proposedStart"] = instant(wire["proposedStart"]) if wire.key?("proposedStart")
+        wire["proposedEnd"] = instant(wire["proposedEnd"]) if wire.key?("proposedEnd")
+        wire
+      end
     end
   end
 end

data/lib/openemail/resources/contacts.rb

@@ -96,16 +96,86 @@ module OpenEmail
         iterate_pages(fill(ApiPaths::CONTACT_THREADS, email:), query_params(q:, sort:), limit:, cursor:, api_key:, &)
       end
 
+      def list_events(email, name: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::CONTACT_EVENTS, email:), query_params(name:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_events(email, name: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::CONTACT_EVENTS, email:), query_params(name:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_events(email, name: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::CONTACT_EVENTS, email:), query_params(name:), limit:, cursor:, api_key:, &)
+      end
+
       def activity(email, minutes: nil, grain: nil, offset_minutes: nil, api_key: nil)
         request(fill(ApiPaths::CONTACT_ACTIVITY, email:), query: query_params(minutes:, grain:, offset_minutes:),
           api_key:)
       end
 
+      def list_cards(email: nil, without_email: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CONTACT_CARDS, card_query(email, without_email), limit:, cursor:, api_key:)
+      end
+
+      def list_all_cards(email: nil, without_email: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONTACT_CARDS, card_query(email, without_email), limit:, cursor:, api_key:)
+      end
+
+      def iterate_cards(email: nil, without_email: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONTACT_CARDS, card_query(email, without_email), limit:, cursor:, api_key:, &)
+      end
+
+      def get_card(id, api_key: nil)
+        request(fill(ApiPaths::CONTACT_CARD, id:), api_key:)
+      end
+
+      def create_card(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CONTACT_CARDS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update_card(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT_CARD, id:), method: :patch, body: payload(patch, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete_card(id, api_key: nil)
+        request(fill(ApiPaths::CONTACT_CARD, id:), method: :delete, api_key:)
+      end
+
+      def import_vcf(data, filename: nil, api_key: nil)
+        request(ApiPaths::CONTACT_IMPORTS, method: :post, query: query_params(filename: optional_upload_name(data, filename)),
+          raw: data, content_type: Protocol::CONTENT_TYPES[:VCARD], api_key:)
+      end
+
+      def list_imports(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CONTACT_IMPORTS, limit:, cursor:, api_key:)
+      end
+
+      def list_all_imports(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONTACT_IMPORTS, limit:, cursor:, api_key:)
+      end
+
+      def iterate_imports(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONTACT_IMPORTS, limit:, cursor:, api_key:, &)
+      end
+
+      def get_import(id, api_key: nil)
+        request(fill(ApiPaths::CONTACT_IMPORT, id:), api_key:)
+      end
+
+      def undo_import(id, api_key: nil)
+        request(fill(ApiPaths::CONTACT_IMPORT_UNDO, id:), method: :post, api_key:)
+      end
+
       private
 
       def people_query(q, email, sort, blocked)
         query_params(q:, email:, sort:, blocked: flag(blocked))
       end
+
+      def card_query(email, without_email)
+        query_params(email:, without_email: flag(without_email))
+      end
     end
   end
 end

data/lib/openemail/resources/domains.rb

@@ -137,6 +137,39 @@ module OpenEmail
         request(fill(ApiPaths::DOMAIN_ADDRESS_LOGIN, id:, addressId: address_id), method: :delete, api_key:)
       end
 
+      def get_mail_app_settings(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APPS, id:, addressId: address_id), api_key:)
+      end
+
+      def update_mail_app_settings(id, address_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APPS, id:, addressId: address_id), method: :patch,
+          body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def list_app_passwords(id, address_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORDS, id:, addressId: address_id), api_key:)
+      end
+
+      def create_app_password(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORDS, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
+      def update_app_password(id, address_id, password_id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORD, id:, addressId: address_id, passwordId: password_id),
+          method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete_app_password(id, address_id, password_id, api_key: nil)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_APP_PASSWORD, id:, addressId: address_id, passwordId: password_id),
+          method: :delete, api_key:)
+      end
+
+      def send_mail_app_setup(id, address_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::DOMAIN_ADDRESS_MAIL_APP_SETUP, id:, addressId: address_id), method: :post,
+          body: payload(body, fields), api_key:)
+      end
+
       def get_dns(id, refresh: nil, api_key: nil)
         request(fill(ApiPaths::DOMAIN_DNS, id:), query: query_params(refresh:), api_key:)
       end

data/lib/openemail/resources/events.rb

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

data/lib/openemail/resources/files.rb

@@ -76,20 +76,6 @@ module OpenEmail
       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/follow_ups.rb

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

data/lib/openemail/resources/imports.rb

@@ -48,6 +48,22 @@ module OpenEmail
         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) }

data/lib/openemail/resources/keys.rb

@@ -40,87 +40,86 @@ module OpenEmail
           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)
+      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, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil)
-        query = request_query(since, binding.local_variable_get(:until), failed_only)
+      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, since: nil, until: nil, limit: nil, cursor: nil, api_key: nil, &)
-        query = request_query(since, binding.local_variable_get(:until), failed_only)
+      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 = window_query(since, binding.local_variable_get(:until))
+        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 = window_query(since, binding.local_variable_get(:until))
+        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 = window_query(since, binding.local_variable_get(:until))
+        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, 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)
+      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, 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)
+      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, 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)
+      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 = window_query(since, binding.local_variable_get(:until)).merge(query_params(key_ids: joined(key_ids)))
+        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 = window_query(since, binding.local_variable_get(:until)).merge(query_params(key_ids: joined(key_ids)))
+        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 = window_query(since, binding.local_variable_get(:until)).merge(query_params(key_ids: joined(key_ids)))
+        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 = window_query(since, binding.local_variable_get(:until))
+        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 window_query(since, until_value)
-        query_params(since: instant(since), until: instant(until_value))
+      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 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)))
+      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

data/lib/openemail/resources/knowledge.rb

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

@@ -31,6 +31,10 @@ module OpenEmail
         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

data/lib/openemail/resources/me.rb

@@ -14,6 +14,44 @@ module OpenEmail
       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

data/lib/openemail/resources/out_of_office.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Resources
+    class OutOfOffice < Resource
+      def list(address: nil, api_key: nil)
+        fetch_list(ApiPaths::OUT_OF_OFFICE, query_params(address:), api_key:)
+      end
+
+      def set(address, body = nil, api_key: nil, **fields)
+        request(ApiPaths::OUT_OF_OFFICE, method: :put, query: query_params(address:),
+          body: reply_wire(payload(body, fields)), repeatable: true, api_key:)
+      end
+
+      def clear(address, api_key: nil)
+        request(ApiPaths::OUT_OF_OFFICE, method: :delete, query: query_params(address:), repeatable: true, api_key:)
+      end
+
+      private
+
+      def reply_wire(wire)
+        wire["startsAt"] = instant(wire["startsAt"]) if wire.key?("startsAt")
+        wire["endsAt"] = instant(wire["endsAt"]) if wire.key?("endsAt")
+        wire
+      end
+    end
+  end
+end

data/lib/openemail/resources/provider_imports.rb

@@ -6,10 +6,12 @@ module OpenEmail
       NOT_GIVEN = Object.new.freeze
       private_constant :NOT_GIVEN
 
-      def inspect(provider_key = NOT_GIVEN, api_key: nil)
+      def inspect(provider_key = NOT_GIVEN, provider: nil, api_key: nil)
         return super() if provider_key.equal?(NOT_GIVEN)
 
-        request(ApiPaths::PROVIDER_IMPORTS_INSPECT, method: :post, body: {"apiKey" => provider_key}, api_key:)
+        body = {"apiKey" => provider_key}
+        body["provider"] = provider unless provider.nil?
+        request(ApiPaths::PROVIDER_IMPORTS_INSPECT, method: :post, body:, api_key:)
       end
 
       def create(body = nil, api_key: nil, **fields)