amazon-ads 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4e68acc1d736bb5c7f6a59b10163bce7a2622065a291fcebfe3aafd7e028fa2
-  data.tar.gz: 3f33dd9eeae73cfb943bf548efbb842393aea4b42d6b8f87fb79e8faad4f9d49
+  metadata.gz: 01b624dd728e5d50d55c9d199671a1730ce61c260210d0d13c2173241edc297e
+  data.tar.gz: 6a8cc4aa441d12b1c12905fbec987935c82807b2495a520e0d304830c36ceadc
 SHA512:
-  metadata.gz: ef4d4bf550a0c1cbee2ca11b469906d576e35a1db35978e52896572ad202a0905d32087810e1ee750b358ee9409bb073b1f863485847588bfd1f2cfce7f901bf
-  data.tar.gz: 6755c1f89af12711d7dd3970e1ac37e9e3ac1872c944f497030bfa74a84e5cbbd825af087719cf68104e6be019302f7639138c0dcbe6006b2294dcf490448080
+  metadata.gz: 8afd9e71ec2e8006cf99de7f66bc202cbc8589fbe9809a591d42a7948ed032dfad3d7b1d2d9c536548643de93a15824e6fa94724424e2d0c76c5ace11610387e
+  data.tar.gz: 6cca951e838bf718be509b0f0882ef54c4e6ee8d2955d25982f0ab9d6a595e08535b4f3ed63f17b84103fef1a3f813c23d282e6e34f253afbbbe688bbcaab061

data/README.md

@@ -1,39 +1,59 @@
-# Sponsor
+# Amazon Ads
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sponsor`. To experiment with that code, run `bin/console` for an interactive prompt.
+A Ruby client for the [Amazon Ads API](https://advertising.amazon.com/API/docs/en-us).
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add to your Gemfile:
+
+```ruby
+gem "amazon-ads"
+```
 
-Install the gem and add to the application's Gemfile by executing:
+Or install directly:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install amazon-ads
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+## Configuration
 
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+Set your app credentials at the module level or via environment variables:
+
+```ruby
+AmazonAds.client_id = "your_client_id"
+AmazonAds.client_secret = "your_client_secret"
 ```
 
+Or set `AMAZON_ADS_CLIENT_ID` and `AMAZON_ADS_CLIENT_SECRET`.
+
 ## Usage
 
-TODO: Write usage instructions here
+Request an access token via Login with Amazon (LWA):
 
-## Development
+```ruby
+data = AmazonAds::LWA.request(refresh_token: "your_refresh_token")
+access_token = data.fetch("access_token")
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+The caller owns token caching. Store and reuse the token until it expires.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Make requests:
 
-## Contributing
+```ruby
+# List advertising profiles
+profiles = AmazonAds::Profiles.new(region: "NA", access_token:)
+profiles.list_profiles
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sponsor.
+# List campaigns under a profile
+campaigns = AmazonAds::Campaigns.new(
+  region: "NA",
+  access_token:,
+  profile_id: "123456789",
+)
+campaigns.list_campaigns
+```
 
-## License
+## Development
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+See [AGENTS.md](AGENTS.md).

data/lib/amazon_ads/api.rb

@@ -1,50 +1,70 @@
 # frozen_string_literal: true
 
-# rbs_inline: enabled
-
 require "http"
 
 module AmazonAds
-  # Base class for Amazon Ads API clients.
-  # Handles authentication, response parsing, error mapping, and retry logic.
+  # Base class for Amazon Ads API endpoints
   class API
     ENDPOINTS = { #: Hash[Symbol, String]
-      na: "https://advertising-api.amazon.com",
-      eu: "https://advertising-api-eu.amazon.com",
-      fe: "https://advertising-api-fe.amazon.com",
+      na: "advertising-api.amazon.com",
+      eu: "advertising-api-eu.amazon.com",
+      fe: "advertising-api-fe.amazon.com",
     }.freeze
 
