zelf-sdk 1.0.0

data/lib/zelf/page.rb

@@ -0,0 +1,114 @@
+module Zelf
+  # One page of results, plus the envelope metadata that came with it.
+  #
+  # The page keeps the request that produced it, so the next page is fetched by
+  # re-issuing that request with a new +page+ value.
+  class Page
+    include Enumerable
+
+    attr_reader :results, :log_id, :page, :item_count, :next_page_number,
+                :previous_page_number, :applied_filters
+
+    def initialize(envelope, model, transport, path, query)
+      @results = Array(envelope['results']).map { |row| model ? model.new(row) : row }
+      @log_id = envelope['log_id']
+      @page = envelope['page']
+      @item_count = envelope['item_count']
+      @next_page_number = envelope['next']
+      @previous_page_number = envelope['previous']
+      @applied_filters = envelope['applied_filters'] || {}
+      @model = model
+      @transport = transport
+      @path = path
+      @query = query
+    end
+
+    def each(&block)
+      @results.each(&block)
+    end
+
+    def size
+      @results.size
+    end
+
+    def next?
+      !@next_page_number.nil?
+    end
+
+    def inspect
+      "#<Zelf::Page page=#{@page} item_count=#{@item_count} next=#{next?}>"
+    end
+
+    # The page after this one, or nil when there is none.
+    def next_page
+      return nil unless next?
+
+      query = @query.reject { |key, _| key.to_s == 'page' }.merge('page' => @next_page_number)
+      envelope = @transport.request(:get, @path, query: query)
+      Page.new(envelope, @model, @transport, @path, query)
+    end
+
+    # Yield this page and the ones after it.
+    #
+    # +max_pages+ counts this page as the first, so <tt>max_pages: 1</tt>
+    # yields only what has already been fetched and makes no further request.
+    def pages(max_pages: nil)
+      return enum_for(:pages, max_pages: max_pages) unless block_given?
+
+      check_limit!(max_pages, 'max_pages')
+      current = self
+      seen = 0
+      while current
+        yield current
+        seen += 1
+        break if max_pages && seen >= max_pages
+
+        current = current.next_page
+      end
+    end
+
+    # Walk the remaining pages, yielding one item at a time.
+    #
+    # +max_pages+ bounds how many pages are fetched and +max_items+ how many
+    # items come back. Either one stops the walk, so no page is requested once
+    # enough items are in hand.
+    def auto_paging(max_pages: nil, max_items: nil)
+      return enum_for(:auto_paging, max_pages: max_pages, max_items: max_items) unless block_given?
+
+      check_limit!(max_items, 'max_items')
+      produced = 0
+      pages(max_pages: max_pages) do |page|
+        page.results.each do |row|
+          yield row
+          produced += 1
+          return nil if max_items && produced >= max_items
+        end
+      end
+      nil
+    end
+
+    private
+
+    def check_limit!(value, name)
+      return if value.nil?
+      raise ArgumentError, "#{name} must be 1 or greater" if value < 1
+    end
+  end
+
+  # Take the single row out of the envelope.
+  #
+  # Reads that match nothing come back as 200 with an empty +results+ array
+  # rather than a 404, so the empty case is raised as a not-found error.
+  def self.one(envelope, model, what)
+    rows = Array(envelope['results'])
+    if rows.empty?
+      raise NotFoundError.new("No #{what} matched the request.",
+                              status: 404, code: 'NOT_FOUND', log_id: envelope['log_id'])
+    end
+    model ? model.new(rows.first) : rows.first
+  end
+
+  def self.rows(envelope, model)
+    Array(envelope['results']).map { |row| model ? model.new(row) : row }
+  end
+end

data/lib/zelf/resources/ai_analysis.rb

