ebay-mcp-remote-edition 1.0.0

package/build/api/marketing-and-promotions/marketing.js

@@ -0,0 +1,768 @@
+/**
+ * Marketing API - Marketing campaigns and promotions
+ * Based on: docs/sell-apps/marketing-and-promotions/sell_marketing_v1_oas3.json
+ */
+export class MarketingApi {
+    client;
+    basePath = '/sell/marketing/v1';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get campaigns
+     */
+    async getCampaigns(campaignStatus, marketplaceId, limit) {
+        const params = {};
+        if (campaignStatus)
+            params.campaign_status = campaignStatus;
+        if (marketplaceId)
+            params.marketplace_id = marketplaceId;
+        if (limit)
+            params.limit = limit;
+        return await this.client.get(`${this.basePath}/ad_campaign`, params);
+    }
+    /**
+     * Get a specific campaign
+     */
+    async getCampaign(campaignId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}`);
+    }
+    /**
+     * Create a campaign
+     */
+    async createCampaign(campaign) {
+        return await this.client.post(`${this.basePath}/ad_campaign`, campaign);
+    }
+    /**
+     * Get promotions
+     */
+    async getPromotions(marketplaceId, limit) {
+        const params = {};
+        if (marketplaceId)
+            params.marketplace_id = marketplaceId;
+        if (limit)
+            params.limit = limit;
+        return await this.client.get(`${this.basePath}/promotion`, params);
+    }
+    /**
+     * Create a promotion (item promotion)
+     */
+    async createPromotion(promotion) {
+        return await this.client.post(`${this.basePath}/item_promotion`, promotion);
+    }
+    /**
+     * Get ads for a campaign
+     */
+    async getAds(campaignId, adGroupIds, adStatus, limit, listingIds, offset) {
+        const params = {};
+        if (adGroupIds)
+            params.ad_group_ids = adGroupIds;
+        if (adStatus)
+            params.ad_status = adStatus;
+        if (limit)
+            params.limit = limit;
+        if (listingIds)
+            params.listing_ids = listingIds;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad`, params);
+    }
+    /**
+     * Create an ad for a campaign
+     */
+    async createAd(campaignId, ad) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad`, ad);
+    }
+    /**
+     * Create ads by inventory reference for a campaign
+     */
+    async createAdsByInventoryReference(campaignId, ads) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/create_ads_by_inventory_reference`, ads);
+    }
+    /**
+     * Get a specific ad for a campaign
+     */
+    async getAd(campaignId, adId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}`);
+    }
+    /**
+     * Delete a specific ad from a campaign
+     */
+    async deleteAd(campaignId, adId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}`);
+    }
+    /**
+     * Clone an ad for a campaign
+     */
+    async cloneAd(campaignId, adId, ad) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}/clone`, ad);
+    }
+    /**
+     * Get ads by inventory reference for a campaign
+     */
+    async getAdsByInventoryReference(campaignId, inventoryReferenceId, inventoryReferenceType) {
+        const params = {
+            inventory_reference_id: inventoryReferenceId,
+            inventory_reference_type: inventoryReferenceType,
+        };
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/get_ads_by_inventory_reference`, params);
+    }
+    /**
+     * Get ads by listing ID for a campaign
+     */
+    async getAdsByListingId(campaignId, listingId) {
+        const params = {
+            listing_id: listingId,
+        };
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/get_ads_by_listing_id`, params);
+    }
+    /**
+     * Update the bid for an ad in a campaign
+     */
+    async updateBid(campaignId, adId, bid) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}/update_bid`, bid);
+    }
+    /**
+     * Clone a campaign
+     */
+    async cloneCampaign(campaignId, campaign) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/clone`, campaign);
+    }
+    /**
+     * End a campaign
+     */
+    async endCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/end`, {});
+    }
+    /**
+     * Get campaign by name
+     */
+    async getCampaignByName(campaignName) {
+        const params = {
+            campaign_name: campaignName,
+        };
+        return await this.client.get(`${this.basePath}/ad_campaign/get_campaign_by_name`, params);
+    }
+    /**
+     * Bulk create ads by inventory reference
+     */
+    async bulkCreateAdsByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_ads_by_inventory_reference`, body);
+    }
+    /**
+     * Bulk create ads by listing id
+     */
+    async bulkCreateAdsByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_ads_by_listing_id`, body);
+    }
+    async bulkDeleteAdsByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_delete_ads_by_inventory_reference`, body);
+    }
+    async deleteAdsByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/delete_ads_by_inventory_reference`, body);
+    }
+    async bulkDeleteAdsByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_delete_ads_by_listing_id`, body);
+    }
+    /**
+     * Bulk update ads bid by inventory reference
+     */
+    async bulkUpdateAdsBidByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_bid_by_inventory_reference`, body);
+    }
+    /**
+     * Bulk update ads bid by listing id
+     */
+    async bulkUpdateAdsBidByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_bid_by_listing_id`, body);
+    }
+    /**
+     * Bulk update ads status
+     */
+    async bulkUpdateAdsStatus(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_status`, body);
+    }
+    /**
+     * Bulk update ads status by listing id
+     */
+    async bulkUpdateAdsStatusByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_status_by_listing_id`, body);
+    }
+    /**
+     * Pause a campaign
+     */
+    async pauseCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/pause`, {});
+    }
+    /**
+     * Resume a campaign
+     */
+    async resumeCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/resume`, {});
+    }
+    /**
+     * Update campaign identification
+     */
+    async updateCampaignIdentification(campaignId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/update_campaign_identification`, body);
+    }
+    /**
+     * Create an ad group
+     */
+    async createAdGroup(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group`, body);
+    }
+    /**
+     * Clone an ad group
+     */
+    async cloneAdGroup(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/clone`, body);
+    }
+    /**
+     * Get ad groups
+     */
+    async getAdGroups(campaignId, adGroupStatus, limit, offset) {
+        const params = {};
+        if (adGroupStatus)
+            params.ad_group_status = adGroupStatus;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group`, params);
+    }
+    /**
+     * Get an ad group
+     */
+    async getAdGroup(campaignId, adGroupId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}`);
+    }
+    /**
+     * Suggest bids for an ad group
+     */
+    async suggestBids(campaignId, adGroupId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/suggest_bids`, {});
+    }
+    /**
+     * Update ad group bids
+     */
+    async updateAdGroupBids(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/update_ad_group_bids`, body);
+    }
+    /**
+     * Update ad group keywords
+     */
+    async updateAdGroupKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/update_ad_group_keywords`, body);
+    }
+    /**
+     * Suggest keywords
+     */
+    async suggestKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/suggest_keywords`, body);
+    }
+    /**
+     * Get keywords
+     */
+    async getKeywords(campaignId, adGroupId, keywordStatus, limit, offset) {
+        const params = {};
+        if (keywordStatus)
+            params.keyword_status = keywordStatus;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword`, params);
+    }
+    /**
+     * Bulk create keywords
+     */
+    async bulkCreateKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/bulk_create_keywords`, body);
+    }
+    /**
+     * Bulk delete keywords
+     */
+    async bulkDeleteKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/bulk_delete_keywords`, body);
+    }
+    /**
+     * Bulk update keyword bids
+     */
+    async bulkUpdateKeywordBids(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/bulk_update_keyword_bids`, body);
+    }
+    /**
+     * Create a keyword
+     */
+    async createKeyword(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/create_keyword`, body);
+    }
+    /**
+     * Get a keyword
+     */
+    async getKeyword(campaignId, adGroupId, keywordId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword/${keywordId}`);
+    }
+    /**
+     * Delete a keyword
+     */
+    async deleteKeyword(campaignId, adGroupId, keywordId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword/${keywordId}`);
+    }
+    /**
+     * Update a keyword's bid
+     */
+    async updateKeywordBid(campaignId, adGroupId, keywordId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword/${keywordId}/update_bid`, body);
+    }
+    /**
+     * Get ad report
+     */
+    async getAdReport(dimension, metric, startDate, endDate, sort, listingIds, marketplaceId) {
+        const params = {
+            dimension,
+            metric,
+            start_date: startDate,
+            end_date: endDate,
+        };
+        if (sort)
+            params.sort = sort;
+        if (listingIds)
+            params.listing_ids = listingIds;
+        if (marketplaceId)
+            params.marketplace_id = marketplaceId;
+        return await this.client.get(`${this.basePath}/ad_report`, params);
+    }
+    /**
+     * Get ad report metadata
+     */
+    async getAdReportMetadata() {
+        return await this.client.get(`${this.basePath}/ad_report_metadata`);
+    }
+    /**
+     * Get ad report metadata for a report type
+     */
+    async getAdReportMetadataForReportType(reportType) {
+        return await this.client.get(`${this.basePath}/ad_report_metadata/${reportType}`);
+    }
+    /**
+     * Create a report task
+     */
+    async createReportTask(body) {
+        return await this.client.post(`${this.basePath}/ad_report_task`, body);
+    }
+    /**
+     * Get report tasks
+     */
+    async getReportTasks(reportTaskStatuses, limit, offset) {
+        const params = {};
+        if (reportTaskStatuses)
+            params.report_task_statuses = reportTaskStatuses;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_report_task`, params);
+    }
+    /**
+     * Get a report task
+     */
+    async getReportTask(reportTaskId) {
+        return await this.client.get(`${this.basePath}/ad_report_task/${reportTaskId}`);
+    }
+    /**
+     * Get an item promotion
+     */
+    async getItemPromotion(promotionId) {
+        return await this.client.get(`${this.basePath}/item_promotion/${promotionId}`);
+    }
+    /**
+     * Delete an item promotion
+     */
+    async deleteItemPromotion(promotionId) {
+        return await this.client.delete(`${this.basePath}/item_promotion/${promotionId}`);
+    }
+    /**
+     * Pause an item promotion
+     */
+    async pauseItemPromotion(promotionId) {
+        return await this.client.post(`${this.basePath}/item_promotion/${promotionId}/pause`, {});
+    }
+    /**
+     * Resume an item promotion
+     */
+    async resumeItemPromotion(promotionId) {
+        return await this.client.post(`${this.basePath}/item_promotion/${promotionId}/resume`, {});
+    }
+    /**
+     * Update an item promotion
+     */
+    async updateItemPromotion(promotionId, body) {
+        return await this.client.put(`${this.basePath}/item_promotion/${promotionId}`, body);
+    }
+    /**
+     * Get a promotion report
+     */
+    async getPromotionReport(marketplaceId, promotionStatus, limit, offset) {
+        const params = {
+            marketplace_id: marketplaceId,
+        };
+        if (promotionStatus)
+            params.promotion_status = promotionStatus;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/promotion_report`, params);
+    }
+    /**
+     * Get a promotion summary report
+     */
+    async getPromotionSummaryReport(marketplaceId) {
+        const params = { marketplace_id: marketplaceId };
+        return await this.client.get(`${this.basePath}/promotion_summary_report`, params);
+    }
+    /**
+     * Get promotion summary (alias for getPromotionSummaryReport)
+     */
+    async getPromotionSummary(marketplaceId) {
+        return await this.getPromotionSummaryReport(marketplaceId);
+    }
+    /**
+     * Get promotion reports (alias for getPromotionReport)
+     */
+    async getPromotionReports(marketplaceId, promotionStatus, limit, offset) {
+        return await this.getPromotionReport(marketplaceId, promotionStatus, limit, offset);
+    }
+    /**
+     * Get targeting for a campaign
+     */
+    async getTargeting(campaignId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/targeting`);
+    }
+    /**
+     * Create targeting for a campaign
+     */
+    async createTargeting(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/targeting`, body);
+    }
+    /**
+     * Update targeting for a campaign
+     */
+    async updateTargeting(campaignId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/targeting`, body);
+    }
+    /**
+     * Get negative keywords for a campaign
+     */
+    async getNegativeKeywords(campaignId, limit, offset) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword`, params);
+    }
+    /**
+     * Create a negative keyword for a campaign
+     */
+    async createNegativeKeyword(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword`, body);
+    }
+    /**
+     * Bulk create negative keywords for a campaign
+     */
+    async bulkCreateNegativeKeywords(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_negative_keywords`, body);
+    }
+    /**
+     * Bulk delete negative keywords for a campaign
+     */
+    async bulkDeleteNegativeKeywords(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_delete_negative_keywords`, body);
+    }
+    /**
+     * Bulk update negative keywords for a campaign
+     */
+    async bulkUpdateNegativeKeywords(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_negative_keywords`, body);
+    }
+    /**
+     * Get a negative keyword for a campaign
+     */
+    async getNegativeKeyword(campaignId, negativeKeywordId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Delete a negative keyword for a campaign
+     */
+    async deleteNegativeKeyword(campaignId, negativeKeywordId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Update a negative keyword for a campaign
+     */
+    async updateNegativeKeyword(campaignId, negativeKeywordId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword/${negativeKeywordId}`, body);
+    }
+    /**
+     * Get negative keywords for an ad group
+     */
+    async getNegativeKeywordsForAdGroup(adGroupId, limit, offset) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_group/${adGroupId}/negative_keyword`, params);
+    }
+    /**
+     * Create a negative keyword for an ad group
+     */
+    async createNegativeKeywordForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/negative_keyword`, body);
+    }
+    /**
+     * Bulk create negative keywords for an ad group
+     */
+    async bulkCreateNegativeKeywordsForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/bulk_create_negative_keywords`, body);
+    }
+    /**
+     * Bulk delete negative keywords for an ad group
+     */
+    async bulkDeleteNegativeKeywordsForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/bulk_delete_negative_keywords`, body);
+    }
+    /**
+     * Bulk update negative keywords for an ad group
+     */
+    async bulkUpdateNegativeKeywordsForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/bulk_update_negative_keywords`, body);
+    }
+    /**
+     * Get a negative keyword for an ad group
+     */
+    async getNegativeKeywordForAdGroup(adGroupId, negativeKeywordId) {
+        return await this.client.get(`${this.basePath}/ad_group/${adGroupId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Delete a negative keyword for an ad group
+     */
+    async deleteNegativeKeywordForAdGroup(adGroupId, negativeKeywordId) {
+        return await this.client.delete(`${this.basePath}/ad_group/${adGroupId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Update a negative keyword for an ad group
+     */
+    async updateNegativeKeywordForAdGroup(adGroupId, negativeKeywordId, body) {
+        return await this.client.put(`${this.basePath}/ad_group/${adGroupId}/negative_keyword/${negativeKeywordId}`, body);
+    }
+    /**
+     * Delete a campaign
+     */
+    async deleteCampaign(campaignId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}`);
+    }
+    /**
+     * Launch a campaign
+     */
+    async launchCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/launch`, {});
+    }
+    /**
+     * Find campaign by ad reference
+     */
+    async findCampaignByAdReference(inventoryReferenceId, inventoryReferenceType, listingId) {
+        const params = {};
+        if (inventoryReferenceId)
+            params.inventory_reference_id = inventoryReferenceId;
+        if (inventoryReferenceType)
+            params.inventory_reference_type = inventoryReferenceType;
+        if (listingId)
+            params.listing_id = listingId;
+        return await this.client.get(`${this.basePath}/ad_campaign/find_campaign_by_ad_reference`, params);
+    }
+    /**
+     * Setup quick campaign
+     */
+    async setupQuickCampaign(body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/setup_quick_campaign`, body);
+    }
+    /**
+     * Suggest budget for a campaign
+     */
+    async suggestBudget(campaignId) {
+        const params = {};
+        if (campaignId)
+            params.campaign_id = campaignId;
+        return await this.client.get(`${this.basePath}/ad_campaign/suggest_budget`, params);
+    }
+    /**
+     * Suggest items for a campaign
+     */
+    async suggestItems(campaignId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/suggest_items`);
+    }
+    /**
+     * Suggest max CPC for ads
+     */
+    async suggestMaxCpc(body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/suggest_max_cpc`, body);
+    }
+    /**
+     * Update ad rate strategy for a campaign
+     */
+    async updateAdRateStrategy(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/update_ad_rate_strategy`, body);
+    }
+    /**
+     * Update bidding strategy for a campaign
+     */
+    async updateBiddingStrategy(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/update_bidding_strategy`, body);
+    }
+    /**
+     * Update campaign budget
+     */
+    async updateCampaignBudget(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/update_campaign_budget`, body);
+    }
+    /**
+     * Update an ad group
+     */
+    async updateAdGroup(campaignId, adGroupId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}`, body);
+    }
+    /**
+     * Update a keyword
+     */
+    async updateKeyword(campaignId, keywordId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/keyword/${keywordId}`, body);
+    }
+    /**
+     * Bulk create keywords (campaign level)
+     */
+    async bulkCreateKeyword(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_keyword`, body);
+    }
+    /**
+     * Bulk update keywords (campaign level)
+     */
+    async bulkUpdateKeyword(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_keyword`, body);
+    }
+    /**
+     * Get a report by ID
+     */
+    async getReport(reportId) {
+        return await this.client.get(`${this.basePath}/ad_report/${reportId}`);
+    }
+    /**
+     * Delete a report task
+     */
+    async deleteReportTask(reportTaskId) {
+        return await this.client.delete(`${this.basePath}/ad_report_task/${reportTaskId}`);
+    }
+    /**
+     * Create an item price markdown promotion
+     */
+    async createItemPriceMarkdownPromotion(body) {
+        return await this.client.post(`${this.basePath}/item_price_markdown`, body);
+    }
+    /**
+     * Get an item price markdown promotion
+     */
+    async getItemPriceMarkdownPromotion(promotionId) {
+        return await this.client.get(`${this.basePath}/item_price_markdown/${promotionId}`);
+    }
+    /**
+     * Update an item price markdown promotion
+     */
+    async updateItemPriceMarkdownPromotion(promotionId, body) {
+        return await this.client.put(`${this.basePath}/item_price_markdown/${promotionId}`, body);
+    }
+    /**
+     * Delete an item price markdown promotion
+     */
+    async deleteItemPriceMarkdownPromotion(promotionId) {
+        return await this.client.delete(`${this.basePath}/item_price_markdown/${promotionId}`);
+    }
+    /**
+     * Get listing set for a promotion
+     */
+    async getListingSet(promotionId) {
+        return await this.client.get(`${this.basePath}/promotion/${promotionId}/get_listing_set`);
+    }
+    /**
+     * Pause a promotion
+     */
+    async pausePromotion(promotionId) {
+        return await this.client.post(`${this.basePath}/promotion/${promotionId}/pause`, {});
+    }
+    /**
+     * Resume a promotion
+     */
+    async resumePromotion(promotionId) {
+        return await this.client.post(`${this.basePath}/promotion/${promotionId}/resume`, {});
+    }
+    /**
+     * Get email campaigns
+     */
+    async getEmailCampaigns(limit, offset) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/email_campaign`, params);
+    }
+    /**
+     * Create an email campaign
+     */
+    async createEmailCampaign(body) {
+        return await this.client.post(`${this.basePath}/email_campaign`, body);
+    }
+    /**
+     * Get an email campaign
+     */
+    async getEmailCampaign(emailCampaignId) {
+        return await this.client.get(`${this.basePath}/email_campaign/${emailCampaignId}`);
+    }
+    /**
+     * Update an email campaign
+     */
+    async updateEmailCampaign(emailCampaignId, body) {
+        return await this.client.put(`${this.basePath}/email_campaign/${emailCampaignId}`, body);
+    }
+    /**
+     * Delete an email campaign
+     */
+    async deleteEmailCampaign(emailCampaignId) {
+        return await this.client.delete(`${this.basePath}/email_campaign/${emailCampaignId}`);
+    }
+    /**
+     * Get email campaign audiences
+     */
+    async getAudiences() {
+        return await this.client.get(`${this.basePath}/email_campaign/audience`);
+    }
+    /**
+     * Get email preview for a campaign
+     */
+    async getEmailPreview(emailCampaignId) {
+        return await this.client.get(`${this.basePath}/email_campaign/${emailCampaignId}/email_preview`);
+    }
+    /**
+     * Get email campaign report
+     */
+    async getEmailReport(limit, offset) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/email_campaign/report`, params);
+    }
+}