-    MAX_RETRIES = 3 #: Integer
-    BASE_RETRY_DELAY = 1 #: Integer
-
+    # API endpoint region
     attr_reader :region #: Symbol
+
+    # LWA access token
+    attr_reader :access_token #: String
+
+    # Advertiser profile, scopes requests to a marketplace
     attr_reader :profile_id #: String?
 
-    #: (region: Symbol, ?access_token: String?, ?lwa: LWA?, ?profile_id: String?) -> void
-    def initialize(region:, access_token: nil, lwa: nil, profile_id: nil)
-      @region = region
+    # Advertiser account
+    attr_reader :account_id #: String?
+
+    # Number of retries when throttled (default: 0)
+    attr_reader :retries #: Integer
+
+    #: (region: Symbol | String, access_token: String, ?profile_id: String?, ?account_id: String?, ?retries: Integer, ?http: untyped) -> void
+    def initialize(region:, access_token:, profile_id: nil, account_id: nil, retries: 0, http: HTTP)
+      @region = region.to_s.downcase.to_sym
       @access_token = access_token
-      @lwa = lwa
       @profile_id = profile_id
-
-      unless @access_token || @lwa
-        raise ArgumentError, "Either access_token or lwa must be provided"
-      end
+      @account_id = account_id
+      @retries = retries
+      @http = http
     end
 
-    private
-
-    # Returns the current access token, refreshing via LWA if needed.
-    #: () -> String
-    def access_token
-      @lwa ? @lwa.access_token : @access_token or raise AmazonAds::AuthenticationError, "No access token"
+    #: () -> URI::HTTPS
+    def endpoint
+      URI::HTTPS.build(host: ENDPOINTS.fetch(region) do
+        raise ArgumentError, "Unknown region: #{region}"
+      end)
     end
 
     #: () -> HTTP::Client
     def http
-      HTTP
+      client = @http
         .headers(default_headers)
         .use(:auto_inflate)
+
+      if retries.zero?
+        client.use(:raise_error)
+      else
+        client
+          .use(raise_error: { ignore: [429] })
+          .retriable(tries: retries + 1, retry_statuses: [429])
+      end
+    end
+
+    private
+
+    #: (HTTP::verb, String, **untyped) -> HTTP::Response
+    def request(method, path, **options)
+      url = endpoint
+      url.path = path
+      http.request(method, url.to_s, **options)
     end
 
     #: () -> Hash[String, String]
@@ -55,87 +75,19 @@ module AmazonAds
         "Content-Type" => "application/json",
         "Accept" => "application/json",
       }
-      headers["Amazon-Advertising-API-Scope"] = profile_id if profile_id
+      if (scope = profile_id)
+        headers["Amazon-Advertising-API-Scope"] = scope
+      end
+      if (account = account_id)
+        headers["Amazon-Ads-AccountId"] = account
+      end
 
       headers
     end
 
     #: () -> String
     def client_id
