fopost 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1845a9113bbfdb41688fd430794d43749707b835d82e2f0a4df826df43b4f1da
-  data.tar.gz: '08c64a3e1385d13789b22b5924f8672bcffbcf89dd524da03e8f3b94806fefc3'
+  metadata.gz: 39dcfa4fd395633ab79afe8b23b7888c9c76ad6b07d7bd86c874c56335647f48
+  data.tar.gz: 49ebacabb32eb4054db27d6bf69e14eae7f828a4071207c921b6dd9b5ef529ad
 SHA512:
-  metadata.gz: d151dc7b437cfeb9e3369c3455f5534c8a2a599a17084eb5b6cc5ba77d5bc2d53ffdf887abba1eb33836e04b34d9d60b04f9b7958c9263e2882056137d07d1d9
-  data.tar.gz: 05f02730b6ab206ae44dbcaee5910253e10a28f8f6fd2eaa2f9f0d6ecae7c44e598716a4eff08e9f77565c528070dc9a8f68ea4075b59a7f5da93cf3af09487c
+  metadata.gz: c4e179a15c45093239bd90ec0664c5ce49a491e11a750b7152448dcfebac7edb7fd2538798789f9eb1859efa0bdf6e0d24bc35c9f1b782fdc68ee4dcc337cb4d
+  data.tar.gz: 82b98ae4e3eb9c9004454abf091c693dbe254a6d7983b990d57e9766bc760b169016f328284730b0292d0b6776d1b6e75da48204cd1e6da0fc16fc80d6e56164

data/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this gem are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the gem follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-09-19
+
+### Added
+
+- `inbox` resource: list items, threads and conversations, unread count, accounts and
+  platforms, mark a thread read, refresh, update state, reply, hide, unhide, delete, and the
+  reply approvals (`inbox` scope).
+- `ads` resource: ads, external ads, boostable posts, connections, sources, Meta authorization,
+  boost, create, refresh, set status, delete, audiences, targeting search, lead forms and leads
+  (`ads` scope; `boost`, `create`, `set_status` and `delete` also need `publish`).
+
 ## [0.1.0] - 2026-08-30
 
 Initial release.
@@ -15,4 +26,5 @@ Initial release.
 - Response models that accept either wire casing and keep unknown fields on `#raw`.
 - A pluggable transport, so the HTTP stack can be swapped or stubbed.
 
+[0.2.0]: https://github.com/fopost/fopost-ruby/releases/tag/v0.2.0
 [0.1.0]: https://github.com/fopost/fopost-ruby/releases/tag/v0.1.0

data/README.md

@@ -25,7 +25,7 @@ gem install fopost
 
 ## Get an API key
 
