nextmail 0.0.1

data/lib/nextmail/resources/account.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Account < Resource
+      def set_name(name, api_key: nil)
+        request(ApiPaths::ACCOUNT, method: :patch, body: {"name" => name}, repeatable: true, api_key:)
+      end
+
+      def get_notifications(api_key: nil)
+        request(ApiPaths::ACCOUNT_NOTIFICATIONS, api_key:)
+      end
+
+      def set_email_notification(category, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::ACCOUNT_NOTIFICATION_EMAIL, category:), method: :put,
+          body: payload(body, fields).slice("enabled"), repeatable: true, api_key:)
+      end
+
+      def set_push_muted(workspace_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::ACCOUNT_NOTIFICATION_PUSH, workspaceId: workspace_id), method: :put,
+          body: payload(body, fields).slice("muted"), repeatable: true, api_key:)
+      end
+
+      def list_push_devices(api_key: nil)
+        fetch_list(ApiPaths::ACCOUNT_PUSH_DEVICES, api_key:)
+      end
+
+      def remove_push_device(device_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_PUSH_DEVICE, deviceId: device_id), method: :delete, api_key:)
+      end
+
+      def send_test_push(body = nil, api_key: nil, **fields)
+        request(ApiPaths::ACCOUNT_PUSH_DEVICES_TEST, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def set_photo(data, content_type: nil, crop: nil, api_key: nil)
+        request(ApiPaths::ACCOUNT_PHOTO, 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(api_key: nil)
+        request(ApiPaths::ACCOUNT_PHOTO, method: :delete, repeatable: true, api_key:)
+      end
+
+      def get_username(api_key: nil)
+        request(ApiPaths::ACCOUNT_USERNAME, api_key:)
+      end
+
+      def check_username(username, api_key: nil)
+        request(ApiPaths::ACCOUNT_USERNAME_AVAILABILITY, query: query_params(username:), api_key:)
+      end
+
+      def set_username(username, api_key: nil)
+        request(ApiPaths::ACCOUNT_USERNAME, method: :put, body: {"username" => username}, api_key:)
+      end
+
+      def list_connected_apps(api_key: nil)
+        fetch_list(ApiPaths::ACCOUNT_CONNECTED_APPS, api_key:)
+      end
+
+      def list_connected_app_requests(client_id, failed_only: nil, statuses: 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, nil)
+        fetch_page(fill(ApiPaths::ACCOUNT_CONNECTED_APP_REQUESTS, clientId: client_id), query, limit:, cursor:, api_key:)
+      end
+
+      def list_all_connected_app_requests(client_id, failed_only: nil, statuses: 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, nil)
+        collect_all(fill(ApiPaths::ACCOUNT_CONNECTED_APP_REQUESTS, clientId: client_id), query, limit:, cursor:,
+          api_key:)
+      end
+
+      def iterate_connected_app_requests(client_id, failed_only: nil, statuses: 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, nil)
+        iterate_pages(fill(ApiPaths::ACCOUNT_CONNECTED_APP_REQUESTS, clientId: client_id), query, limit:, cursor:,
+          api_key:, &)
+      end
+
+      def revoke_connected_app(client_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_CONNECTED_APP, clientId: client_id), method: :delete, api_key:)
+      end
+
+      def end_connected_app_elevation(client_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_CONNECTED_APP_ELEVATION, clientId: client_id), method: :delete, repeatable: true,
+          api_key:)
+      end
+
+      def list_sessions(api_key: nil)
+        fetch_list(ApiPaths::ACCOUNT_SESSIONS, api_key:)
+      end
+
+      def revoke_session(session_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_SESSION, sessionId: session_id), method: :delete, api_key:)
+      end
+
+      def revoke_sessions(connected_apps: nil, api_key: nil)
+        request(ApiPaths::ACCOUNT_SESSIONS, method: :delete, query: query_params(connected_apps: flag(connected_apps)),
+          api_key:)
+      end
+
+      def list_security_events(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::ACCOUNT_SECURITY_EVENTS, limit:, cursor:, api_key:)
+      end
+
+      def list_all_security_events(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::ACCOUNT_SECURITY_EVENTS, limit:, cursor:, api_key:)
+      end
+
+      def iterate_security_events(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::ACCOUNT_SECURITY_EVENTS, limit:, cursor:, api_key:, &)
+      end
+
+      def list_passkeys(api_key: nil)
+        fetch_list(ApiPaths::ACCOUNT_PASSKEYS, api_key:)
+      end
+
+      def rename_passkey(passkey_id, name, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_PASSKEY, passkeyId: passkey_id), method: :patch, body: {"name" => name},
+          repeatable: true, api_key:)
+      end
+
+      def remove_passkey(passkey_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_PASSKEY, passkeyId: passkey_id), method: :delete, api_key:)
+      end
+
+      def list_invitations(api_key: nil)
+        fetch_list(ApiPaths::ACCOUNT_INVITATIONS, api_key:)
+      end
+
+      def accept_invitation(invitation_id, activate: nil, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_INVITATION_ACCEPT, invitationId: invitation_id), method: :post,
+          body: activate.nil? ? {} : {"activate" => activate}, repeatable: true, api_key:)
+      end
+
+      def decline_invitation(invitation_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_INVITATION_DECLINE, invitationId: invitation_id), method: :post,
+          repeatable: true, api_key:)
+      end
+
+      def list_ownership_offers(api_key: nil)
+        fetch_list(ApiPaths::ACCOUNT_OWNERSHIP_OFFERS, api_key:)
+      end
+
+      def accept_ownership_offer(workspace_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_OWNERSHIP_OFFER_ACCEPT, workspaceId: workspace_id), method: :post, api_key:)
+      end
+
+      def decline_ownership_offer(workspace_id, api_key: nil)
+        request(fill(ApiPaths::ACCOUNT_OWNERSHIP_OFFER_DECLINE, workspaceId: workspace_id), method: :post, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/addresses.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Addresses < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        envelope = request(ApiPaths::ADDRESSES, query: Pagination.page_query(nil, CURSOR, limit, cursor), api_key:)
+        envelope = {} unless envelope.is_a?(Hash)
+        next_cursor = Pagination.cursor_of(envelope[:nextCursor])
+
+        AddressBookPage.new(
+          unrestricted: envelope[:unrestricted],
+          addresses: Pagination.items_of(envelope),
+          domains: envelope[:domains].is_a?(Array) ? envelope[:domains] : [],
+          has_more: Pagination.more?(envelope, next_cursor),
+          next_cursor:
+        )
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        current = list(limit:, cursor:, api_key:)
+        addresses = current.addresses.dup
+
+        while current.has_more && current.next_cursor && current.next_cursor != cursor
+          cursor = current.next_cursor
+          current = list(limit:, cursor:, api_key:)
+          addresses.concat(current.addresses)
+        end
+
+        AddressBook.new(unrestricted: current.unrestricted, addresses:, domains: current.domains)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::ADDRESSES, limit:, cursor:, api_key:, &)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/analytics.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Analytics < Resource
+      def mailbox(from: nil, to: nil, offset_minutes: nil, grain: nil, address: nil, api_key: nil)
+        query = query_params(from: instant(from), to: instant(to), offset_minutes:, grain:, address:)
+        request(ApiPaths::ANALYTICS_MAILBOX, query:, api_key:)
+      end
+
+      def sending(days: nil, minutes: nil, offset_minutes: nil, grain: nil, address: nil, since: nil, until: nil,
+        recipient: nil, tag: nil, api_key: nil)
+        query = query_params(days:, minutes:, offset_minutes:, grain:, address:, since: instant(since),
+          until: instant(binding.local_variable_get(:until)), recipient:, tag:)
+        request(ApiPaths::ANALYTICS_SENDING, query:, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/app_host.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class AppHost < Resource
+      def get(api_key: nil)
+        request(ApiPaths::APP_HOST, api_key:)
+      end
+
+      def set(body = nil, api_key: nil, **fields)
+        request(ApiPaths::APP_HOST, method: :put, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def verify(api_key: nil)
+        request(ApiPaths::APP_HOST_VERIFY, method: :post, repeatable: true, api_key:)
+      end
+
+      def delete(api_key: nil)
+        request(ApiPaths::APP_HOST, method: :delete, repeatable: true, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/audiences.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Audiences < Resource
+      def list(limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::AUDIENCES, limit:, cursor:, api_key:)
+      end
+
+      def list_all(limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::AUDIENCES, limit:, cursor:, api_key:)
+      end
+
+      def iterate(limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::AUDIENCES, limit:, cursor:, api_key:, &)
+      end
+
+      def growth(audience_ids: nil, days: nil, minutes: nil, since: nil, until: nil, grain: nil, offset_minutes: nil,
+        api_key: nil)
+        query = query_params(audience_ids: joined(audience_ids), days:, minutes:, grain:, offset_minutes:)
+          .merge(log_window_query(since, binding.local_variable_get(:until)))
+        request(ApiPaths::AUDIENCES_GROWTH, query:, api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::AUDIENCE, id:), api_key:)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::AUDIENCES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUDIENCE, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::AUDIENCE, id:), method: :delete, api_key:)
+      end
+
+      def empty(id, api_key: nil)
+        request(fill(ApiPaths::AUDIENCE_EMPTY, id:), method: :post, api_key:)
+      end
+
+      def list_contacts(id, q: nil, source: nil, sort: nil, statuses: nil, inactive_days: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        fetch_page(fill(ApiPaths::AUDIENCE_CONTACTS, id:), member_query(q, source, sort, statuses, inactive_days),
+          limit:, cursor:, api_key:)
+      end
+
+      def list_all_contacts(id, q: nil, source: nil, sort: nil, statuses: nil, inactive_days: nil, limit: nil,
+        cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::AUDIENCE_CONTACTS, id:), member_query(q, source, sort, statuses, inactive_days),
+          limit:, cursor:, api_key:)
+      end
+
+      def iterate_contacts(id, q: nil, source: nil, sort: nil, statuses: nil, inactive_days: nil, limit: nil,
+        cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::AUDIENCE_CONTACTS, id:), member_query(q, source, sort, statuses, inactive_days),
+          limit:, cursor:, api_key:, &)
+      end
+
+      def add_contact(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUDIENCE_CONTACTS, id:), method: :post, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      def remove_contact(id, email, api_key: nil)
+        request(fill(ApiPaths::AUDIENCE_CONTACT, id:, email:), method: :delete, api_key:)
+      end
+
+      def add_contacts(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUDIENCE_CONTACTS_BATCH, id:), method: :post, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def remove_contacts(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUDIENCE_CONTACTS_BATCH_REMOVE, id:), method: :post, body: payload(body, fields),
+          repeatable: true, api_key:)
+      end
+
+      def import_contacts(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUDIENCE_IMPORT, id:), method: :post, body: payload(body, fields), repeatable: true,
+          api_key:)
+      end
+
+      private
+
+      def member_query(q, source, sort, statuses, inactive_days)
+        status = (statuses.nil? || statuses.empty?) ? nil : joined(statuses)
+        query_params(q:, source:, sort:, status:, inactive_days:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/automations.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Automations < Resource
+      def list(status: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::AUTOMATIONS, query_params(status:), limit:, cursor:, api_key:)
+      end
+
+      def list_all(status: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(ApiPaths::AUTOMATIONS, query_params(status:), limit:, cursor:, api_key:)
+      end
+
+      def iterate(status: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(ApiPaths::AUTOMATIONS, query_params(status:), limit:, cursor:, api_key:, &)
+      end
+
+      def create(body = nil, api_key: nil, **fields)
+        request(ApiPaths::AUTOMATIONS, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_starters(api_key: nil)
+        fetch_list(ApiPaths::AUTOMATION_STARTERS, api_key:)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION, id:), api_key:)
+      end
+
+      def update(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUTOMATION, id:), method: :patch, body: payload(patch, fields), repeatable: true,
+          api_key:)
+      end
+
+      def delete(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION, id:), method: :delete, api_key:)
+      end
+
+      def publish(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_PUBLISH, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def pause(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_PAUSE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def resume(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_RESUME, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def archive(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_ARCHIVE, id:), method: :post, repeatable: true, api_key:)
+      end
+
+      def duplicate(id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_DUPLICATE, id:), method: :post, api_key:)
+      end
+
+      def send_test(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUTOMATION_TEST, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_versions(id, api_key: nil)
+        fetch_list(fill(ApiPaths::AUTOMATION_VERSIONS, id:), api_key:)
+      end
+
+      def restore_version(id, version, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_VERSION_RESTORE, id:, version:), method: :post, repeatable: true, api_key:)
+      end
+
+      def stats(id, since: nil, until: nil, api_key: nil)
+        query = log_window_query(since, binding.local_variable_get(:until))
+        request(fill(ApiPaths::AUTOMATION_STATS, id:), query:, api_key:)
+      end
+
+      def analytics(automation_ids: nil, since: nil, until: nil, api_key: nil)
+        query = query_params(automation_ids: joined(automation_ids))
+          .merge(log_window_query(since, binding.local_variable_get(:until)))
+        request(ApiPaths::AUTOMATIONS_ANALYTICS, query:, api_key:)
+      end
+
+      def list_runs(id, event: nil, step_key: nil, outcome: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::AUTOMATION_RUNS, id:), query_params(event:, step_key:, outcome:), limit:, cursor:,
+          api_key:)
+      end
+
+      def list_all_runs(id, event: nil, step_key: nil, outcome: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::AUTOMATION_RUNS, id:), query_params(event:, step_key:, outcome:), limit:, cursor:,
+          api_key:)
+      end
+
+      def iterate_runs(id, event: nil, step_key: nil, outcome: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::AUTOMATION_RUNS, id:), query_params(event:, step_key:, outcome:), limit:,
+          cursor:, api_key:, &)
+      end
+
+      def list_enrollments(id, status: nil, step_key: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(fill(ApiPaths::AUTOMATION_ENROLLMENTS, id:), query_params(status:, step_key:, q:), limit:, cursor:,
+          api_key:)
+      end
+
+      def list_all_enrollments(id, status: nil, step_key: nil, q: nil, limit: nil, cursor: nil, api_key: nil)
+        collect_all(fill(ApiPaths::AUTOMATION_ENROLLMENTS, id:), query_params(status:, step_key:, q:), limit:, cursor:,
+          api_key:)
+      end
+
+      def iterate_enrollments(id, status: nil, step_key: nil, q: nil, limit: nil, cursor: nil, api_key: nil, &)
+        iterate_pages(fill(ApiPaths::AUTOMATION_ENROLLMENTS, id:), query_params(status:, step_key:, q:), limit:,
+          cursor:, api_key:, &)
+      end
+
+      def get_enrollment(id, enrollment_id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_ENROLLMENT, id:, enrollmentId: enrollment_id), api_key:)
+      end
+
+      def enroll(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::AUTOMATION_ENROLLMENTS, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def exit_enrollment(id, enrollment_id, api_key: nil)
+        request(fill(ApiPaths::AUTOMATION_ENROLLMENT_EXIT, id:, enrollmentId: enrollment_id), method: :post, api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/billing.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Billing < Resource
+      def get(api_key: nil)
+        request(ApiPaths::BILLING, api_key:)
+      end
+
+      def list_plans(api_key: nil)
+        request(ApiPaths::BILLING_PLANS, api_key:)
+      end
+
+      def get_usage(days: nil, api_key: nil)
+        request(ApiPaths::BILLING_USAGE, query: query_params(days:), api_key:)
+      end
+
+      def list_alerts(api_key: nil)
+        request(ApiPaths::BILLING_ALERTS, api_key:)
+      end
+
+      def list_countries(api_key: nil)
+        request(ApiPaths::BILLING_COUNTRIES, api_key:)
+      end
+
+      def get_pay_as_you_go(api_key: nil)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO, api_key:)
+      end
+
+      def set_pay_as_you_go(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO, method: :patch, body: payload(body, fields), api_key:)
+      end
+
+      def set_pay_as_you_go_limit(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO_LIMIT, method: :put, body: payload(body, fields), api_key:)
+      end
+
+      def confirm_pay_as_you_go(api_key: nil)
+        request(ApiPaths::BILLING_PAY_AS_YOU_GO_CONFIRM, method: :post, api_key:)
+      end
+
+      def start_checkout(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_CHECKOUT, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_add_ons(api_key: nil)
+        request(ApiPaths::BILLING_ADD_ONS, api_key:)
+      end
+
+      def start_add_on_checkout(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_ADD_ON_CHECKOUT, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def cancel_add_on(add_on, api_key: nil)
+        request(fill(ApiPaths::BILLING_ADD_ON, addOn: add_on), method: :delete, api_key:)
+      end
+
+      def open_portal(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BILLING_PORTAL, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def list_invoices(page: nil, limit: nil, sort: nil, search: nil, api_key: nil)
+        request(ApiPaths::BILLING_INVOICES, query: query_params(page:, limit:, sort:, search:), api_key:)
+      end
+
+      def get_invoice(order_id, api_key: nil)
+        request(fill(ApiPaths::BILLING_INVOICE, orderId: order_id), api_key:)
+      end
+
+      def save_invoice_details(order_id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BILLING_INVOICE_DETAILS, orderId: order_id), method: :put, body: payload(body, fields),
+          api_key:)
+      end
+    end
+  end
+end

data/lib/nextmail/resources/bookings.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Bookings < Resource
+      def list_pages(q: nil, status: nil, since: nil, until: nil, sort: nil, api_key: nil)
+        until_value = binding.local_variable_get(:until)
+        query = query_params(q:, status:, since: instant(since), until: instant(until_value), sort:)
+        fetch_list(ApiPaths::BOOKING_PAGES, query, api_key:)
+      end
+
+      def get_page(id, api_key: nil)
+        request(fill(ApiPaths::BOOKING_PAGE, id:), api_key:)
+      end
+
+      def create_page(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BOOKING_PAGES, method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def update_page(id, patch = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BOOKING_PAGE, id:), method: :patch, body: payload(patch, fields), repeatable: true, api_key:)
+      end
+
+      def upload_background(id, data, content_type: nil, crop: nil, api_key: nil)
+        request(fill(ApiPaths::BOOKING_PAGE_BACKGROUND, id:), 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_background(id, api_key: nil)
+        request(fill(ApiPaths::BOOKING_PAGE_BACKGROUND, id:), method: :delete, repeatable: true, api_key:)
+      end
+
+      def delete_page(id, api_key: nil)
+        request(fill(ApiPaths::BOOKING_PAGE, id:), method: :delete, api_key:)
+      end
+
+      def list_times(id, from: nil, to: nil, duration_minutes: nil, booking_id: nil, api_key: nil)
+        query = query_params(from: instant(from), to: instant(to), duration_minutes:, booking_id:)
+        request(fill(ApiPaths::BOOKING_PAGE_TIMES, id:), query:, api_key:)
+      end
+
+      def list(view: nil, page_id: nil, page_ids: nil, q: nil, from: nil, to: nil, limit: nil, cursor: nil, api_key: nil)
+        fetch_page(ApiPaths::BOOKINGS, list_query(view, page_id, page_ids, q, from, to), limit:, cursor:, api_key:)
+      end
+
+      def list_all(view: nil, page_id: nil, page_ids: nil, q: nil, from: nil, to: nil, limit: nil, cursor: nil,
+        api_key: nil)
+        collect_all(ApiPaths::BOOKINGS, list_query(view, page_id, page_ids, q, from, to), limit:, cursor:, api_key:)
+      end
+
+      def iterate(view: nil, page_id: nil, page_ids: nil, q: nil, from: nil, to: nil, limit: nil, cursor: nil,
+        api_key: nil, &)
+        iterate_pages(ApiPaths::BOOKINGS, list_query(view, page_id, page_ids, q, from, to), limit:, cursor:, api_key:, &)
+      end
+
+      def get(id, api_key: nil)
+        request(fill(ApiPaths::BOOKING, id:), api_key:)
+      end
+
+      def approve(id, api_key: nil)
+        request(fill(ApiPaths::BOOKING_APPROVE, id:), method: :post, api_key:)
+      end
+
+      def decline(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BOOKING_DECLINE, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def cancel(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BOOKING_CANCEL, id:), method: :post, body: payload(body, fields), api_key:)
+      end
+
+      def reschedule(id, body = nil, api_key: nil, **fields)
+        request(fill(ApiPaths::BOOKING_RESCHEDULE, id:), method: :post, body: reschedule_wire(payload(body, fields)),
+          api_key:)
+      end
+
+      def resend_email(id, api_key: nil)
+        request(fill(ApiPaths::BOOKING_RESEND, id:), method: :post, api_key:)
+      end
+
+      def analytics(page_ids: nil, days: nil, minutes: nil, since: nil, until: nil, grain: nil, offset_minutes: nil,
+        api_key: nil)
+        query = query_params(page_ids: joined(page_ids), days:, minutes:, grain:, offset_minutes:)
+          .merge(log_window_query(since, binding.local_variable_get(:until)))
+        request(ApiPaths::BOOKINGS_ANALYTICS, query:, api_key:)
+      end
+
+      private
+
+      def list_query(view, page_id, page_ids, q, from, to)
+        query_params(view:, page_id:, page_ids: joined(page_ids), q:, from: instant(from), to: instant(to))
+      end
+
+      def reschedule_wire(wire)
+        wire["start"] = instant(wire["start"]) if wire.key?("start")
+        wire
+      end
+    end
+  end
+end

data/lib/nextmail/resources/branding.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Nextmail
+  module Resources
+    class Branding < Resource
+      def get(api_key: nil)
+        request(ApiPaths::BRANDING, api_key:)
+      end
+
+      def update(body = nil, api_key: nil, **fields)
+        request(ApiPaths::BRANDING, method: :patch, body: payload(body, fields), repeatable: true, api_key:)
+      end
+
+      def upload_image(variant, data, content_type: nil, crop: nil, api_key: nil)
+        request(fill(ApiPaths::BRANDING_IMAGE, variant:), 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_image(variant, api_key: nil)
+        request(fill(ApiPaths::BRANDING_IMAGE, variant:), method: :delete, repeatable: true, api_key:)
+      end
+    end
+  end
+end