-      ENV.fetch("AMAZON_ADS_CLIENT_ID")
-    end
-
-    #: () -> String
-    def endpoint
-      ENDPOINTS.fetch(region) do
-        raise ArgumentError, "Unknown region: #{region}"
-      end
-    end
-
-    # Handles HTTP response, raising appropriate errors or parsing success responses.
-    #: (HTTP::Response) -> untyped
-    def handle_response(response)
-      case response.status.code
-      when 200..299
-        return if response.body.to_s.empty?
-
-        response.parse
-      when 400
-        raise AmazonAds::BadRequestError.new("Bad request", response: response)
-      when 401
-        raise AmazonAds::AuthenticationError.new("Unauthorized", response: response)
-      when 404
-        raise AmazonAds::NotFoundError.new("Not found", response: response)
-      when 429
-        retry_after = response.headers["Retry-After"]&.to_i
-        raise AmazonAds::RateLimitError.new("Rate limited", response: response, retry_after: retry_after)
-      when 500..599
-        raise AmazonAds::ServerError.new("Server error", response: response)
-      else
-        raise AmazonAds::Error.new("Request failed with status #{response.status.code}", response: response)
-      end
-    end
-
-    # Executes request with retry logic for rate limiting.
-    #: () { () -> HTTP::Response } -> untyped
-    def with_retry(&block)
-      retries = 0
-
-      loop do
-        response = yield
-        return handle_response(response)
-      rescue AmazonAds::RateLimitError => e
-        retries += 1
-        raise if retries > MAX_RETRIES
-
-        delay = e.retry_after || (BASE_RETRY_DELAY * (2**(retries - 1)))
-        sleep(delay)
-      end
-    end
-
-    #: (String, ?params: Hash[String, untyped]) -> untyped
-    def get(path, params: {})
-      with_retry { http.get("#{endpoint}#{path}", params: params) }
-    end
-
-    #: (String, ?body: Hash[String, untyped]) -> untyped
-    def post(path, body: {})
-      with_retry { http.post("#{endpoint}#{path}", json: body) }
-    end
-
-    #: (String, ?body: Hash[String, untyped]) -> untyped
-    def put(path, body: {})
-      with_retry { http.put("#{endpoint}#{path}", json: body) }
-    end
-
-    #: (String, ?body: Hash[String, untyped]) -> untyped
-    def patch(path, body: {})
-      with_retry { http.patch("#{endpoint}#{path}", json: body) }
-    end
-
-    #: (String) -> untyped
-    def delete(path)
-      with_retry { http.delete("#{endpoint}#{path}") }
+      AmazonAds.client_id!
     end
   end
 end