@@ -0,0 +1,110 @@
+# Generated by codegen. Do not edit by hand.
+module Zelf
+  module Resources
+    # The ai_analysis endpoints.
+    class AiAnalysis
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # Get AI Analysis Content Statistics. Returns aggregate totals (post count, views,
+      # engagement, earned media value, and unique creators) over the content an AI analysis
+      # ran over. Requires `analysis_id` (an analysis `id` from `ai_analysis.list`) and
+      # returns the same totals shape as `content.statistics`.
+      #
+      # Calls GET /api/v1/ai_analysis/contents/statistics/ (ai_analysis.content_statistics).
+      def content_statistics(analysis_id:)
+        query = {
+          "analysis_id" => analysis_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/ai_analysis/contents/statistics/", query: query)
+        Zelf.one(envelope, Models::ContentStatistics, "ContentStatistics")
+      end
+
+      # List AI Analysis Content. Returns the content an AI analysis ran over, in the
+      # standard content shape. Use it to inspect the exact posts included in an analysis.
+      # Requires `analysis_id` (an analysis `id` from `ai_analysis.list`). Brand-scoped
+      # fields (`is_owned`, `is_tagged`, `net_promoter_score`, ...) are `null` in this
+      # response.
+      #
+      # Calls GET /api/v1/ai_analysis/contents/ (ai_analysis.contents).
+      def contents(analysis_id:, page: nil, page_size: nil)
+        query = {
+          "analysis_id" => analysis_id,
+          "page" => page,
+          "page_size" => page_size,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/ai_analysis/contents/", query: query)
+        path = @transport.resolve_path("/api/v1/ai_analysis/contents/".dup, {})
+        Zelf::Page.new(envelope, Models::Content, @transport, path, query)
+      end
+
+      # Create AI Analysis. Starts an AI analysis over the content matched by
+      # `content_filters` (or its comments) for a given `topic`. Runs complete
+      # asynchronously; this method returns immediately with the created analysis and its
+      # initial runs. The analysis runs over the highest-ranked matching content by
+      # `content_filters.order_by`, up to 500 posts or the limit configured for your
+      # workspace. When `order_by` is omitted, content is ranked by
+      # `earned_media_value_cents` descending. The created analysis is returned as the
+      # single item in `results`. Take its `id` and poll `ai_analysis.list` until a run
+      # reports `COMPLETED`. An analysis can take an hour or more, so poll at a moderate
+      # interval; prefer the `ai_analysis.completed` webhook over frequent polling, which
+      # can trigger `RATE_LIMIT_EXCEEDED`. Once complete, retrieve the payload from
+      # `ai_analysis.results`, passing `analysis_id=<id>`.
+      #
+      # Calls POST /api/v1/ai_analysis/ (ai_analysis.create).
+      def create(name:, topic:, content_filters:, analysis_scope: nil)
+        body = {
+          "name" => name,
+          "topic" => topic,
+          "content_filters" => content_filters,
+          "analysis_scope" => analysis_scope,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:post, "/api/v1/ai_analysis/", body: body)
+        Zelf.one(envelope, Models::AiAnalysis, "AiAnalysis")
+      end
+
+      # List AI Analyses. Returns the AI analyses that have been created, ordered newest
+      # first, each with its runs and their current `status`. It lists the analyses
+      # available and tracks run progress without retrieving the full result payload. An
+      # analysis `id` maps to `analysis_id` on `ai_analysis.results` and
+      # `ai_analysis.contents`, and each run's `id` maps to `id` on `ai_analysis.results`.
+      # The run `result` download is not included in this response; retrieve it from
+      # `ai_analysis.results` once a run reports `COMPLETED` (statuses: `IN_PROGRESS`,
+      # `COMPLETED`, `EMPTY_RESULT`, `FAILED`). Supply `id` to return a single analysis.
+      #
+      # Calls GET /api/v1/ai_analysis/ (ai_analysis.list).
+      def list(id: nil, page: nil, page_size: nil)
+        query = {
+          "id" => id,
+          "page" => page,
+          "page_size" => page_size,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/ai_analysis/", query: query)
+        path = @transport.resolve_path("/api/v1/ai_analysis/".dup, {})
+        Zelf::Page.new(envelope, Models::AiAnalysis, @transport, path, query)
+      end
+
+      # Get AI Analysis Results. Returns each run's `result`, a signed, time-limited
+      # download of the analysis payload. Call this method after a run reaches `COMPLETED`;
+      # for earlier statuses the row is returned with a `null` `result`. Supply
+      # `analysis_id` (the analysis `id` from `ai_analysis.list`) to return every run of
+      # that analysis, or `id` (a single run's `id`) to return one run. Exactly one is
+      # required. A malformed id returns `INVALID_ID`; omitting both returns
+      # `VALIDATION_ERROR`.
+      #
+      # Calls GET /api/v1/ai_analysis/results/ (ai_analysis.results).
+      def results(analysis_id: nil, id: nil, page: nil, page_size: nil)
+        query = {
+          "analysis_id" => analysis_id,
+          "id" => id,
+          "page" => page,
+          "page_size" => page_size,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/ai_analysis/results/", query: query)
+        path = @transport.resolve_path("/api/v1/ai_analysis/results/".dup, {})
+        Zelf::Page.new(envelope, Models::AiAnalysisResult, @transport, path, query)
+      end
+    end
+  end
+end

data/lib/zelf/resources/brand_accounts.rb

@@ -0,0 +1,65 @@
+# Generated by codegen. Do not edit by hand.
+module Zelf
+  module Resources
+    # The brand_accounts endpoints.
+    class BrandAccounts
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # Add Brand Accounts. Adds profiles to a brand's `tracked`, `influencer` or `owned`
+      # list. Use `owned` for the brand's own profiles. Each `profile_url` is matched and
+      # deduplicated by `(platform, username)`, so re-adding an existing account has no
+      # effect. URLs that cannot be parsed fail validation on `profile_urls`. Supply
+      # `brand_id` in the request body to target another brand; otherwise the brand the key
+      # acts on is used. Any brand listed by `brands.list` is a valid target, which includes
+      # linked top-level brands and their sub-brands.
+      #
+      # Calls POST /api/v1/brands/accounts/ (brand_accounts.add).
+      def add(account_type:, profile_urls:, brand_id: nil)
+        body = {
+          "account_type" => account_type,
+          "profile_urls" => profile_urls,
+          "brand_id" => brand_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:post, "/api/v1/brands/accounts/", body: body)
+        Zelf.rows(envelope, Models::BrandAccountGroups)
+      end
+
+      # List Brand Accounts. Returns a brand's tracked and influencer creator accounts, plus
+      # the `owned` accounts the brand operates itself. Defaults to the brand the key acts
+      # on. Supply `brand_id` to target another brand listed by `brands.list`, which
+      # includes linked top-level brands and their sub-brands. Restrict the response to a
+      # single list with the `account_type` parameter (`tracked`, `influencer` or `owned`).
+      #
+      # Calls GET /api/v1/brands/accounts/ (brand_accounts.list).
+      def list(account_type: nil, brand_id: nil)
+        query = {
+          "account_type" => account_type,
+          "brand_id" => brand_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/brands/accounts/", query: query)
+        Zelf.rows(envelope, Models::BrandAccountGroups)
+      end
+
+      # Remove Brand Accounts. Removes profiles from a brand's `tracked`, `influencer` or
+      # `owned` list. This operation is destructive; call it only when the intent is to stop
+      # following these accounts. Profiles are matched by `(platform, username)` parsed from
+      # each `profile_url`. Returns the updated list. Supply `brand_id` in the request body
+      # to target another brand; otherwise the brand the key acts on is used. Any brand
+      # listed by `brands.list` is a valid target, which includes linked top-level brands
+      # and their sub-brands.
+      #
+      # Calls DELETE /api/v1/brands/accounts/ (brand_accounts.remove).
+      def remove(account_type:, profile_urls:, brand_id: nil)
+        body = {
+          "account_type" => account_type,
+          "profile_urls" => profile_urls,
+          "brand_id" => brand_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:delete, "/api/v1/brands/accounts/", body: body)
+        Zelf.rows(envelope, Models::BrandAccountGroups)
+      end
+    end
+  end
+end

data/lib/zelf/resources/brands.rb

@@ -0,0 +1,83 @@
+# Generated by codegen. Do not edit by hand.
+module Zelf
+  module Resources
+    # The brands endpoints.
+    class Brands
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # Search Brand Catalog. Returns the brands Zelf curates for competitive benchmarking.
+      # Every api key can read content for these brands, whether or not they are linked to
+      # yours, so this is where to look for a competitor that is not one of your own sub-
+      # brands. Each row's `id` is the value to supply as `brand_id` on the content and AI
+      # analysis endpoints; the brand write endpoints do not accept it. Narrow the list with
+      # `search` (title substring), `industry_id`, or `category_id`; the id values for the
+      # last two come from `brands.catalog_categories`.
+      #
+      # Calls GET /api/v1/brands/catalog/ (brands.catalog).
+      def catalog(category_id: nil, industry_id: nil, order_by: nil, page: nil, search: nil)
+        query = {
+          "category_id" => category_id,
+          "industry_id" => industry_id,
+          "order_by" => order_by,
+          "page" => page,
+          "search" => search,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/brands/catalog/", query: query)
+        path = @transport.resolve_path("/api/v1/brands/catalog/".dup, {})
+        Zelf::Page.new(envelope, Models::BrandCatalog, @transport, path, query)
+      end
+
+      # List Brand Catalog Categories. Returns every industry and the categories under it,
+      # as one flat list. An industry has `level: industry` and a null `parent_id`; a
+      # category has `level: category` and the `parent_id` of its industry. Each `id` is the
+      # value to supply as `industry_id` or `category_id` to `brands.catalog`.
+      #
+      # Calls GET /api/v1/brands/catalog/categories/ (brands.catalog_categories).
+      def catalog_categories
+        envelope = @transport.request(:get, "/api/v1/brands/catalog/categories/")
+        Zelf.rows(envelope, Models::BrandCatalogItem)
+      end
+
+      # List Brands. Returns every brand this key can reach: the workspace brand, every
+      # brand linked to it, and the sub-brands of each. Start here when building a new
+      # integration, to find out which brand ids are available. Each row's `id` is the value
+      # to supply as `brand_id` wherever a brand is named. `is_primary` identifies the
+      # workspace brand, and `parent_brand_id` links a sub-brand to its parent.
+      #
+      # Calls GET /api/v1/brands/ (brands.list).
+      def list(page: nil)
+        query = {
+          "page" => page,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/brands/", query: query)
+        path = @transport.resolve_path("/api/v1/brands/".dup, {})
+        Zelf::Page.new(envelope, Models::Brand, @transport, path, query)
+      end
+
+      # Update Brand. Partially updates a brand's monitoring keywords. Only the supplied
+      # fields are modified. Targets the brand the key acts on unless `brand_id` is provided
+      # in the request body. Any brand listed by `brands.list` is a valid target. That list
+      # holds every brand linked to the key, each linked brand's sub-brands, and the key's
+      # own brand. A single key therefore reaches whole brand families, often dozens of
+      # brands, and this endpoint writes to all of them. Returns the updated brand.
+      #
+      # Calls PATCH /api/v1/brands/ (brands.update).
+      def update(search_terms: nil, inclusion_terms: nil, exclusion_terms: nil, compound_inclusion_terms: nil, influencer_terms: nil, allowed_languages: nil, boolean_query: nil, brand_id: nil)
+        body = {
+          "search_terms" => search_terms,
+          "inclusion_terms" => inclusion_terms,
+          "exclusion_terms" => exclusion_terms,
+          "compound_inclusion_terms" => compound_inclusion_terms,
+          "influencer_terms" => influencer_terms,
+          "allowed_languages" => allowed_languages,
+          "boolean_query" => boolean_query,
+          "brand_id" => brand_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:patch, "/api/v1/brands/", body: body)
+        Zelf.one(envelope, Models::Brand, "Brand")
+      end
+    end
+  end
+end

data/lib/zelf/resources/comments.rb

@@ -0,0 +1,33 @@
+# Generated by codegen. Do not edit by hand.
+module Zelf
+  module Resources
+    # The comments endpoints.
+    class Comments
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # List Comments. Returns a paginated list of comments, ordered by newest first. At
+      # least one filter is required to scope the query. Filter by `content_id` (a content
+      # `id`) to retrieve the comments on a piece of content, by `id` to retrieve a single
+      # comment, or by `parent_comment_id` to retrieve the replies to a comment. A request
+      # that supplies none of these returns `INVALID_ID`.
+      #
+      # Calls GET /api/v1/comment/ (comments.list).
+      def list(content_id: nil, id: nil, is_parent_comment: nil, order_by: nil, page: nil, page_size: nil, parent_comment_id: nil)
+        query = {
+          "content_id" => content_id,
+          "id" => id,
+          "is_parent_comment" => is_parent_comment,
+          "order_by" => order_by,
+          "page" => page,
+          "page_size" => page_size,
+          "parent_comment_id" => parent_comment_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/comment/", query: query)
+        path = @transport.resolve_path("/api/v1/comment/".dup, {})
+        Zelf::Page.new(envelope, Models::Comment, @transport, path, query)
+      end
+    end
+  end
+end

data/lib/zelf/resources/content.rb

@@ -0,0 +1,256 @@
+# Generated by codegen. Do not edit by hand.
+module Zelf
+  module Resources
+    # The content endpoints.
+    class Content
+      def initialize(transport)
+        @transport = transport
+      end
+
+      # AI Summarize Content. Writes a short AI summary of what the content is about.
+      # Returns `202` with `status: PENDING` when a run starts. Call again to follow it:
+      # `PENDING` while it runs, `COMPLETED` once the content has a summary, `FAILED` if all
+      # 3 tries failed.
+      #
+      # Calls POST /api/v1/content/ai_summarize/ (content.ai_summarize).
+      def ai_summarize(content_id:)
+        body = {
+          "content_id" => content_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:post, "/api/v1/content/ai_summarize/", body: body)
+        Zelf.one(envelope, Models::ContentActionResponse, "ContentActionResponse")
+      end
+
+      # Get Content. Returns a single piece of content identified by `id`. Supply `brand_id`
+      # to additionally require the content to exist under that brand and to populate the
+      # brand-specific fields. If the content does not exist under that brand, the response
+      # is an empty result set rather than a 404. When `brand_id` is omitted, the brand-
+      # specific fields are returned as `null`.
+      #
+      # Calls GET /api/v1/content/{id}/ (content.details).
+      def details(id, brand_id: nil)
+        path_params = { "id" => id }
+        query = {
+          "brand_id" => brand_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/content/{id}/", path_params: path_params, query: query)
+        Zelf.one(envelope, Models::Content, "Content")
+      end
+
+      # Create Content Discovery. Starts an asynchronous job that indexes fresh content
+      # matching a search term across the requested platforms. Use it to ingest content Zelf
+      # does not yet cover. The response describes the job, not the content itself. Once the
+      # job completes, query `content.list` to retrieve the indexed content. An identical
+      # term requested again within the deduplication window reuses the in-flight job and
+      # returns `dispatched: false` instead of starting a new one.
+      #
+      # Calls POST /api/v1/content/discovery/ (content.discover).
+      def discover(search_term:, platforms: nil)
+        body = {
+          "search_term" => search_term,
+          "platforms" => platforms,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:post, "/api/v1/content/discovery/", body: body)
+        Zelf.one(envelope, Models::ContentDiscovery, "ContentDiscovery")
+      end
+
+      # List Content. Returns a paginated list of content. Every request must scope what it
+      # covers: supply at least one of `creator_id`, `creator_username`, `search`,
+      # `brand_id`, or `external_id`, otherwise the request is rejected with
+      # `VALIDATION_ERROR`. By default results are ordered by `posted_at` descending (most
+      # recently posted first); override with `order_by`. Every response echoes the
+      # effective defaults in `applied_filters` (the resolved date window, `page`,
+      # `page_size`, and `brand_id`), so an empty `results` set can be explained. ### Dates
+      # Every request covers a time window. Four parameters define it. | Parameter | Type |
+      # Defines | |---|---|---| | `posted_after` | timestamp | Start of the window | |
+      # `posted_within_hours` | integer, 1 to 8760 | Start of the window, counted back from
+      # the current time | | `posted_within_days` | integer, 1 to 365 | Start of the window,
+      # counted back from the current time | | `posted_before` | timestamp | End of the
+      # window | A request with no date parameter covers the last 7 days. `applied_filters`
+      # reports this as `posted_within_days: 7`. Three parameters define the start of the
+      # window, so a request may carry more than one. Such a request is valid. The API
+      # applies the first parameter present in this order and ignores the rest: 1.
+      # `posted_after` 2. `posted_within_hours` 3. `posted_within_days` `applied_filters`
+      # contains only the parameter that was applied, so it identifies the window that
+      # produced a response. `posted_before` defines the end of the window and combines with
+      # any of the three. On its own it covers the 366 days before it. With
+      # `posted_within_hours` or `posted_within_days` the window is counted back from
+      # `posted_before` instead of from the current time, so
+      # `posted_before=2026-09-01T00:00:00Z` with `posted_within_hours=24` covers
+      # `2026-08-31T00:00:00Z` to `2026-09-01T00:00:00Z`. Two limits apply to every window.
+      # `posted_after` and `posted_before` may be at most 366 days apart, and a longer
+      # period is read as consecutive requests. Content posted before 2025-01-01 is not
+      # available. A value outside the ranges in the table returns `VALIDATION_ERROR`. Such
+      # values are rejected, not clamped: `posted_within_days=400` is an error rather than
+      # 365. Results are paginated: `page` defaults to `1` and `page_size` to `30`, which is
+      # also the maximum (larger values are reduced to `30`). `item_count` is the number of
+      # rows in the returned page, not the size of the whole match set, and `next` is non-
+      # null while further pages remain. For the total number of matching posts, call
+      # `content.statistics` with the same query and read `post_count`. When `brand_id` is
+      # omitted, the brand-specific fields (`brand_id`, `is_owned`, `is_tagged`,
+      # `is_influencer`, `mention_type`, `net_promoter_score`) are returned as `null`, and
+      # the brand-only filters and sorts return `BRAND_ID_REQUIRED`. Supply `brand_id` (one
+      # or more values, comma-separated) to populate those fields and enable the brand-only
+      # filters. Each row's `id` is the value to use for `content.details` and for the
+      # `comments.list` `content_id`.
+      #
+      # Calls GET /api/v1/content/ (content.list).
+      def list(brand_id: nil, comment_count: nil, comment_count_max: nil, comment_count_min: nil, content_form: nil, creator_follower_count: nil, creator_follower_count_max: nil, creator_follower_count_min: nil, creator_id: nil, creator_username: nil, earned_media_value_cents: nil, earned_media_value_cents_max: nil, earned_media_value_cents_min: nil, engagement_rate: nil, engagement_rate_max: nil, engagement_rate_min: nil, external_id: nil, is_influencer: nil, is_owned: nil, is_tagged: nil, language: nil, like_count: nil, like_count_max: nil, like_count_min: nil, media_duration: nil, media_duration_max: nil, media_duration_min: nil, mention_type: nil, mention_type_not: nil, net_promoter_score: nil, net_promoter_score_max: nil, net_promoter_score_min: nil, order_by: nil, page: nil, page_size: nil, platform: nil, posted: nil, posted_after: nil, posted_before: nil, posted_within_days: nil, posted_within_hours: nil, search: nil, share_count: nil, share_count_max: nil, share_count_min: nil, total_engagement: nil, total_engagement_max: nil, total_engagement_min: nil, view_count: nil, view_count_max: nil, view_count_min: nil)
+        query = {
+          "brand_id" => brand_id,
+          "comment_count" => comment_count,
+          "comment_count_max" => comment_count_max,
+          "comment_count_min" => comment_count_min,
+          "content_form" => content_form,
+          "creator_follower_count" => creator_follower_count,
+          "creator_follower_count_max" => creator_follower_count_max,
+          "creator_follower_count_min" => creator_follower_count_min,
+          "creator_id" => creator_id,
+          "creator_username" => creator_username,
+          "earned_media_value_cents" => earned_media_value_cents,
+          "earned_media_value_cents_max" => earned_media_value_cents_max,
+          "earned_media_value_cents_min" => earned_media_value_cents_min,
+          "engagement_rate" => engagement_rate,
+          "engagement_rate_max" => engagement_rate_max,
+          "engagement_rate_min" => engagement_rate_min,
+          "external_id" => external_id,
+          "is_influencer" => is_influencer,
+          "is_owned" => is_owned,
+          "is_tagged" => is_tagged,
+          "language" => language,
+          "like_count" => like_count,
+          "like_count_max" => like_count_max,
+          "like_count_min" => like_count_min,
+          "media_duration" => media_duration,
+          "media_duration_max" => media_duration_max,
+          "media_duration_min" => media_duration_min,
+          "mention_type" => mention_type,
+          "mention_type_not" => mention_type_not,
+          "net_promoter_score" => net_promoter_score,
+          "net_promoter_score_max" => net_promoter_score_max,
+          "net_promoter_score_min" => net_promoter_score_min,
+          "order_by" => order_by,
+          "page" => page,
+          "page_size" => page_size,
+          "platform" => platform,
+          "posted" => posted,
+          "posted_after" => posted_after,
+          "posted_before" => posted_before,
+          "posted_within_days" => posted_within_days,
+          "posted_within_hours" => posted_within_hours,
+          "search" => search,
+          "share_count" => share_count,
+          "share_count_max" => share_count_max,
+          "share_count_min" => share_count_min,
+          "total_engagement" => total_engagement,
+          "total_engagement_max" => total_engagement_max,
+          "total_engagement_min" => total_engagement_min,
+          "view_count" => view_count,
+          "view_count_max" => view_count_max,
+          "view_count_min" => view_count_min,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/content/", query: query)
+        path = @transport.resolve_path("/api/v1/content/".dup, {})
+        Zelf::Page.new(envelope, Models::Content, @transport, path, query)
+      end
+
+      # Get Content Statistics. Returns a single aggregate of reach, engagement, value, and
+      # creator counts over the **same content set*; that `content.list` would return for an
+      # identical query. The `post_count` is the number of posts in that whole set, across
+      # every page the list would return, and each other total is the sum over those same
+      # posts. `content.list` never counts the full set: its `item_count` is only the number
+      # of rows in the page it returned, so `post_count` here is the only total available.
+      # This accepts every filter `content.list` accepts and applies the **same defaults*;
+      # and requirements: every request must scope what it covers with at least one of
+      # `creator_id`, `creator_username`, `search`, `brand_id`, or `external_id` (else
+      # `VALIDATION_ERROR`); brand-only filters and sorts still require `brand_id`.
+      # `order_by` is validated the same as in `content.list` (brand-only sorts still
+      # require `brand_id`) but has no effect on the aggregated totals. Returns a single
+      # totals object (`item_count: 1`), not paginated, and echoes the resolved date window
+      # and `brand_id` in `applied_filters`. ### Dates `content.statistics` takes the same
+      # four date parameters as `content.list` and applies them identically. `posted_after`,
+      # `posted_within_hours` (1 to 8760) and `posted_within_days` (1 to 365) define the
+      # start of the window; `posted_before` defines the end. A request with no date
+      # parameter covers the last 7 days. A request carrying more than one start parameter
+      # is valid, and the first present in the order `posted_after`, `posted_within_hours`,
+      # `posted_within_days` is applied; `applied_filters` reports that one. `posted_after`
+      # and `posted_before` may be at most 366 days apart. Both endpoints apply these
+      # parameters identically, so one set of dates covers the same posts on each.
+      # `post_count` is therefore the size of the set `content.list` pages through. Supply
+      # `brand_id` (one or more values, comma-separated) to scope the totals the same way
+      # the list does. Each piece of content is counted once even when several `brand_id`
+      # values match it.
+      #
+      # Calls GET /api/v1/content/statistics/ (content.statistics).
+      def statistics(brand_id: nil, comment_count: nil, comment_count_max: nil, comment_count_min: nil, content_form: nil, creator_follower_count: nil, creator_follower_count_max: nil, creator_follower_count_min: nil, creator_id: nil, creator_username: nil, earned_media_value_cents: nil, earned_media_value_cents_max: nil, earned_media_value_cents_min: nil, engagement_rate: nil, engagement_rate_max: nil, engagement_rate_min: nil, external_id: nil, is_influencer: nil, is_owned: nil, is_tagged: nil, language: nil, like_count: nil, like_count_max: nil, like_count_min: nil, media_duration: nil, media_duration_max: nil, media_duration_min: nil, mention_type: nil, mention_type_not: nil, net_promoter_score: nil, net_promoter_score_max: nil, net_promoter_score_min: nil, order_by: nil, platform: nil, posted: nil, posted_after: nil, posted_before: nil, posted_within_days: nil, posted_within_hours: nil, search: nil, share_count: nil, share_count_max: nil, share_count_min: nil, total_engagement: nil, total_engagement_max: nil, total_engagement_min: nil, view_count: nil, view_count_max: nil, view_count_min: nil)
+        query = {
+          "brand_id" => brand_id,
+          "comment_count" => comment_count,
+          "comment_count_max" => comment_count_max,
+          "comment_count_min" => comment_count_min,
+          "content_form" => content_form,
+          "creator_follower_count" => creator_follower_count,
+          "creator_follower_count_max" => creator_follower_count_max,
+          "creator_follower_count_min" => creator_follower_count_min,
+          "creator_id" => creator_id,
+          "creator_username" => creator_username,
+          "earned_media_value_cents" => earned_media_value_cents,
+          "earned_media_value_cents_max" => earned_media_value_cents_max,
+          "earned_media_value_cents_min" => earned_media_value_cents_min,
+          "engagement_rate" => engagement_rate,
+          "engagement_rate_max" => engagement_rate_max,
+          "engagement_rate_min" => engagement_rate_min,
+          "external_id" => external_id,
+          "is_influencer" => is_influencer,
+          "is_owned" => is_owned,
+          "is_tagged" => is_tagged,
+          "language" => language,
+          "like_count" => like_count,
+          "like_count_max" => like_count_max,
+          "like_count_min" => like_count_min,
+          "media_duration" => media_duration,
+          "media_duration_max" => media_duration_max,
+          "media_duration_min" => media_duration_min,
+          "mention_type" => mention_type,
+          "mention_type_not" => mention_type_not,
+          "net_promoter_score" => net_promoter_score,
+          "net_promoter_score_max" => net_promoter_score_max,
+          "net_promoter_score_min" => net_promoter_score_min,
+          "order_by" => order_by,
+          "platform" => platform,
+          "posted" => posted,
+          "posted_after" => posted_after,
+          "posted_before" => posted_before,
+          "posted_within_days" => posted_within_days,
+          "posted_within_hours" => posted_within_hours,
+          "search" => search,
+          "share_count" => share_count,
+          "share_count_max" => share_count_max,
+          "share_count_min" => share_count_min,
+          "total_engagement" => total_engagement,
+          "total_engagement_max" => total_engagement_max,
+          "total_engagement_min" => total_engagement_min,
+          "view_count" => view_count,
+          "view_count_max" => view_count_max,
+          "view_count_min" => view_count_min,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:get, "/api/v1/content/statistics/", query: query)
+        Zelf.one(envelope, Models::ContentStatistics, "ContentStatistics")
+      end
+
+      # Transcribe Content. Transcribes the speech in the content's audio or video into
+      # text. Returns `202` with `status: PENDING` when a run starts. Call again to follow
+      # it: `PENDING` while it runs, `COMPLETED` once the content has a transcription,
+      # `FAILED` if all 3 tries failed.
+      #
+      # Calls POST /api/v1/content/transcribe/ (content.transcribe).
+      def transcribe(content_id:)
+        body = {
+          "content_id" => content_id,
+        }.reject { |_, value| value.nil? }
+        envelope = @transport.request(:post, "/api/v1/content/transcribe/", body: body)
+        Zelf.one(envelope, Models::ContentActionResponse, "ContentActionResponse")
+      end
+    end
+  end
+end