-Create a key at [app.fopost.com/api-keys](https://app.fopost.com/api-keys). The full API reference lives at [fopost.com/docs](https://fopost.com/docs).
+Create a key at [fopost.com/dashboard/api-keys](https://fopost.com/dashboard/api-keys). The full API reference lives at [fopost.com/docs](https://fopost.com/docs).
 
 ## Quick start
 
@@ -152,6 +152,59 @@ repurposed = client.ai.repurpose_url(
 
 > **API keys reach `credits` and `generate_caption`.** `rewrite` and `repurpose_url` currently require a signed-in dashboard session and answer `401` to an API key. They are here so the surface is complete once the server opens them up.
 
+## Inbox
+
+Comments, mentions and direct messages on connected accounts. Needs the `inbox` scope.
+
+```ruby
+page = client.inbox.list(workspace_id: workspace.id, state: 'unread', sort: 'unanswered')
+page.each { |item| puts "#{item.platform} #{item.author_handle}: #{item.text}" }
+
+client.inbox.threads(workspace_id: workspace.id)         # one row per post with comments
+client.inbox.conversations(workspace_id: workspace.id)   # one row per DM thread
+client.inbox.unread_count(workspace_id: workspace.id)
+
+client.inbox.reply(item.id, text: 'Thanks!')
+client.inbox.update(item.id, state: 'snoozed', snoozed_until: Time.utc(2026, 9, 20, 9))
+client.inbox.hide(item.id)
+client.inbox.mark_thread_read(workspace_id: workspace.id, account_id: item.account.id,
+                              post_external_id: item.post_external_id)
+client.inbox.refresh(workspace_id: workspace.id)
+
+client.inbox.approvals(workspace_id: workspace.id).each { |a| client.inbox.approve_reply(a.id) }
+```
+
+## Ads
+
+Meta ads, audiences and lead forms. Every call needs the `ads` scope; `boost`, `create`, `set_status` and `delete` spend money and also need `publish`. A boost or ad starts paused unless you pass `paused: false`.
+
+```ruby
+url = client.ads.authorize_meta(workspace_id: workspace.id)   # finish the Meta login in a browser
+source = client.ads.sources(workspace_id: workspace.id).first
+
+ad = client.ads.boost(
+  workspace_id: workspace.id,
+  connection_id: source.connection_id,
+  ad_account_id: source.ad_accounts.first['id'],
+  post_id: post.id,
+  account_id: accounts.first.id,
+  name: 'Launch boost',
+  goal: 'engagement',
+  budget: { minor: 5000, type: 'daily' },
+  targeting: { countries: ['US'] }
+)
+
+client.ads.set_status(ad.id, workspace_id: workspace.id, status: 'active')
+client.ads.refresh(ad.id, workspace_id: workspace.id).insights.impressions
+client.ads.list(workspace_id: workspace.id)
+client.ads.external(workspace_id: workspace.id)   # ads made outside FoPost, read live
+
+client.ads.audiences(connection_id: source.connection_id, ad_account_id: 'act_123')
+client.ads.search_targeting(connection_id: source.connection_id, type: 'interest', q: 'coffee')
+client.ads.lead_forms(workspace_id: workspace.id)
+client.ads.leads('form_1', connection_id: source.connection_id, page_id: '42')
+```
+
 ## Errors
 
 Every non-2xx response raises. All of them are rescuable as `Fopost::Error`.

data/lib/fopost/client.rb

@@ -4,7 +4,9 @@ require 'fopost/http/client'
 require 'fopost/models'
 require 'fopost/resources/base'
 require 'fopost/resources/accounts'
+require 'fopost/resources/ads'
 require 'fopost/resources/ai'
+require 'fopost/resources/inbox'
 require 'fopost/resources/labels'
 require 'fopost/resources/posts'
 require 'fopost/resources/workspaces'
@@ -21,7 +23,7 @@ module Fopost
   class Client
     DEFAULT_BASE_URL = HTTP::Client::DEFAULT_BASE_URL
 
-    attr_reader :posts, :accounts, :workspaces, :labels, :ai
+    attr_reader :posts, :accounts, :workspaces, :labels, :ai, :inbox, :ads
 
     def initialize(api_key: nil, base_url: DEFAULT_BASE_URL, timeout: HTTP::Client::DEFAULT_TIMEOUT,
                    max_retries: HTTP::Client::DEFAULT_MAX_RETRIES, transport: nil, sleeper: nil)
@@ -45,6 +47,8 @@ module Fopost
       @workspaces = Resources::Workspaces.new(@http)
       @labels = Resources::Labels.new(@http)
       @ai = Resources::Ai.new(@http)
+      @inbox = Resources::Inbox.new(@http)
+      @ads = Resources::Ads.new(@http)
     end
 
     def base_url

data/lib/fopost/models.rb

@@ -205,4 +205,281 @@ module Fopost
     attribute :posts, :hash
     attribute :credits, AiCredits
   end
+
+  # `page`, `per_page`, `total` on the inbox list endpoints.
+  class InboxPageMeta < Model
+    attribute :page
+    attribute :per_page
+    attribute :total
+  end
+
+  class InboxAccountRef < Model
+    attribute :id
+    attribute :platform
+    attribute :username
+    attribute :name
+    attribute :avatar
+  end
+
+  class InboxAttachment < Model
+    attribute :kind
+    attribute :name
+    attribute :width
+    attribute :height
+    attribute :link
+    attribute :url
+    attribute :preview_url
+  end
+
+  # The platform post an item sits under, whoever published it.
+  class InboxPostContext < Model
+    attribute :external_id
+    attribute :is_own
+    attribute :text
+    attribute :author_name
+    attribute :author_handle
+    attribute :author_avatar_url
+    attribute :thumbnail_url
+    attribute :permalink
+    attribute :published_at, :time
+    attribute :published, :hash
+  end
+
+  # A comment, mention or direct message on a connected account.
+  class InboxItem < Model
+    attribute :id
+    attribute :workspace_id
+    attribute :platform
+    attribute :type
+    attribute :state
+    attribute :direction
+    attribute :conversation_id
+    attribute :author_name
+    attribute :author_handle
+    attribute :author_avatar_url
+    attribute :text
+    attribute :attachments, [InboxAttachment]
+    attribute :permalink
+    attribute :post_external_id
+    attribute :parent_external_id
+    attribute :platform_created_at, :time
+    attribute :snoozed_until, :time
+    attribute :replied_at, :time
+    attribute :created_at, :time
+    attribute :can_reply
+    attribute :hidden
+    attribute :can_hide
+    attribute :can_delete
+    attribute :post, :hash
+    attribute :post_context, InboxPostContext
+    attribute :account, InboxAccountRef
+  end
+
+  # One platform post and the comments it has collected.
+  class InboxThread < Model
+    attribute :workspace_id
+    attribute :account_id
+    attribute :post_external_id
+    attribute :comment_count
+    attribute :unread_count
+    attribute :last_comment_at, :time
+    attribute :last_comment_text
+    attribute :last_comment_author
+    attribute :post, InboxPostContext
+    attribute :account, InboxAccountRef
+  end
+
+  # One direct-message thread.
+  class InboxConversation < Model
+    attribute :workspace_id
+    attribute :account_id
+    attribute :conversation_id
+    attribute :message_count
+    attribute :unread_count
+    attribute :last_message_at, :time
+    attribute :last_message_text
+    attribute :last_message_outbound
+    attribute :participant, :hash
+    attribute :account, InboxAccountRef
+  end
+
+  class InboxAccount < Model
+    attribute :id
+    attribute :workspace_id
+    attribute :platform
+    attribute :username
+    attribute :name
+    attribute :avatar
+    attribute :inbox_supported
+    attribute :pending_reason
+    attribute :dm_supported
+    attribute :dm_pending_reason
+  end
+
+  class InboxPlatform < Model
+    attribute :platform
+    attribute :comments
+    attribute :dms
+  end
+
+  # A drafted reply a person still has to send.
+  class InboxApproval < Model
+    attribute :id
+    attribute :workspace_id
+    attribute :source
+    attribute :reply
+    attribute :created_at, :time
+    attribute :item, :hash
+  end
+
+  class InboxReplyResult < Model
+    attribute :item, InboxItem
+    attribute :reply, :hash
+  end
+
+  class InboxRefreshResult < Model
+    attribute :accounts_polled
+    attribute :new_items
+    attribute :rate_limited
+    attribute :dm_reconnect
+  end
+
+  # Lifetime numbers from the last refresh. `spend_minor` is in the ad
+  # account currency, minor units.
+  class AdInsights < Model
+    attribute :impressions
+    attribute :reach
+    attribute :clicks
+    attribute :spend_minor
+  end
+
+  # A boost or standalone ad created through FoPost.
+  class Ad < Model
+    attribute :id
+    attribute :workspace_id
+    attribute :kind
+    attribute :name
+    attribute :goal
+    attribute :status
+    attribute :effective_status
+    attribute :connection_id
+    attribute :account_id
+    attribute :platform
+    attribute :ad_account_id
+    attribute :source_post_id
+    attribute :budget_minor
+    attribute :budget_type
+    attribute :currency
+    attribute :end_at, :time
+    attribute :targeting, :hash
+    attribute :creative, :hash
+    attribute :insights, AdInsights
+    attribute :insights_at, :time
+    attribute :last_error
+    attribute :created_at, :time
+  end
+
+  # An ad on a connected ad account that was made outside FoPost.
+  class ExternalAd < Model
+    attribute :id
+    attribute :name
+    attribute :effective_status
+    attribute :campaign_id
+    attribute :campaign_name
+    attribute :objective
+    attribute :budget_minor
+    attribute :budget_type
+    attribute :end_at, :time
+    attribute :created_at, :time
+    attribute :connection_id
+    attribute :ad_account_id
+    attribute :currency
+    attribute :workspace_id
+  end
+
+  class AdConnection < Model
+    attribute :id
+    attribute :provider
+    attribute :auth_type
+    attribute :name
+    attribute :business_id
+    attribute :created_at, :time
+    attribute :workspace_id
+  end
+
+  # A connection with the ad accounts and Pages its grant reaches.
+  class AdSource < Model
+    attribute :connection_id
+    attribute :name
+    attribute :workspace_id
+    attribute :ad_accounts
+    attribute :pages
+    attribute :error
+  end
+
+  class BoostablePost < Model
+    attribute :id
+    attribute :workspace_id
+    attribute :text
+    attribute :thumbnail_url
+    attribute :deliveries
+  end
+
+  class Audience < Model
+    attribute :id
+    attribute :name
+    attribute :subtype
+    attribute :description
+    attribute :size_lower
+    attribute :size_upper
+    attribute :delivery_status
+    attribute :created_at
+  end
+
+  class AudiencesResult < Model
+    attribute :audiences, [Audience]
+    attribute :pixels
+    attribute :workspace_id
+  end
+
+  class TargetingOption < Model
+    attribute :id
+    attribute :name
+    attribute :detail
+  end
+
+  class LeadForm < Model
+    attribute :id
+    attribute :name
+    attribute :status
+    attribute :leads_count
+    attribute :created_at
+    attribute :questions
+  end
+
+  class LeadFormSource < Model
+    attribute :connection_id
+    attribute :connection_name
+    attribute :page_id
+    attribute :page_name
+    attribute :forms, [LeadForm]
+    attribute :error
+    attribute :workspace_id
+  end
+
+  class Lead < Model
+    attribute :id
+    attribute :created_at
+    attribute :fields
+    attribute :ad_name
+    attribute :campaign_name
+    attribute :platform
+    attribute :is_organic
+  end
+
+  # One page of leads; pass `next_cursor` back as `after:` for the next.
+  class LeadsPage < Model
+    attribute :leads, [Lead]
+    attribute :next_cursor
+  end
 end

data/lib/fopost/resources/ads.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Fopost
+  module Resources
+    # `client.ads` — Meta ads, audiences and lead forms.
+    #
+    # Every method needs the `ads` scope. {#boost}, {#create}, {#set_status}
+    # and {#delete} spend money and also need `publish`.
+    class Ads < Base
+      # Boosts and ads created through FoPost, with insights from their last refresh.
+      def list(workspace_id: nil)
+        parse_list(Ad, unwrap(http.get('/ads', { 'workspace_id' => workspace_id })))
+      end
+
+      # Ads on the connected ad accounts that were made elsewhere. Read live, never stored.
+      def external(workspace_id: nil)
+        parse_list(ExternalAd, unwrap(http.get('/ads/external', { 'workspace_id' => workspace_id })))
+      end
+
+      def boostable(workspace_id: nil)
+        parse_list(BoostablePost, unwrap(http.get('/ads/boostable', { 'workspace_id' => workspace_id })))
+      end
+
+      def connections(workspace_id: nil)
+        parse_list(AdConnection, unwrap(http.get('/ads/connections', { 'workspace_id' => workspace_id })))
+      end
+
+      # Each connection with the ad accounts and Pages its grant reaches.
+      def sources(workspace_id: nil)
+        parse_list(AdSource, unwrap(http.get('/ads/sources', { 'workspace_id' => workspace_id })))
+      end
+
+      # The Meta login URL; the caller finishes it in their own browser.
+      # `method` is "business" (default) or "user".
+      def authorize_meta(workspace_id:, method: nil, return_to: nil)
+        body = compact_nil('workspaceId' => workspace_id, 'method' => method, 'returnTo' => return_to)
+        result = unwrap(http.post('/ads/connections/meta/authorize', body))
+        url = result.is_a?(Hash) ? result['url'] : nil
+        url.nil? ? '' : url.to_s
+      end
+
+      # Also deletes every ad record created through the connection.
+      def delete_connection(connection_id, workspace_id:)
+        http.request(:delete, "/ads/connections/#{connection_id}", params: { 'workspace_id' => workspace_id })
+        nil
+      end
+
+      # Promote a post FoPost already published. Needs `ads` and `publish`.
+      # The boost starts paused unless `paused: false`.
+      def boost(workspace_id:, connection_id:, ad_account_id:, post_id:, account_id:, name:, goal:,
+                budget:, targeting:, paused: nil)
+        body = {
+          'workspaceId' => workspace_id,
+          'connectionId' => connection_id,
+          'adAccountId' => ad_account_id,
+          'postId' => post_id,
+          'accountId' => account_id,
+          'name' => name,
+          'goal' => goal,
+          'budget' => stringify(budget),
+          'targeting' => stringify(targeting)
+        }
+        body['paused'] = paused unless paused.nil?
+        Ad.new(unwrap(http.post('/ads/boost', body)))
+      end
+
+      # Create a standalone ad from a creative. Needs `ads` and `publish`.
+      # The ad starts paused unless `paused: false`.
+      def create(workspace_id:, connection_id:, ad_account_id:, page_id:, name:, goal:, budget:, targeting:,
+                 text:, headline: nil, destination_url: nil, media_url: nil, paused: nil)
+        body = {
+          'workspaceId' => workspace_id,
+          'connectionId' => connection_id,
+          'adAccountId' => ad_account_id,
+          'pageId' => page_id,
+          'name' => name,
+          'goal' => goal,
+          'budget' => stringify(budget),
+          'targeting' => stringify(targeting),
+          'text' => text
+        }
+        body.merge!(
+          compact_nil(
+            'headline' => headline,
+            'destinationUrl' => destination_url,
+            'mediaUrl' => media_url,
+            'paused' => paused
+          )
+        )
+        Ad.new(unwrap(http.post('/ads', body)))
+      end
+
+      # Read the delivery status and lifetime insights from Meta.
+      def refresh(ad_id, workspace_id:)
+        Ad.new(unwrap(http.request(:post, "/ads/#{ad_id}/refresh", params: { 'workspace_id' => workspace_id })))
+      end
+
+      # `status` is "active" or "paused". Needs `ads` and `publish`.
+      def set_status(ad_id, workspace_id:, status:)
+        Ad.new(
+          unwrap(
+            http.request(:patch, "/ads/#{ad_id}", json: { 'status' => status },
+                                                  params: { 'workspace_id' => workspace_id })
+          )
+        )
+      end
+
+      # End delivery and delete the ad on Meta as well as here. Needs `ads` and `publish`.
+      def delete(ad_id, workspace_id:)
+        http.request(:delete, "/ads/#{ad_id}", params: { 'workspace_id' => workspace_id })
+        nil
+      end
+
+      def audiences(connection_id:, ad_account_id:, workspace_id: nil)
+        AudiencesResult.new(
+          unwrap(
+            http.get(
+              '/ads/audiences',
+              { 'workspace_id' => workspace_id, 'connection_id' => connection_id, 'ad_account_id' => ad_account_id }
+            )
+          )
+        )
+      end
+
+      # `spec` carries a `subtype` of CUSTOM, LOOKALIKE or WEBSITE. Answers `{ id, added }`.
+      def create_audience(workspace_id:, connection_id:, ad_account_id:, name:, spec:, description: nil)
+        body = {
+          'workspaceId' => workspace_id,
+          'connectionId' => connection_id,
+          'adAccountId' => ad_account_id,
+          'name' => name,
+          'spec' => stringify(spec)
+        }
+        body['description'] = description unless description.nil?
+        as_hash(unwrap(http.post('/ads/audiences', body)))
+      end
+
+      # Locations, interests, behaviours and income brackets as Meta names them.
+      # `type` is country, region, city, zip, metro, interest, behavior or income.
+      def search_targeting(connection_id:, type:, q: nil, workspace_id: nil)
+        parse_list(
+          TargetingOption,
+          unwrap(
+            http.get(
+              '/ads/targeting/search',
+              { 'workspace_id' => workspace_id, 'connection_id' => connection_id, 'type' => type, 'q' => q }
+            )
+          )
+        )
+      end
+
+      def lead_forms(workspace_id: nil)
+        parse_list(LeadFormSource, unwrap(http.get('/ads/lead-forms', { 'workspace_id' => workspace_id })))
+      end
+
+      # Create an Instant Form on the Page. Returns its id.
+      def create_lead_form(workspace_id:, connection_id:, page_id:, name:, questions:, privacy_policy_url:,
+                           thank_you_message:, follow_up_url: nil)
+        body = {
+          'workspaceId' => workspace_id,
+          'connectionId' => connection_id,
+          'pageId' => page_id,
+          'name' => name,
+          'questions' => questions.to_a,
+          'privacyPolicyUrl' => privacy_policy_url,
+          'thankYouMessage' => thank_you_message
+        }
+        body['followUpUrl'] = follow_up_url unless follow_up_url.nil?
+        result = unwrap(http.post('/ads/lead-forms', body))
+        id = result.is_a?(Hash) ? result['id'] : nil
+        id.nil? ? '' : id.to_s
+      end
+
+      # One page of leads; pass `next_cursor` back as `after:` for the next.
+      def leads(form_id, connection_id:, page_id:, after: nil, workspace_id: nil)
+        LeadsPage.new(
+          unwrap(
+            http.get(
+              "/ads/lead-forms/#{form_id}/leads",
+              { 'workspace_id' => workspace_id, 'connection_id' => connection_id, 'page_id' => page_id,
+                'after' => after }
+            )
+          )
+        )
+      end
+
+      private
+
+      def stringify(hash)
+        hash.to_h.transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/fopost/resources/inbox.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Fopost
+  module Resources
+    # `client.inbox` — comments, mentions and direct messages on connected
+    # accounts. Every method needs the `inbox` scope.
+    class Inbox < Base
+      # One page of items, newest first. The result is Enumerable over its items.
+      #
+      # `type` is comment, mention or dm; `state` is unread, read, resolved or
+      # snoozed; `sort` is newest, oldest or unanswered.
+      def list(workspace_id: nil, type: nil, state: nil, platform: nil, account_id: nil, post_id: nil,
+               post_external_id: nil, conversation_id: nil, direction: nil, q: nil, sort: nil,
+               page: 1, per_page: 25)
+        body = http.get(
+          '/inbox',
+          {
+            'workspace_id' => workspace_id,
+            'type' => type,
+            'state' => state,
+            'platform' => platform,
+            'account_id' => account_id,
+            'post_id' => post_id,
+            'post_external_id' => post_external_id,
+            'conversation_id' => conversation_id,
+            'direction' => direction,
+            'q' => q,
+            'sort' => sort,
+            'page' => page,
+            'per_page' => per_page
+          }
+        )
+        page_of(InboxItem, body)
+      end
+
+      # One row per post with comments; `kind: 'mentions'` for posts the
+      # account was tagged in.
+      def threads(workspace_id: nil, kind: nil, platform: nil, account_id: nil, state: nil, q: nil,
+                  sort: nil, page: 1, per_page: 25)
+        body = http.get(
+          '/inbox/posts',
+          {
+            'workspace_id' => workspace_id,
+            'kind' => kind,
+            'platform' => platform,
+            'account_id' => account_id,
+            'state' => state,
+            'q' => q,
+            'sort' => sort,
+            'page' => page,
+            'per_page' => per_page
+          }
+        )
+        page_of(InboxThread, body)
+      end
+
+      # One row per DM thread, latest first.
+      def conversations(workspace_id: nil, platform: nil, account_id: nil, state: nil, q: nil, sort: nil,
+                        page: 1, per_page: 25)
+        body = http.get(
+          '/inbox/conversations',
+          {
+            'workspace_id' => workspace_id,
+            'platform' => platform,
+            'account_id' => account_id,
+            'state' => state,
+            'q' => q,
+            'sort' => sort,
+            'page' => page,
+            'per_page' => per_page
+          }
+        )
+        page_of(InboxConversation, body)
+      end
+
+      def unread_count(workspace_id: nil)
+        body = http.get('/inbox/unread-count', { 'workspace_id' => workspace_id })
+        count = body.is_a?(Hash) ? body['count'] : nil
+        count.is_a?(Integer) ? count : 0
+      end
+
+      # Every active account, flagged with whether comments and DMs can be read for it.
+      def accounts(workspace_id: nil)
+        parse_list(InboxAccount, unwrap(http.get('/inbox/accounts', { 'workspace_id' => workspace_id })))
+      end
+
+      def platforms
+        parse_list(InboxPlatform, unwrap(http.get('/inbox/platforms')))
+      end
+
+      # Mark a whole comment thread or DM thread read. Returns how many items changed.
+      def mark_thread_read(workspace_id:, account_id:, post_external_id: nil, conversation_id: nil)
+        body = compact_nil(
+          'workspace_id' => workspace_id,
+          'account_id' => account_id,
+          'post_external_id' => post_external_id,
+          'conversation_id' => conversation_id
+        )
+        result = unwrap(http.post('/inbox/read', body))
+        updated = result.is_a?(Hash) ? result['updated'] : nil
+        updated.is_a?(Integer) ? updated : 0
+      end
+
+      # Poll every inbox-capable account in the workspace now.
+      def refresh(workspace_id:)
+        InboxRefreshResult.new(unwrap(http.post('/inbox/refresh', { 'workspace_id' => workspace_id })))
+      end
+
+      # Set the item's state to unread, read, resolved or snoozed. A snooze
+      # needs `snoozed_until` in the future.
+      def update(item_id, state:, snoozed_until: nil)
+        body = compact_nil('state' => state, 'snoozedUntil' => iso8601(snoozed_until))
+        InboxItem.new(unwrap(http.request(:patch, "/inbox/#{item_id}", json: body)))
+      end
+
+      # Send the reply on the platform as the connected account.
+      def reply(item_id, text:)
+        InboxReplyResult.new(unwrap(http.post("/inbox/#{item_id}/reply", { 'text' => text })))
+      end
+
+      def hide(item_id)
+        InboxItem.new(unwrap(http.post("/inbox/#{item_id}/hide")))
+      end
+
+      def unhide(item_id)
+        InboxItem.new(unwrap(http.post("/inbox/#{item_id}/unhide")))
+      end
+
+      # Delete the comment on the platform.
+      def delete(item_id)
+        http.delete("/inbox/#{item_id}")
+        nil
+      end
+
+      # Replies an automation or the agent drafted that a person still has to send.
+      def approvals(workspace_id: nil)
+        parse_list(InboxApproval, unwrap(http.get('/inbox/approvals', { 'workspace_id' => workspace_id })))
+      end
+
+      # Send the draft, or `text` in its place.
+      def approve_reply(approval_id, text: nil)
+        as_hash(unwrap(http.post("/inbox/approvals/#{approval_id}/approve", compact_nil('text' => text))))
+      end
+
+      def reject_reply(approval_id)
+        as_hash(unwrap(http.post("/inbox/approvals/#{approval_id}/reject")))
+      end
+
+      private
+
+      def page_of(model, body)
+        items = parse_list(model, body.is_a?(Hash) ? body['data'] : body)
+        raw_meta = body.is_a?(Hash) ? body['meta'] : nil
+        Page.new(items: items, meta: InboxPageMeta.new(raw_meta.is_a?(Hash) ? raw_meta : {}))
+      end
+    end
+  end
+end

data/lib/fopost/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fopost
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fopost
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - FoPost
@@ -30,8 +30,10 @@ files:
 - lib/fopost/models.rb
 - lib/fopost/platforms.rb
 - lib/fopost/resources/accounts.rb
+- lib/fopost/resources/ads.rb
 - lib/fopost/resources/ai.rb
 - lib/fopost/resources/base.rb
+- lib/fopost/resources/inbox.rb
 - lib/fopost/resources/labels.rb
 - lib/fopost/resources/posts.rb
 - lib/fopost/resources/workspaces.rb