posthubify 0.1.0

data/lib/posthubify/resources/messaging.rb

@@ -0,0 +1,882 @@
+# frozen_string_literal: true
+
+module Posthubify
+  # Inbox — conversations + messages (Node sdk .inbox).
+  class InboxResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Conversation list (paginated envelope; req → returns data+pagination together).
+    def conversations(platform: nil, account_id: nil, limit: nil, cursor: nil, sort_order: nil)
+      @http.req('GET', '/inbox/conversations', query: {
+        'platform' => platform, 'accountId' => account_id, 'limit' => limit,
+        'cursor' => cursor, 'sortOrder' => sort_order
+      })
+    end
+
+    # Messages in a conversation.
+    def messages(conversation_id)
+      @http.data('GET', "/inbox/conversations/#{conversation_id}/messages")
+    end
+
+    # Send a message to a conversation.
+    def send_message(conversation_id, text)
+      @http.data('POST', "/inbox/conversations/#{conversation_id}/messages", body: { 'text' => text })
+    end
+
+    # Start a new conversation (recipientId = PSID/IGSID/convoId/handle).
+    def start_conversation(input)
+      @http.data('POST', '/inbox/conversations', body: input)
+    end
+  end
+
+  # Comment management — list/reply/hide/like/delete (Node sdk .comments).
+  class CommentsResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Comment list (paginated envelope).
+    def list(platform: nil, account_id: nil, limit: nil, cursor: nil)
+      @http.req('GET', '/inbox/comments', query: {
+        'platform' => platform, 'accountId' => account_id, 'limit' => limit, 'cursor' => cursor
+      })
+    end
+
+    # A post's comments.
+    def for_post(post_id, account_id)
+      @http.data('GET', "/inbox/posts/#{post_id}/comments", query: { 'accountId' => account_id })
+    end
+
+    # Reply to a comment (text or media; the user provides camelCase keys).
+    def reply(comment_id, input)
+      @http.data('POST', "/inbox/comments/#{comment_id}/reply", body: input)
+    end
+
+    # Private reply to a commenter (IG/FB) — opens a DM without requiring an open window.
+    def private_reply(comment_id, input)
+      @http.data('POST', "/inbox/comments/#{comment_id}/private-reply", body: input)
+    end
+
+    # Write a top-level comment on a post.
+    def create_on_post(post_id, input)
+      @http.data('POST', "/inbox/posts/#{post_id}/comments", body: input)
+    end
+
+    # Hide/show a comment.
+    def hide(comment_id, input)
+      @http.data('POST', "/inbox/comments/#{comment_id}/hide", body: input)
+    end
+
+    # Like a comment.
+    def like(comment_id, input)
+      @http.data('POST', "/inbox/comments/#{comment_id}/like", body: input)
+    end
+
+    # Delete a comment.
+    def delete(comment_id, account_id)
+      @http.data('DELETE', "/inbox/comments/#{comment_id}", query: { 'accountId' => account_id })
+    end
+  end
+
+  # Review management — list/reply/delete-reply (Node sdk .reviews).
+  class ReviewsResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Review list (paginated envelope + summary).
+    def list(platform: nil, account_id: nil, min_rating: nil, max_rating: nil, limit: nil, cursor: nil)
+      @http.req('GET', '/reviews', query: {
+        'platform' => platform, 'accountId' => account_id, 'minRating' => min_rating,
+        'maxRating' => max_rating, 'limit' => limit, 'cursor' => cursor
+      })
+    end
+
+    # Delete a review reply.
+    def delete_reply(reply_id, account_id)
+      @http.data('DELETE', "/reviews/replies/#{reply_id}", query: { 'accountId' => account_id })
+    end
+
+    # Write a reply to a review.
+    def reply(context_id, input)
+      @http.data('POST', "/reviews/#{context_id}/reply", body: input)
+    end
+  end
+
+  # Contact management — CRUD + channels + bulk import (Node sdk .contacts).
+  class ContactsResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Contact list (paginated envelope).
+    def list(search: nil, tag: nil, limit: nil, cursor: nil)
+      @http.req('GET', '/contacts', query: {
+        'search' => search, 'tag' => tag, 'limit' => limit, 'cursor' => cursor
+      })
+    end
+
+    # A single contact.
+    def get(id)
+      @http.data('GET', "/contacts/#{id}")
+    end
+
+    # Channel-first idempotent upsert: an existing contact is returned inside the envelope with 'existing' => true →
+    # unwrap the data envelope and merge the existing flag (mirrors Node async create).
+    def create(input)
+      r = @http.req('POST', '/contacts', body: input)
+      contact = r.is_a?(Hash) && r.key?('data') ? r['data'] : r
+      if r.is_a?(Hash) && r['existing'] && contact.is_a?(Hash)
+        contact.merge('existing' => true)
+      else
+        contact
+      end
+    end
+
+    # Update a contact (partial).
+    def update(id, input)
+      @http.data('PATCH', "/contacts/#{id}", body: input)
+    end
+
+    # Delete a contact.
+    def delete(id)
+      @http.data('DELETE', "/contacts/#{id}")
+    end
+
+    # A contact's channels.
+    def channels(id)
+      @http.data('GET', "/contacts/#{id}/channels")
+    end
+
+    # Add a channel to a contact.
+    def add_channel(id, input)
+      @http.data('POST', "/contacts/#{id}/channels", body: input)
+    end
+
+    # Bulk import (1-1000); channel-first upsert avoids piling up duplicates.
+    def bulk(contacts)
+      @http.data('POST', '/contacts/bulk', body: { 'contacts' => contacts })
+    end
+  end
+
+  # Automation management — CRUD + activate/pause/duplicate + runs + dry-test (Node sdk .automations).
+  class AutomationsResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Automation list.
+    def list
+      @http.data('GET', '/automations')
+    end
+
+    # A single automation.
+    def get(id)
+      @http.data('GET', "/automations/#{id}")
+    end
+
+    # Create an automation (trigger + action).
+    def create(input)
+      @http.data('POST', '/automations', body: input)
+    end
+
+    # Update an automation (partial).
+    def update(id, input)
+      @http.data('PATCH', "/automations/#{id}", body: input)
+    end
+
+    # Delete an automation.
+    def delete(id)
+      @http.data('DELETE', "/automations/#{id}")
+    end
+
+    # Activate an automation.
+    def activate(id)
+      @http.data('POST', "/automations/#{id}/activate")
+    end
+
+    # Pause an automation.
+    def pause(id)
+      @http.data('POST', "/automations/#{id}/pause")
+    end
+
+    # The copy starts PAUSED (protection against accidental double-triggering).
+    def duplicate(id)
+      @http.data('POST', "/automations/#{id}/duplicate")
+    end
+
+    # Automation run records.
+    def runs(id, limit: nil)
+      @http.data('GET', "/automations/#{id}/runs", query: { 'limit' => limit })
+    end
+
+    # Dry-run: does a synthetic event match the trigger (nothing is sent).
+    def test(id, input = {})
+      @http.data('POST', "/automations/#{id}/test", body: input)
+    end
+  end
+
+  # PHASE D4 — IG/FB comment→DM automations (per-post/story, buttons, click-tracking).
+  class CommentAutomationsResource
+    def initialize(http)
+      @http = http
+    end
+
+    # List comment-automations (filter: account_id/platform/enabled).
+    def list(account_id: nil, platform: nil, enabled: nil)
+      @http.data('GET', '/comment-automations',
+                 query: { 'accountId' => account_id, 'platform' => platform, 'enabled' => enabled })
+    end
+
+    # A single comment-automation (including funnel stats).
+    def get(id)
+      @http.data('GET', "/comment-automations/#{id}")
+    end
+
+    # Create a comment→DM automation. input: {name, platform, accountId, triggerType?, targeting?, ...}.
+    def create(input)
+      @http.data('POST', '/comment-automations', body: input)
+    end
+
+    # Update a comment-automation (partial; platform/account cannot change).
+    def update(id, input)
+      @http.data('PATCH', "/comment-automations/#{id}", body: input)
+    end
+
+    # Delete a comment-automation.
+    def delete(id)
+      @http.data('DELETE', "/comment-automations/#{id}")
+    end
+
+    # Per-comment trigger audit ledger (paginated).
+    def logs(id, limit: nil, cursor: nil)
+      @http.req('GET', "/comment-automations/#{id}/logs", query: { 'limit' => limit, 'cursor' => cursor })
+    end
+  end
+
+  # PHASE D5 — graph-based conversation automation (node/edge, versioning, run timeline).
+  class WorkflowsResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list(account_id: nil, status: nil)
+      @http.data('GET', '/workflows', query: { 'accountId' => account_id, 'status' => status })
+    end
+
+    def get(id)
+      @http.data('GET', "/workflows/#{id}")
+    end
+
+    # Draft workflow from a node/edge graph. input: {name, accountId, nodes?, edges?, triggerConfig?}.
+    def create(input)
+      @http.data('POST', '/workflows', body: input)
+    end
+
+    # F3 — generate a graph with AI from a natural-language command. create:true → a draft is saved (returns the workflow).
+    def generate(command, account_id, create: false)
+      @http.data('POST', '/workflows/generate', body: { 'command' => command, 'accountId' => account_id, 'create' => create })
+    end
+
+    def update(id, input)
+      @http.data('PATCH', "/workflows/#{id}", body: input)
+    end
+
+    def delete(id)
+      @http.data('DELETE', "/workflows/#{id}")
+    end
+
+    def activate(id)
+      @http.data('POST', "/workflows/#{id}/activate")
+    end
+
+    def pause(id)
+      @http.data('POST', "/workflows/#{id}/pause")
+    end
+
+    def duplicate(id)
+      @http.data('POST', "/workflows/#{id}/duplicate")
+    end
+
+    def executions(id, limit: nil, cursor: nil)
+      @http.req('GET', "/workflows/#{id}/executions", query: { 'limit' => limit, 'cursor' => cursor })
+    end
+
+    # Manual test-run (side-effect-free dry-run). input: {message?, variables?}. → {execution, events}.
+    def run_test(id, input = {})
+      @http.data('POST', "/workflows/#{id}/executions", body: input)
+    end
+
+    def events(id, execution_id)
+      @http.data('GET', "/workflows/#{id}/executions/#{execution_id}/events")
+    end
+
+    def versions(id)
+      @http.data('GET', "/workflows/#{id}/versions")
+    end
+
+    def version(id, version)
+      @http.data('GET', "/workflows/#{id}/versions/#{version}")
+    end
+
+    # Restore the live graph to a snapshot (reversible).
+    def restore_version(id, version)
+      @http.data('POST', "/workflows/#{id}/versions/#{version}/restore")
+    end
+
+    # Store a BYOK provider key for the ai node (write-only, encrypted).
+    # provider ∈ anthropic|openai|google|mistral|groq.
+    def set_secret(id, provider, api_key)
+      @http.data('PUT', "/workflows/#{id}/secrets/#{provider}", body: { 'apiKey' => api_key })
+    end
+  end
+
+  # Broadcast — CRUD + send/schedule/cancel + recipients (Node sdk .broadcasts).
+  class BroadcastsResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Broadcast list.
+    def list
+      @http.data('GET', '/broadcasts')
+    end
+
+    # A single broadcast.
+    def get(id)
+      @http.data('GET', "/broadcasts/#{id}")
+    end
+
+    # Create a broadcast (safe retry with idempotency_key).
+    def create(input, idempotency_key: nil)
+      @http.data('POST', '/broadcasts', body: input, idempotency_key: idempotency_key)
+    end
+
+    # Editable only in the draft/scheduled/failed stage.
+    def update(id, input)
+      @http.data('PATCH', "/broadcasts/#{id}", body: input)
+    end
+
+    # Delete a broadcast.
+    def delete(id)
+      @http.data('DELETE', "/broadcasts/#{id}")
+    end
+
+    # Asynchronous (202): sending happens in the background; poll progress with get(id).
+    def send(id)
+      @http.data('POST', "/broadcasts/#{id}/send")
+    end
+
+    # draft → scheduled; when the time comes the server scheduler starts the send.
+    def schedule(id, scheduled_at)
+      @http.data('POST', "/broadcasts/#{id}/schedule", body: { 'scheduledAt' => scheduled_at })
+    end
+
+    # scheduled → draft (content is preserved).
+    def cancel(id)
+      @http.data('POST', "/broadcasts/#{id}/cancel")
+    end
+
+    # Recipients: contact name + per-target status (paginated envelope).
+    def recipients(id, limit: nil, cursor: nil)
+      @http.req('GET', "/broadcasts/#{id}/recipients", query: { 'limit' => limit, 'cursor' => cursor })
+    end
+
+    # Add recipients (duplicates are skipped) — only draft/scheduled.
+    def add_recipients(id, contact_ids)
+      @http.data('POST', "/broadcasts/#{id}/recipients", body: { 'contactIds' => contact_ids })
+    end
+  end
+
+  # Message sequence — CRUD + activate/pause + enroll/unenroll (Node sdk .sequences).
+  class SequencesResource
+    def initialize(http)
+      @http = http
+    end
+
+    # Sequence list (paginated envelope).
+    def list(status: nil, limit: nil, cursor: nil)
+      @http.req('GET', '/sequences', query: { 'status' => status, 'limit' => limit, 'cursor' => cursor })
+    end
+
+    # A single sequence.
+    def get(id)
+      @http.data('GET', "/sequences/#{id}")
+    end
+
+    # Create a sequence (steps + status/platform/account_id/exit_on_reply/exit_on_unsubscribe).
+    def create(input)
+      @http.data('POST', '/sequences', body: input)
+    end
+
+    # Update a sequence (partial).
+    def update(id, input)
+      @http.data('PATCH', "/sequences/#{id}", body: input)
+    end
+
+    # Delete a sequence.
+    def delete(id)
+      @http.data('DELETE', "/sequences/#{id}")
+    end
+
+    # Activate a sequence.
+    def activate(id)
+      @http.data('POST', "/sequences/#{id}/activate")
+    end
+
+    # Pause a sequence.
+    def pause(id)
+      @http.data('POST', "/sequences/#{id}/pause")
+    end
+
+    # Enroll contacts into a sequence.
+    def enroll(id, contact_ids)
+      @http.data('POST', "/sequences/#{id}/enroll", body: { 'contactIds' => contact_ids })
+    end
+
+    # Sequence enrollments.
+    def enrollments(id)
+      @http.data('GET', "/sequences/#{id}/enrollments")
+    end
+
+    # Remove a contact from a sequence.
+    def unenroll(id, contact_id)
+      @http.data('POST', "/sequences/#{id}/unenroll", body: { 'contactId' => contact_id })
+    end
+  end
+  # Custom fields (D3) — definition CRUD + per-contact value (Node sdk .customFields).
+  class CustomFieldsResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list
+      @http.data('GET', '/custom-fields')
+    end
+
+    def create(input)
+      @http.data('POST', '/custom-fields', body: input)
+    end
+
+    def update(key, input)
+      @http.data('PATCH', "/custom-fields/#{key}", body: input)
+    end
+
+    def delete(key)
+      @http.data('DELETE', "/custom-fields/#{key}")
+    end
+
+    def values_for(contact_id)
+      @http.data('GET', "/contacts/#{contact_id}/fields")
+    end
+
+    def set_value(contact_id, key, value)
+      @http.data('PUT', "/contacts/#{contact_id}/fields/#{key}", body: { 'value' => value })
+    end
+
+    def clear_value(contact_id, key)
+      @http.data('DELETE', "/contacts/#{contact_id}/fields/#{key}")
+    end
+  end
+
+  # WhatsApp Business — message templates (D1). account_id = the connected WhatsApp account.
+  # Only status=APPROVED templates can be sent; creation goes to Meta for approval (PENDING).
+  class WhatsAppResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list_templates(account_id, status: nil, limit: nil)
+      @http.data('GET', "/whatsapp/#{account_id}/templates",
+                 query: { 'status' => status, 'limit' => limit })
+    end
+
+    def get_template(account_id, name)
+      @http.data('GET', "/whatsapp/#{account_id}/templates/#{name}")
+    end
+
+    def create_template(account_id, input)
+      @http.data('POST', "/whatsapp/#{account_id}/templates", body: input)
+    end
+
+    def edit_template(account_id, template_id, input)
+      @http.data('PATCH', "/whatsapp/#{account_id}/templates/#{template_id}", body: input)
+    end
+
+    def delete_template(account_id, name, hsm_id: nil)
+      @http.data('DELETE', "/whatsapp/#{account_id}/templates/#{name}", query: { 'hsmId' => hsm_id })
+    end
+
+    def send_template(account_id, input)
+      @http.data('POST', "/whatsapp/#{account_id}/template-messages", body: input)
+    end
+
+    def get_profile(account_id)
+      @http.data('GET', "/whatsapp/#{account_id}/profile")
+    end
+
+    def update_profile(account_id, input)
+      @http.data('PATCH', "/whatsapp/#{account_id}/profile", body: input)
+    end
+
+    def request_code(account_id, input)
+      @http.data('POST', "/whatsapp/#{account_id}/request-code", body: input)
+    end
+
+    def verify_code(account_id, code)
+      @http.data('POST', "/whatsapp/#{account_id}/verify-code", body: { 'code' => code })
+    end
+
+    def register(account_id, pin)
+      @http.data('POST', "/whatsapp/#{account_id}/register", body: { 'pin' => pin })
+    end
+
+    def set_two_step_pin(account_id, pin)
+      @http.data('POST', "/whatsapp/#{account_id}/two-step", body: { 'pin' => pin })
+    end
+
+    def list_blocked(account_id, limit: nil)
+      @http.data('GET', "/whatsapp/#{account_id}/blocked", query: { 'limit' => limit })
+    end
+
+    def block(account_id, users)
+      @http.data('POST', "/whatsapp/#{account_id}/block", body: { 'users' => users })
+    end
+
+    def unblock(account_id, users)
+      @http.data('POST', "/whatsapp/#{account_id}/unblock", body: { 'users' => users })
+    end
+
+    # --- Flows (D1e) ---
+    def list_flows(account_id)
+      @http.data('GET', "/whatsapp/#{account_id}/flows")
+    end
+
+    def get_flow(account_id, flow_id)
+      @http.data('GET', "/whatsapp/#{account_id}/flows/#{flow_id}")
+    end
+
+    def create_flow(account_id, input)
+      @http.data('POST', "/whatsapp/#{account_id}/flows", body: input)
+    end
+
+    def update_flow(account_id, flow_id, input)
+      @http.data('PATCH', "/whatsapp/#{account_id}/flows/#{flow_id}", body: input)
+    end
+
+    def delete_flow(account_id, flow_id)
+      @http.data('DELETE', "/whatsapp/#{account_id}/flows/#{flow_id}")
+    end
+
+    def upload_flow_json(account_id, flow_id, flow_json)
+      @http.data('PUT', "/whatsapp/#{account_id}/flows/#{flow_id}/json", body: { 'flowJson' => flow_json })
+    end
+
+    def publish_flow(account_id, flow_id)
+      @http.data('POST', "/whatsapp/#{account_id}/flows/#{flow_id}/publish")
+    end
+
+    def deprecate_flow(account_id, flow_id)
+      @http.data('POST', "/whatsapp/#{account_id}/flows/#{flow_id}/deprecate")
+    end
+
+    def get_flow_preview(account_id, flow_id, invalidate: nil)
+      @http.data('GET', "/whatsapp/#{account_id}/flows/#{flow_id}/preview",
+                 query: { 'invalidate' => invalidate })
+    end
+
+    # --- Sandbox (D1f) — shared test number sessions ---
+    def sandbox_list_sessions
+      @http.data('GET', '/whatsapp/sandbox/sessions')
+    end
+
+    def sandbox_create_session(phone)
+      @http.data('POST', '/whatsapp/sandbox/sessions', body: { 'phone' => phone })
+    end
+
+    def sandbox_revoke_session(session_id)
+      @http.data('DELETE', "/whatsapp/sandbox/sessions/#{session_id}")
+    end
+
+    # --- Calling (D1g) — voice calls ---
+    def calling_get_config(account_id)
+      @http.data('GET', '/whatsapp/calling', query: { 'accountId' => account_id })
+    end
+
+    def calling_enable(account_id, input)
+      @http.data('POST', "/whatsapp/phone-numbers/#{account_id}/calling", body: input)
+    end
+
+    def calling_update(account_id, input)
+      @http.data('PATCH', "/whatsapp/phone-numbers/#{account_id}/calling", body: input)
+    end
+
+    def calling_disable(account_id)
+      @http.data('DELETE', "/whatsapp/phone-numbers/#{account_id}/calling")
+    end
+
+    def call_permissions(account_id, to)
+      @http.data('GET', '/whatsapp/call-permissions', query: { 'accountId' => account_id, 'to' => to })
+    end
+
+    def place_call(account_id, input)
+      @http.data('POST', '/whatsapp/calls', body: { 'accountId' => account_id }.merge(input))
+    end
+
+    def list_calls(account_id, limit: nil)
+      @http.data('GET', '/whatsapp/calls', query: { 'accountId' => account_id, 'limit' => limit })
+    end
+
+    def get_call(account_id, call_id)
+      @http.data('GET', "/whatsapp/calls/#{call_id}", query: { 'accountId' => account_id })
+    end
+
+    def estimate_call(to, recording: nil)
+      @http.data('GET', '/whatsapp/calls/estimate', query: { 'to' => to, 'recording' => recording })
+    end
+  end
+
+  # Google Business Profile (D2) — location + review. account_id = the connected GBP account.
+  class GmbResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list_locations(account_id, page_token: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-locations", query: { 'pageToken' => page_token })
+    end
+
+    def switch_location(account_id, location_name)
+      @http.data('PUT', "/accounts/#{account_id}/gmb-locations", body: { 'locationName' => location_name })
+    end
+
+    def list_reviews(account_id, location_id: nil, page_token: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-reviews",
+                 query: { 'locationId' => location_id, 'pageToken' => page_token })
+    end
+
+    def batch_reviews(account_id, location_names)
+      @http.data('POST', "/accounts/#{account_id}/gmb-reviews/batch",
+                 body: { 'locationNames' => location_names })
+    end
+
+    def reply_review(account_id, review_id, comment, location_id: nil)
+      @http.data('POST', "/accounts/#{account_id}/gmb-reviews/#{review_id}/reply",
+                 body: { 'comment' => comment }, query: { 'locationId' => location_id })
+    end
+
+    def delete_review_reply(account_id, review_id, location_id: nil)
+      @http.data('DELETE', "/accounts/#{account_id}/gmb-reviews/#{review_id}/reply",
+                 query: { 'locationId' => location_id })
+    end
+
+    # ── Listing content (D2 cp3) ──
+    def get_location_details(account_id, location_id: nil, read_mask: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-location-details",
+                 query: { 'locationId' => location_id, 'readMask' => read_mask })
+    end
+
+    def update_location_details(account_id, update_mask, patch, location_id: nil)
+      @http.data('PUT', "/accounts/#{account_id}/gmb-location-details",
+                 body: { 'updateMask' => update_mask, 'patch' => patch },
+                 query: { 'locationId' => location_id })
+    end
+
+    def get_attributes(account_id, location_id: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-attributes", query: { 'locationId' => location_id })
+    end
+
+    def update_attributes(account_id, attributes, attribute_mask, location_id: nil)
+      @http.data('PUT', "/accounts/#{account_id}/gmb-attributes",
+                 body: { 'attributes' => attributes, 'attributeMask' => attribute_mask },
+                 query: { 'locationId' => location_id })
+    end
+
+    def list_attribute_metadata(account_id, language_code:, location_id: nil, category_name: nil,
+                                region_code: nil, page_size: nil, page_token: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-attribute-metadata",
+                 query: { 'languageCode' => language_code, 'locationId' => location_id,
+                          'categoryName' => category_name, 'regionCode' => region_code,
+                          'pageSize' => page_size, 'pageToken' => page_token })
+    end
+
+    def get_services(account_id, location_id: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-services", query: { 'locationId' => location_id })
+    end
+
+    def update_services(account_id, service_items, location_id: nil)
+      @http.data('PUT', "/accounts/#{account_id}/gmb-services",
+                 body: { 'serviceItems' => service_items }, query: { 'locationId' => location_id })
+    end
+
+    def get_food_menus(account_id, location_id: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-food-menus", query: { 'locationId' => location_id })
+    end
+
+    def update_food_menus(account_id, menus, update_mask: nil, location_id: nil)
+      @http.data('PUT', "/accounts/#{account_id}/gmb-food-menus",
+                 body: { 'menus' => menus, 'updateMask' => update_mask },
+                 query: { 'locationId' => location_id })
+    end
+
+    # ── Media (D2 cp3) ──
+    def list_media(account_id, location_id: nil, page_size: nil, page_token: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-media",
+                 query: { 'locationId' => location_id, 'pageSize' => page_size, 'pageToken' => page_token })
+    end
+
+    def create_media(account_id, source_url, category, location_id: nil)
+      @http.data('POST', "/accounts/#{account_id}/gmb-media",
+                 body: { 'sourceUrl' => source_url, 'category' => category },
+                 query: { 'locationId' => location_id })
+    end
+
+    def delete_media(account_id, media_id, location_id: nil)
+      @http.data('DELETE', "/accounts/#{account_id}/gmb-media",
+                 query: { 'mediaId' => media_id, 'locationId' => location_id })
+    end
+
+    # ── Place actions (D2 cp3) ──
+    def list_place_actions(account_id, location_id: nil, page_size: nil, page_token: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-place-actions",
+                 query: { 'locationId' => location_id, 'pageSize' => page_size, 'pageToken' => page_token })
+    end
+
+    def create_place_action(account_id, uri, place_action_type, location_id: nil)
+      @http.data('POST', "/accounts/#{account_id}/gmb-place-actions",
+                 body: { 'uri' => uri, 'placeActionType' => place_action_type },
+                 query: { 'locationId' => location_id })
+    end
+
+    def update_place_action(account_id, name, uri: nil, place_action_type: nil, location_id: nil)
+      @http.data('PATCH', "/accounts/#{account_id}/gmb-place-actions",
+                 body: { 'name' => name, 'uri' => uri, 'placeActionType' => place_action_type },
+                 query: { 'locationId' => location_id })
+    end
+
+    def delete_place_action(account_id, name, location_id: nil)
+      @http.data('DELETE', "/accounts/#{account_id}/gmb-place-actions",
+                 query: { 'name' => name, 'locationId' => location_id })
+    end
+
+    # ── Verification (D2 cp3) ──
+    def get_verifications(account_id, location_id: nil)
+      @http.data('GET', "/accounts/#{account_id}/gmb-verifications", query: { 'locationId' => location_id })
+    end
+
+    def start_verification(account_id, body, location_id: nil)
+      @http.data('POST', "/accounts/#{account_id}/gmb-verifications",
+                 body: body, query: { 'locationId' => location_id })
+    end
+
+    def fetch_verification_options(account_id, language_code, context: nil, location_id: nil)
+      @http.data('POST', "/accounts/#{account_id}/gmb-verifications/options",
+                 body: { 'languageCode' => language_code, 'context' => context },
+                 query: { 'locationId' => location_id })
+    end
+
+    def complete_verification(account_id, verification_id, pin, location_id: nil)
+      @http.data('POST', "/accounts/#{account_id}/gmb-verifications/#{verification_id}/complete",
+                 body: { 'pin' => pin }, query: { 'locationId' => location_id })
+    end
+  end
+
+  # Discord community-ops (D6) — role/member/event/pin/DM/settings. account_id scopes to the connected account.
+  class DiscordResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list_roles(account_id, guild_id)
+      @http.data('GET', "/discord/guilds/#{guild_id}/roles", query: { 'accountId' => account_id })
+    end
+
+    def list_members(account_id, guild_id, limit: nil, after: nil)
+      @http.data('GET', "/discord/guilds/#{guild_id}/members",
+                 query: { 'accountId' => account_id, 'limit' => limit, 'after' => after })
+    end
+
+    def assign_role(account_id, guild_id, user_id, role_id)
+      @http.data('PUT', "/discord/guilds/#{guild_id}/members/#{user_id}/roles/#{role_id}",
+                 query: { 'accountId' => account_id })
+    end
+
+    def remove_role(account_id, guild_id, user_id, role_id)
+      @http.data('DELETE', "/discord/guilds/#{guild_id}/members/#{user_id}/roles/#{role_id}",
+                 query: { 'accountId' => account_id })
+    end
+
+    def list_events(account_id, guild_id, with_user_count: nil)
+      @http.data('GET', "/discord/guilds/#{guild_id}/events",
+                 query: { 'accountId' => account_id, 'withUserCount' => with_user_count })
+    end
+
+    def create_event(account_id, guild_id, body)
+      @http.data('POST', "/discord/guilds/#{guild_id}/events", query: { 'accountId' => account_id }, body: body)
+    end
+
+    def get_event(account_id, guild_id, event_id, with_user_count: nil)
+      @http.data('GET', "/discord/guilds/#{guild_id}/events/#{event_id}",
+                 query: { 'accountId' => account_id, 'withUserCount' => with_user_count })
+    end
+
+    def update_event(account_id, guild_id, event_id, body)
+      @http.data('PATCH', "/discord/guilds/#{guild_id}/events/#{event_id}",
+                 query: { 'accountId' => account_id }, body: body)
+    end
+
+    def delete_event(account_id, guild_id, event_id)
+      @http.data('DELETE', "/discord/guilds/#{guild_id}/events/#{event_id}", query: { 'accountId' => account_id })
+    end
+
+    def list_pins(account_id, channel_id)
+      @http.data('GET', "/discord/channels/#{channel_id}/pins", query: { 'accountId' => account_id })
+    end
+
+    def pin(account_id, channel_id, message_id)
+      @http.data('PUT', "/discord/channels/#{channel_id}/pins/#{message_id}", query: { 'accountId' => account_id })
+    end
+
+    def unpin(account_id, channel_id, message_id)
+      @http.data('DELETE', "/discord/channels/#{channel_id}/pins/#{message_id}", query: { 'accountId' => account_id })
+    end
+
+    def send_dm(body)
+      @http.data('POST', '/discord/dms', body: body)
+    end
+
+    def list_channels(account_id)
+      @http.data('GET', "/accounts/#{account_id}/discord-channels")
+    end
+
+    def get_settings(account_id)
+      @http.data('GET', "/accounts/#{account_id}/discord-settings")
+    end
+
+    def update_settings(account_id, patch)
+      @http.data('PATCH', "/accounts/#{account_id}/discord-settings", body: patch)
+    end
+  end
+
+  # Content discovery (D7) — read-only Reddit feed/search + LinkedIn mention via the connected account.
+  class DiscoveryResource
+    def initialize(http)
+      @http = http
+    end
+
+    def reddit_feed(account_id, subreddit, query = {})
+      @http.data('GET', '/reddit/feed', query: { 'accountId' => account_id, 'subreddit' => subreddit }.merge(query))
+    end
+
+    def reddit_search(account_id, q, query = {})
+      @http.data('GET', '/reddit/search', query: { 'accountId' => account_id, 'q' => q }.merge(query))
+    end
+
+    def linkedin_mentions(account_id, q)
+      @http.data('GET', "/accounts/#{account_id}/linkedin-mentions", query: { 'q' => q })
+    end
+  end
+
+end