nextmail 0.0.1

data/lib/nextmail/resources/broadcasts.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Broadcasts < Resource
+      def preview(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BROADCASTS_PREVIEW, method: :post,
+          body: payload(body, fields).slice("audienceIds", "excludeAudienceIds", "segmentId"), repeatable: true,
+          api_key:)
+      end
+
+      def send(body = nil, idempotency_key: nil, api_key: nil, **fields)
+        wire = payload(body, fields)
+        wire["scheduledAt"] = instant(wire["scheduledAt"]) if wire.key?("scheduledAt")
+        request(ApiPaths::BROADCASTS, method: :post, body: wire, idempotent: true, idempotency_key:, repeatable: true,
+          api_key:)
+      end
+
+      def list(audience_id: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::BROADCASTS, query_params(audience_id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(audience_id: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::BROADCASTS, query_params(audience_id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(audience_id: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::BROADCASTS, query_params(audience_id:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST, id:), api_key:)
+      end
+
+      def list_recipients(id, filter: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::BROADCAST_RECIPIENTS, id:), query_params(filter:, q:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_recipients(id, filter: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::BROADCAST_RECIPIENTS, id:), query_params(filter:, q:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_recipients(id, filter: nil, q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::BROADCAST_RECIPIENTS, id:), query_params(filter:, q:), limit:, cursor:, api_key:, &)
+      end
+
+      def get_recipient(id, email_id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST_RECIPIENT, id:, emailId: email_id), api_key:)
+      end
+
+      def stats(id, grain: nil, offset_minutes: nil, days: nil, minutes: nil, since: nil, api_key: nil)
+        query = query_params(grain:, offset_minutes:, days:, minutes:, since: instant(since))
+        request(fill(ApiPaths::BROADCAST_STATS, id:), query:, api_key:)
+      end
+
+      def analytics(broadcast_ids: nil, days: nil, minutes: nil, since: nil, grain: nil, offset_minutes: nil,
+        api_key: nil)
+        query = query_params(broadcast_ids: joined(broadcast_ids), days:, minutes:, since: instant(since), grain:,
+          offset_minutes:)
+        request(ApiPaths::BROADCASTS_ANALYTICS, query:, api_key:)
+      end
+
+      def cancel(id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST_CANCEL, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def create_draft(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BROADCAST_DRAFTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BROADCAST, id:), method: :patch, body: scheduled_wire(payload(patch, fields)),
+          repeatable: true, api_key:)
+      end
+
+      def send_draft(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BROADCAST_SEND, id:), method: :post, body: scheduled_wire(payload(body, fields)),
+          api_key:)
+      end
+
+      def duplicate(id, api_key: nil)
+        request(fill(ApiPaths::BROADCAST_DUPLICATE, id:), method: :post, api_key:)
+      end
+
+      def resend(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BROADCAST_RESEND, id:), method: :post, body: scheduled_wire(payload(body, fields)),
+          api_key:)
+      end
+
+      def send_test(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BROADCASTS_TEST, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      private
+
+      def scheduled_wire(wire)
+        wire["scheduledAt"] = instant(wire["scheduledAt"]) if wire.key?("scheduledAt")
+        wire
+      end
+    end
+  end
+end

data/lib/nextmail/resources/calendar.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Calendar < Resource
+      def list_events(from:, to:, timezone: nil, include_team: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        query = range_query(from, to, timezone, include_team, q)
+        fetch_page(ApiPaths::CALENDAR_EVENTS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_events(from:, to:, timezone: nil, include_team: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        query = range_query(from, to, timezone, include_team, q)
+        collect_all(ApiPaths::CALENDAR_EVENTS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_events(from:, to:, timezone: nil, include_team: nil, q: nil, limit: nil, cursor: nil, api_key: nil,
+        &)
+        query = range_query(from, to, timezone, include_team, q)
+        iterate_pages(ApiPaths::CALENDAR_EVENTS, query, limit:, cursor:, api_key:, &)
+      end
+
+      def get_event(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT, id:), api_key:)
+      end
+
+      def get_event_ics(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT_ICS, id:), accept: Protocol::CONTENT_TYPES[:CALENDAR], api_key:)
+      end
+
+      def create_event(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CALENDAR_EVENTS, method: :post, body: event_wire(payload(body, fields)), api_key:)
+      end
+
+      def update_event(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_EVENT, id:), method: :patch, body: event_wire(payload(patch, fields)), api_key:)
+      end
+
+      def delete_event(id, scope: nil, occurrence_start: nil, api_key: nil)
+        query = query_params(scope:, occurrence_start: instant(occurrence_start))
+        request(fill(ApiPaths::CALENDAR_EVENT, id:), method: :delete, query:, api_key:)
+      end
+
+      def cancel_event(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CALENDAR_EVENT_CANCEL, id:), method: :post, body: scope_wire(payload(body, fields)), api_key:)
+      end
+
+      def hide_event(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT_HIDE, id:), method: :post, api_key:)
+      end
+
+      def unhide_event(id, api_key: nil)
+        request(fill(ApiPaths::CALENDAR_EVENT_UNHIDE, id:), method: :post, api_key:)
+      end
+
+      def free_busy(emails:, from:, to:, timezone: nil, duration_minutes: nil, api_key: nil)
+        query = query_params(from: instant(from), to: instant(to), timezone:, emails: joined(emails), duration_minutes:)
+        request(ApiPaths::CALENDAR_FREE_BUSY, query:, api_key:)
+      end
+
+      def respond_to_event(id, body = nil, api_key: nil, **fields)
+        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
+
+      def range_query(from, to, timezone, include_team, q)
+        query_params(from: instant(from), to: instant(to), timezone:, include_team: flag(include_team), q:)
+      end
+
+      def event_wire(wire)
+        wire["start"] = instant(wire["start"]) if wire.key?("start")
+        wire["end"] = instant(wire["end"]) if wire.key?("end")
+        scope_wire(wire)
+      end
+
+      def scope_wire(wire)
+        wire["occurrenceStart"] = instant(wire["occurrenceStart"]) if wire.key?("occurrenceStart")
+        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/nextmail/resources/chats.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Chats < Resource
+      def list(q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CHATS, query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CHATS, query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CHATS, query_params(q:, sort:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::CHAT, id:), api_key:)
+      end
+
+      def rename(id, title, api_key: nil)
+        request(fill(ApiPaths::CHAT, id:), method: :patch, body: {"title" => title}, repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::CHAT, id:), method: :delete, api_key:)
+      end
+
+      def list_messages(id, order: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::CHAT_MESSAGES, id:), query_params(order:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_messages(id, order: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::CHAT_MESSAGES, id:), query_params(order:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_messages(id, order: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::CHAT_MESSAGES, id:), query_params(order:), limit:, cursor:, api_key:, &)
+      end
+
+      def send_message(id, body = nil, timeout: nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CHAT_MESSAGES, id:), method: :post, body: Wire.with_attachments(payload(body, fields)),
+          timeout: turn_timeout(timeout), api_key:)
+      end
+
+      def stop_turn(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CHAT_STOP, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def approve_tool_call(id, tool_call_id, body = nil, timeout: nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CHAT_TOOL_CALL_APPROVE, id:, toolCallId: tool_call_id), method: :post,
+          body: payload(body, fields), timeout: turn_timeout(timeout), api_key:)
+      end
+
+      def deny_tool_call(id, tool_call_id, timeout: nil, api_key: nil)
+        request(fill(ApiPaths::CHAT_TOOL_CALL_DENY, id:, toolCallId: tool_call_id), method: :post,
+          timeout: turn_timeout(timeout), api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/connected_mailboxes.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class ConnectedMailboxes < Resource
+      def list(q: nil, api_key: nil)
+        fetch_list(ApiPaths::CONNECTED_MAILBOXES, query_params(q:), api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::CONNECTED_MAILBOX, id:), api_key:)
+      end
+
+      def discover(email, api_key: nil)
+        request(ApiPaths::CONNECTED_MAILBOX_SETTINGS, query: query_params(email:), api_key:)
+      end
+
+      def connect(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CONNECTED_MAILBOXES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONNECTED_MAILBOX, id:), method: :patch, body: payload(patch, fields), api_key:)
+      end
+
+      def sync(id, api_key: nil)
+        request(fill(ApiPaths::CONNECTED_MAILBOX_SYNC, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def disconnect(id, api_key: nil)
+        request(fill(ApiPaths::CONNECTED_MAILBOX, id:), method: :delete, repeatable: true, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/connectors.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Connectors < Resource
+      def list_apps(search: nil, category: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CONNECTOR_APPS, query_params(search:, category:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_apps(search: nil, category: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONNECTOR_APPS, query_params(search:, category:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_apps(search: nil, category: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONNECTOR_APPS, query_params(search:, category:), limit:, cursor:, api_key:, &)
+      end
+
+      def get_app(slug, api_key: nil)
+        request(fill(ApiPaths::CONNECTOR_APP, slug:), api_key:)
+      end
+
+      def list_categories(api_key: nil)
+        fetch_list(ApiPaths::CONNECTOR_CATEGORIES, api_key:)
+      end
+
+      def list(scope: nil, status: nil, app: nil, api_key: nil)
+        fetch_list(ApiPaths::CONNECTORS, query_params(scope:, status:, app:), api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::CONNECTOR, id:), api_key:)
+      end
+
+      def connect(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CONNECTORS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONNECTOR, id:), method: :patch, body: payload(patch, fields), api_key:)
+      end
+
+      def disconnect(id, api_key: nil)
+        request(fill(ApiPaths::CONNECTOR, id:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def reconnect(id, api_key: nil)
+        request(fill(ApiPaths::CONNECTOR_RECONNECT, id:), method: :post, api_key:)
+      end
+
+      def list_actions(id, search: nil, limit: nil, api_key: nil)
+        fetch_list(fill(ApiPaths::CONNECTOR_ACTIONS, id:), query_params(search:, limit:), api_key:)
+      end
+
+      def get_action(id, action, api_key: nil)
+        request(fill(ApiPaths::CONNECTOR_ACTION, id:, action:), api_key:)
+      end
+
+      def run_action(id, action, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONNECTOR_ACTION_RUN, id:, action:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_calls(connector_id: nil, scope: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CONNECTOR_CALLS, query_params(connector_id:, scope:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_calls(connector_id: nil, scope: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONNECTOR_CALLS, query_params(connector_id:, scope:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_calls(connector_id: nil, scope: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONNECTOR_CALLS, query_params(connector_id:, scope:), limit:, cursor:, api_key:, &)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/contacts.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Contacts < Resource
+      def list(source: nil, audience_id: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::CONTACTS, query_params(source:, q:, audience_id:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(source: nil, audience_id: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONTACTS, query_params(source:, q:, audience_id:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(source: nil, audience_id: nil, q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONTACTS, query_params(source:, q:, audience_id:), limit:, cursor:, api_key:, &)
+      end
+
+      def get(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT, email:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::CONTACTS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(email, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT, email:), method: :patch, body: payload(patch, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT, email:), method: :delete, api_key:)
+      end
+
+      def set_audiences(email, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT_AUDIENCES, email:), method: :put, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      def list_people(q: nil, email: nil, sort: nil, blocked: nil, limit: nil, cursor: nil, api_key: nil)
+        query = Pagination.page_query(people_query(q, email, sort, blocked), CURSOR, limit, cursor)
+        envelope = request(ApiPaths::CONTACTS_PEOPLE, query:, api_key:)
+        envelope = {} unless envelope.is_a?(Hash)
+        next_cursor = Pagination.cursor_of(envelope[:nextCursor])
+
+        PeoplePage.new(
+          items: Pagination.items_of(envelope),
+          has_more: Pagination.more?(envelope, next_cursor),
+          next_cursor:,
+          seen: envelope[:seen] == true
+        )
+      end
+
+      def list_all_people(q: nil, email: nil, sort: nil, blocked: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::CONTACTS_PEOPLE, people_query(q, email, sort, blocked), limit:, cursor:, api_key:)
+      end
+
+      def iterate_people(q: nil, email: nil, sort: nil, blocked: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::CONTACTS_PEOPLE, people_query(q, email, sort, blocked), limit:, cursor:, api_key:, &)
+      end
+
+      def save(email, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT, email:), method: :put, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def delete_many(emails, api_key: nil)
+        request(ApiPaths::CONTACTS_BATCH_DELETE, method: :post, body: {"emails" => emails}, repeatable: true, api_key:)
+      end
+
+      def set_photo(email, data, content_type: nil, crop: nil, api_key: nil)
+        request(fill(ApiPaths::CONTACT_PHOTO, email:), method: :put, query: crop_query(crop), raw: data,
+          content_type: raw_content_type(data, content_type), repeatable: true, timeout: upload_timeout, api_key:)
+      end
+
+      def remove_photo(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT_PHOTO, email:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def block(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT_BLOCK, email:), method: :post, repeatable: true, api_key:)
+      end
+
+      def unblock(email, api_key: nil)
+        request(fill(ApiPaths::CONTACT_BLOCK, email:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def list_threads(email, q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::CONTACT_THREADS, email:), query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def list_all_threads(email, q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::CONTACT_THREADS, email:), query_params(q:, sort:), limit:, cursor:, api_key:)
+      end
+
+      def iterate_threads(email, q: nil, sort: nil, limit: nil, cursor: nil, api_key: nil, &)
+        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, from: nil, to: nil, grain: nil, offset_minutes: nil, api_key: nil)
+        query = query_params(minutes:, grain:, offset_minutes:, from: instant(from), to: instant(to))
+        request(fill(ApiPaths::CONTACT_ACTIVITY, email:), query:, api_key:)
+      end
+
+      def list_cards(email: nil, without_email: nil, kind: nil, group_id: nil, limit: nil, cursor: nil, api_key: nil)
+        query = card_query(email, without_email, kind, group_id)
+        fetch_page(ApiPaths::CONTACT_CARDS, query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_cards(email: nil, without_email: nil, kind: nil, group_id: nil, limit: nil, cursor: nil, api_key: nil)
+        query = card_query(email, without_email, kind, group_id)
+        collect_all(ApiPaths::CONTACT_CARDS, query, limit:, cursor:, api_key:)
+      end
+
+      def iterate_cards(email: nil, without_email: nil, kind: nil, group_id: nil, limit: nil, cursor: nil, api_key: nil,
+        &)
+        query = card_query(email, without_email, kind, group_id)
+        iterate_pages(ApiPaths::CONTACT_CARDS, query, 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 find_duplicate_cards(api_key: nil)
+        request(ApiPaths::CONTACT_CARD_DUPLICATES, api_key:)
+      end
+
+      def merge_cards(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::CONTACT_CARD_MERGE, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_birthdays(from:, to:, timezone: nil, api_key: nil)
+        fetch_list(ApiPaths::CONTACT_BIRTHDAYS, query_params(from: instant(from), to: instant(to), timezone:), 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, kind, group_id)
+        query_params(email:, without_email: flag(without_email), kind:, group_id:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/dns_connections.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class DnsConnections < Resource
+      def list(api_key: nil)
+        request(ApiPaths::DNS_CONNECTIONS, api_key:)
+      end
+
+      def start(api_key: nil)
+        request(ApiPaths::DNS_CONNECTIONS, method: :post, api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::DNS_CONNECTION, id:), api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::DNS_CONNECTION, id:), method: :delete, api_key:)
+      end
+    end
+  end
+end