data/lib/amazon_ads/apis/ad_associations.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class AdAssociations < API
+    # Create Ad Association
+    #: (?ad_associations: Array[untyped]?) -> HTTP::Response
+    def create_ad_association(ad_associations: nil)
+      request(:post, "/adsApi/v1/create/adAssociations", json: { "adAssociations" => ad_associations }.compact)
+    end
+
+    # Delete Ad Association
+    #: (?ad_association_ids: Array[untyped]?) -> HTTP::Response
+    def delete_ad_association(ad_association_ids: nil)
+      request(:post, "/adsApi/v1/delete/adAssociations", json: { "adAssociationIds" => ad_association_ids }.compact)
+    end
+
+    # Query Ad Association
+    #: (?ad_association_id_filter: untyped?, ?ad_group_id_filter: untyped?, ?ad_id_filter: untyped?, ?max_results: Integer?, ?next_token: String?) -> HTTP::Response
+    def query_ad_association(ad_association_id_filter: nil, ad_group_id_filter: nil, ad_id_filter: nil, max_results: nil, next_token: nil)
+      request(:post, "/adsApi/v1/query/adAssociations", json: { "adAssociationIdFilter" => ad_association_id_filter, "adGroupIdFilter" => ad_group_id_filter, "adIdFilter" => ad_id_filter, "maxResults" => max_results, "nextToken" => next_token }.compact)
+    end
+
+    # Update Ad Association
+    #: (?ad_associations: Array[untyped]?) -> HTTP::Response
+    def update_ad_association(ad_associations: nil)
+      request(:post, "/adsApi/v1/update/adAssociations", json: { "adAssociations" => ad_associations }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/ad_extensions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class AdExtensions < API
+    # Create ad extensions - API is in open beta
+    #: (?ad_extensions: Array[untyped]?) -> HTTP::Response
+    def create_ad_extension(ad_extensions: nil)
+      request(:post, "/adsApi/v1/create/adExtensions", json: { "adExtensions" => ad_extensions }.compact)
+    end
+
+    # Query ad_extension - API is in open beta
+    #: (?ad_extension_id_filter: untyped?, ?ad_extension_status_filter: untyped?, ?ad_extension_type_filter: untyped?, ?ad_group_id_filter: untyped?, ?ad_id_filter: untyped?, ?ad_product_filter: untyped?, ?max_results: Integer?, ?next_token: String?, ?state_filter: untyped?) -> HTTP::Response
+    def query_ad_extension(ad_extension_id_filter: nil, ad_extension_status_filter: nil, ad_extension_type_filter: nil, ad_group_id_filter: nil, ad_id_filter: nil, ad_product_filter: nil, max_results: nil, next_token: nil, state_filter: nil)
+      request(:post, "/adsApi/v1/query/adExtensions", json: { "adExtensionIdFilter" => ad_extension_id_filter, "adExtensionStatusFilter" => ad_extension_status_filter, "adExtensionTypeFilter" => ad_extension_type_filter, "adGroupIdFilter" => ad_group_id_filter, "adIdFilter" => ad_id_filter, "adProductFilter" => ad_product_filter, "maxResults" => max_results, "nextToken" => next_token, "stateFilter" => state_filter }.compact)
+    end
+
+    # Update ad_extension - API is in open beta
+    #: (?ad_extensions: Array[untyped]?) -> HTTP::Response
+    def update_ad_extension(ad_extensions: nil)
+      request(:post, "/adsApi/v1/update/adExtensions", json: { "adExtensions" => ad_extensions }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/ad_groups.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class AdGroups < API
+    # Create ad groups
+    #: (?ad_groups: Array[untyped]?) -> HTTP::Response
+    def create_ad_group(ad_groups: nil)
+      request(:post, "/adsApi/v1/create/adGroups", json: { "adGroups" => ad_groups }.compact)
+    end
+
+    # Delete ad groups
+    #: (?ad_group_ids: Array[untyped]?) -> HTTP::Response
+    def delete_ad_group(ad_group_ids: nil)
+      request(:post, "/adsApi/v1/delete/adGroups", json: { "adGroupIds" => ad_group_ids }.compact)
+    end
+
+    # List ad groups
+    #: (ad_product_filter: untyped, ?ad_group_id_filter: untyped?, ?campaign_id_filter: untyped?, ?marketplace_scope_filter: untyped?, ?max_results: Integer?, ?name_filter: untyped?, ?next_token: String?, ?state_filter: untyped?) -> HTTP::Response
+    def query_ad_group(ad_product_filter:, ad_group_id_filter: nil, campaign_id_filter: nil, marketplace_scope_filter: nil, max_results: nil, name_filter: nil, next_token: nil, state_filter: nil)
+      request(:post, "/adsApi/v1/query/adGroups", json: { "adGroupIdFilter" => ad_group_id_filter, "adProductFilter" => ad_product_filter, "campaignIdFilter" => campaign_id_filter, "marketplaceScopeFilter" => marketplace_scope_filter, "maxResults" => max_results, "nameFilter" => name_filter, "nextToken" => next_token, "stateFilter" => state_filter }.compact)
+    end
+
+    # Update ad groups
+    #: (?ad_groups: Array[untyped]?) -> HTTP::Response
+    def update_ad_group(ad_groups: nil)
+      request(:post, "/adsApi/v1/update/adGroups", json: { "adGroups" => ad_groups }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/ads.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class Ads < API
+    # Create ads
+    #: (?ads: Array[untyped]?) -> HTTP::Response
+    def create_ad(ads: nil)
+      request(:post, "/adsApi/v1/create/ads", json: { "ads" => ads }.compact)
+    end
+
+    # Delete ads
+    #: (?ad_ids: Array[untyped]?) -> HTTP::Response
+    def delete_ad(ad_ids: nil)
+      request(:post, "/adsApi/v1/delete/ads", json: { "adIds" => ad_ids }.compact)
+    end
+
+    # List ads
+    #: (ad_product_filter: untyped, ?ad_group_id_filter: untyped?, ?ad_id_filter: untyped?, ?campaign_id_filter: untyped?, ?marketplace_scope_filter: untyped?, ?max_results: Integer?, ?name_filter: untyped?, ?next_token: String?, ?state_filter: untyped?) -> HTTP::Response
+    def query_ad(ad_product_filter:, ad_group_id_filter: nil, ad_id_filter: nil, campaign_id_filter: nil, marketplace_scope_filter: nil, max_results: nil, name_filter: nil, next_token: nil, state_filter: nil)
+      request(:post, "/adsApi/v1/query/ads", json: { "adGroupIdFilter" => ad_group_id_filter, "adIdFilter" => ad_id_filter, "adProductFilter" => ad_product_filter, "campaignIdFilter" => campaign_id_filter, "marketplaceScopeFilter" => marketplace_scope_filter, "maxResults" => max_results, "nameFilter" => name_filter, "nextToken" => next_token, "stateFilter" => state_filter }.compact)
+    end
+
+    # Update ads
+    #: (?ads: Array[untyped]?) -> HTTP::Response
+    def update_ad(ads: nil)
+      request(:post, "/adsApi/v1/update/ads", json: { "ads" => ads }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/advertising_deal_targets.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class AdvertisingDealTargets < API
+    # Create advertisingDealTarget
+    #: (?advertising_deal_targets: Array[untyped]?) -> HTTP::Response
+    def sb_create_advertising_deal_target(advertising_deal_targets: nil)
+      request(:post, "/adsApi/v1/create/advertisingDealTargets/sb", json: { "advertisingDealTargets" => advertising_deal_targets }.compact)
+    end
+
+    # Delete advertisingDealTarget
+    #: (?advertising_deal_target_ids: Array[untyped]?) -> HTTP::Response
+    def sb_delete_advertising_deal_target(advertising_deal_target_ids: nil)
+      request(:post, "/adsApi/v1/delete/advertisingDealTargets/sb", json: { "advertisingDealTargetIds" => advertising_deal_target_ids }.compact)
+    end
+
+    # Query advertisingDealTarget
+    #: (advertising_deal_id_filter: untyped, ?max_results: Integer?, ?next_token: String?) -> HTTP::Response
+    def sb_query_advertising_deal_target(advertising_deal_id_filter:, max_results: nil, next_token: nil)
+      request(:post, "/adsApi/v1/query/advertisingDealTargets/sb", json: { "advertisingDealIdFilter" => advertising_deal_id_filter, "maxResults" => max_results, "nextToken" => next_token }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/advertising_deals.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class AdvertisingDeals < API
+    # Create advertisingDeal
+    #: (?advertising_deals: Array[untyped]?) -> HTTP::Response
+    def sb_create_advertising_deal(advertising_deals: nil)
+      request(:post, "/adsApi/v1/create/advertisingDeals/sb", json: { "advertisingDeals" => advertising_deals }.compact)
+    end
+
+    # Delete advertisingDeal
+    #: (?advertising_deal_ids: Array[untyped]?) -> HTTP::Response
+    def sb_delete_advertising_deal(advertising_deal_ids: nil)
+      request(:post, "/adsApi/v1/delete/advertisingDeals/sb", json: { "advertisingDealIds" => advertising_deal_ids }.compact)
+    end
+
+    # Query advertisingDeal
+    #: (?advertising_deal_id_filter: untyped?, ?max_results: Integer?, ?name_filter: untyped?, ?next_token: String?) -> HTTP::Response
+    def sb_query_advertising_deal(advertising_deal_id_filter: nil, max_results: nil, name_filter: nil, next_token: nil)
+      request(:post, "/adsApi/v1/query/advertisingDeals/sb", json: { "advertisingDealIdFilter" => advertising_deal_id_filter, "maxResults" => max_results, "nameFilter" => name_filter, "nextToken" => next_token }.compact)
+    end
+
+    # Update advertisingDeal
+    #: (?advertising_deals: Array[untyped]?) -> HTTP::Response
+    def sb_update_advertising_deal(advertising_deals: nil)
+      request(:post, "/adsApi/v1/update/advertisingDeals/sb", json: { "advertisingDeals" => advertising_deals }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/brand_store_edition_publish_versions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class BrandStoreEditionPublishVersions < API
+    # Query store edition publish versions
+    #: (edition_id_filter: untyped, publish_status_filter: untyped, store_id_filter: untyped, ?max_results: Integer?, ?next_token: String?) -> HTTP::Response
+    def query_brand_store_edition_publish_version(edition_id_filter:, publish_status_filter:, store_id_filter:, max_results: nil, next_token: nil)
+      request(:post, "/adsApi/v1/query/brandStoreEditionPublishVersions", json: { "editionIdFilter" => edition_id_filter, "maxResults" => max_results, "nextToken" => next_token, "publishStatusFilter" => publish_status_filter, "storeIdFilter" => store_id_filter }.compact)
+    end
+
+    # Update store edition publish versions
+    #: (?brand_store_edition_publish_versions: Array[untyped]?) -> HTTP::Response
+    def update_brand_store_edition_publish_version(brand_store_edition_publish_versions: nil)
+      request(:post, "/adsApi/v1/update/brandStoreEditionPublishVersions", json: { "brandStoreEditionPublishVersions" => brand_store_edition_publish_versions }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/brand_store_editions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class BrandStoreEditions < API
+    # Retrieve brand store page content
+    #: (brand_store_id: String, ?next_token: String?, ?max_results: Integer?) -> HTTP::Response
+    def list_brand_store_edition(brand_store_id:, next_token: nil, max_results: nil)
+      request(:get, "/adsApi/v1/brandStoreEditions", params: { "brandStoreId" => brand_store_id, "nextToken" => next_token, "maxResults" => max_results }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/brand_store_pages.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class BrandStorePages < API
+    # Retrieve brand store page content
+    #: (edition_id_filter: untyped, page_id_filter: untyped, store_id_filter: untyped, ?max_results: Integer?, ?next_token: String?, ?store_edition_publish_id_filter: untyped?) -> HTTP::Response
+    def query_brand_store_page(edition_id_filter:, page_id_filter:, store_id_filter:, max_results: nil, next_token: nil, store_edition_publish_id_filter: nil)
+      request(:post, "/adsApi/v1/query/brandStorePages", json: { "editionIdFilter" => edition_id_filter, "maxResults" => max_results, "nextToken" => next_token, "pageIdFilter" => page_id_filter, "storeEditionPublishIdFilter" => store_edition_publish_id_filter, "storeIdFilter" => store_id_filter }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/brand_stores.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class BrandStores < API
+    # Query brand store content
+    #: (store_name_filter: untyped, ?max_results: Integer?, ?next_token: String?, ?sort: Array[untyped]?) -> HTTP::Response
+    def query_brand_store(store_name_filter:, max_results: nil, next_token: nil, sort: nil)
+      request(:post, "/adsApi/v1/query/brandStores", json: { "maxResults" => max_results, "nextToken" => next_token, "sort" => sort, "storeNameFilter" => store_name_filter }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/branded_keywords_pricings.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class BrandedKeywordsPricings < API
+    # Create brandedKeywords pricing
+    #: (?branded_keywords_pricings: Array[untyped]?) -> HTTP::Response
+    def sb_create_branded_keywords_pricing(branded_keywords_pricings: nil)
+      request(:post, "/adsApi/v1/create/brandedKeywordsPricings/sb", json: { "brandedKeywordsPricings" => branded_keywords_pricings }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/campaign_forecasts.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class CampaignForecasts < API
+    # Retrieve campaign forecast
+    #: (?campaign_forecast_descriptions: Array[untyped]?) -> HTTP::Response
+    def dsp_retrieve_campaign_forecast(campaign_forecast_descriptions: nil)
+      request(:post, "/adsApi/v1/retrieve/campaignForecasts/dsp", json: { "campaignForecastDescriptions" => campaign_forecast_descriptions }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/campaigns.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class Campaigns < API
+    # Create campaigns
+    #: (?campaigns: Array[untyped]?) -> HTTP::Response
+    def create_campaign(campaigns: nil)
+      request(:post, "/adsApi/v1/create/campaigns", json: { "campaigns" => campaigns }.compact)
+    end
+
+    # Delete campaigns
+    #: (?campaign_ids: Array[untyped]?) -> HTTP::Response
+    def delete_campaign(campaign_ids: nil)
+      request(:post, "/adsApi/v1/delete/campaigns", json: { "campaignIds" => campaign_ids }.compact)
+    end
+
+    # Query campaign
+    #: (ad_product_filter: untyped, ?campaign_id_filter: untyped?, ?goal_filter: untyped?, ?marketplace_scope_filter: untyped?, ?max_results: Integer?, ?name_filter: untyped?, ?next_token: String?, ?portfolio_id_filter: untyped?, ?state_filter: untyped?) -> HTTP::Response
+    def query_campaign(ad_product_filter:, campaign_id_filter: nil, goal_filter: nil, marketplace_scope_filter: nil, max_results: nil, name_filter: nil, next_token: nil, portfolio_id_filter: nil, state_filter: nil)
+      request(:post, "/adsApi/v1/query/campaigns", json: { "adProductFilter" => ad_product_filter, "campaignIdFilter" => campaign_id_filter, "goalFilter" => goal_filter, "marketplaceScopeFilter" => marketplace_scope_filter, "maxResults" => max_results, "nameFilter" => name_filter, "nextToken" => next_token, "portfolioIdFilter" => portfolio_id_filter, "stateFilter" => state_filter }.compact)
+    end
+
+    # Update campaign
+    #: (?campaigns: Array[untyped]?) -> HTTP::Response
+    def update_campaign(campaigns: nil)
+      request(:post, "/adsApi/v1/update/campaigns", json: { "campaigns" => campaigns }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/commitment_spends.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class CommitmentSpends < API
+    # Retrieve commitment spend
+    #: (?commitment_ids: Array[untyped]?) -> HTTP::Response
+    def dsp_retrieve_commitment_spend(commitment_ids: nil)
+      request(:post, "/adsApi/v1/retrieve/commitmentSpends/dsp", json: { "commitmentIds" => commitment_ids }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/commitments.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class Commitments < API
+    # Create commitments
+    #: (?commitments: Array[untyped]?) -> HTTP::Response
+    def dsp_create_commitment(commitments: nil)
+      request(:post, "/adsApi/v1/create/commitments/dsp", json: { "commitments" => commitments }.compact)
+    end
+
+    # List commitments
+    #: (?next_token: String?, ?max_results: Integer?) -> HTTP::Response
+    def dsp_list_commitment(next_token: nil, max_results: nil)
+      request(:get, "/adsApi/v1/commitments/dsp", params: { "nextToken" => next_token, "maxResults" => max_results }.compact)
+    end
+
+    # Get Commitments
+    #: (?commitment_ids: Array[untyped]?) -> HTTP::Response
+    def dsp_retrieve_commitment(commitment_ids: nil)
+      request(:post, "/adsApi/v1/retrieve/commitments/dsp", json: { "commitmentIds" => commitment_ids }.compact)
+    end
+
+    # Update commitments
+    #: (?commitments: Array[untyped]?) -> HTTP::Response
+    def dsp_update_commitment(commitments: nil)
+      request(:post, "/adsApi/v1/update/commitments/dsp", json: { "commitments" => commitments }.compact)
+    end
+  end
+end

data/lib/amazon_ads/apis/keyword_reservation_validations.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AmazonAds
+  class KeywordReservationValidations < API
+    # Validate keyword reservation
+    #: (?keyword_reservation_validations: Array[untyped]?) -> HTTP::Response
+    def sb_create_keyword_reservation_validation(keyword_reservation_validations: nil)
+      request(:post, "/adsApi/v1/create/keywordReservationValidations/sb", json: { "keywordReservationValidations" => keyword_reservation_validations }.compact)
+    end
+  end
+end