taboola-backstage-sdk 0.3.0 → 0.6.0

package/dist/index.cjs

@@ -270,7 +270,9 @@ var HttpClient = class {
         afterResponse: [
           async (request, _options, response) => {
             if (this.debug) {
-              console.log(`[Taboola SDK] ${request.method} ${String(response.status)} ${request.url}`);
+              console.log(
+                `[Taboola SDK] ${request.method} ${String(response.status)} ${request.url}`
+              );
             }
             if (response.status === 401) {
               try {
@@ -430,17 +432,6 @@ var CampaignsAPI = class {
   }
   /**
    * List all campaigns for an account
-   *
-   * @param accountId - Account ID
-   * @param options - Pagination and filter options
-   *
-   * @example
-   * ```typescript
-   * const { results } = await client.campaigns.list('my-account');
-   * for (const campaign of results) {
-   *   console.log(campaign.name, campaign.status);
-   * }
-   * ```
    */
   async list(accountId, options = {}) {
     const searchParams = new URLSearchParams();
@@ -462,115 +453,30 @@ var CampaignsAPI = class {
   }
   /**
    * List all campaigns with base (partial) fields only
-   *
-   * Returns a lighter-weight response with fewer fields per campaign.
-   * Useful for listing/overview pages where full campaign data is not needed.
-   *
-   * @param accountId - Account ID
-   *
-   * @example
-   * ```typescript
-   * const { results } = await client.campaigns.listBase('my-account');
-   * for (const campaign of results) {
-   *   console.log(campaign.name, campaign.status);
-   * }
-   * ```
    */
   async listBase(accountId) {
     return this.http.get(`${accountId}/campaigns/base`);
   }
   /**
    * Get a single campaign by ID
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   *
-   * @example
-   * ```typescript
-   * const campaign = await client.campaigns.get('my-account', '12345');
-   * console.log(campaign.name, campaign.cpc);
-   * ```
    */
   async get(accountId, campaignId) {
     return this.http.get(`${accountId}/campaigns/${campaignId}`);
   }
   /**
    * Create a new campaign
-   *
-   * @param accountId - Account ID
-   * @param campaign - Campaign data
-   *
-   * @example
-   * ```typescript
-   * const campaign = await client.campaigns.create('my-account', {
-   *   name: 'My New Campaign',
-   *   branding_text: 'My Brand',
-   *   cpc: 0.50,
-   *   spending_limit: 1000,
-   *   spending_limit_model: 'MONTHLY',
-   *   marketing_objective: 'DRIVE_WEBSITE_TRAFFIC',
-   * });
-   * console.log('Created campaign:', campaign.id);
-   * ```
    */
   async create(accountId, campaign) {
     return this.http.post(`${accountId}/campaigns/`, campaign);
   }
   /**
    * Update an existing campaign
-   *
-   * Submit only the fields you want to update. Fields that are omitted or null
-   * will remain unchanged.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param updates - Fields to update (partial)
-   *
-   * @example Update a single field
-   * ```typescript
-   * const campaign = await client.campaigns.update('my-account', '12345', {
-   *   name: 'DemoCampaign - Edited',
-   * });
-   * ```
-   *
-   * @example Update multiple fields including targeting
-   * ```typescript
-   * const campaign = await client.campaigns.update('my-account', '12345', {
-   *   name: 'Demo Campaign - Edited Again',
-   *   branding_text: 'New branding text',
-   *   spending_limit: 10000,
-   *   spending_limit_model: 'ENTIRE',
-   *   country_targeting: {
-   *     type: 'INCLUDE',
-   *     value: ['AU', 'GB'],
-   *   },
-   *   platform_targeting: {
-   *     type: 'INCLUDE',
-   *     value: ['TBLT', 'PHON'],
-   *   },
-   * });
-   * ```
-   *
-   * @example Pause a campaign (alternatively, use pause() method)
-   * ```typescript
-   * const campaign = await client.campaigns.update('my-account', '12345', {
-   *   is_active: false,
-   * });
-   * ```
    */
   async update(accountId, campaignId, updates) {
     return this.http.post(`${accountId}/campaigns/${campaignId}`, updates);
   }
   /**
    * Delete a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   *
-   * @example
-   * ```typescript
-   * await client.campaigns.delete('my-account', '12345');
-   * ```
    */
   async delete(accountId, campaignId) {
     await this.http.delete(`${accountId}/campaigns/${campaignId}`);
@@ -578,122 +484,58 @@ var CampaignsAPI = class {
   /**
    * Duplicate a campaign
    *
-   * Creates a copy of an existing campaign with a new name.
-   *
    * @param accountId - Account ID
    * @param campaignId - Campaign ID to duplicate
-   * @param newName - Name for the new campaign
-   *
-   * @example
-   * ```typescript
-   * const newCampaign = await client.campaigns.duplicate(
-   *   'my-account',
-   *   '12345',
-   *   'My Campaign - Copy'
-   * );
-   * ```
+   * @param request - Duplication request with optional name and settings
+   * @param destinationAccount - Optional destination account ID for cross-account duplication
    */
-  async duplicate(accountId, campaignId, newName) {
-    return this.http.post(`${accountId}/campaigns/${campaignId}/duplicate`, {
-      name: newName
-    });
+  async duplicate(accountId, campaignId, request, destinationAccount) {
+    const searchParams = new URLSearchParams();
+    if (destinationAccount) {
+      searchParams.set("destination_account", destinationAccount);
+    }
+    const query = searchParams.toString();
+    const path = `${accountId}/campaigns/${campaignId}/duplicate${query ? `?${query}` : ""}`;
+    return this.http.post(path, request);
   }
   /**
    * Pause a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   *
-   * @example
-   * ```typescript
-   * await client.campaigns.pause('my-account', '12345');
-   * ```
    */
   async pause(accountId, campaignId) {
     return this.update(accountId, campaignId, { is_active: false });
   }
   /**
    * Unpause (resume) a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   *
-   * @example
-   * ```typescript
-   * await client.campaigns.unpause('my-account', '12345');
-   * ```
    */
   async unpause(accountId, campaignId) {
     return this.update(accountId, campaignId, { is_active: true });
   }
   /**
    * Bulk update multiple campaigns
-   *
-   * @param accountId - Account ID
-   * @param updates - Array of campaign updates
-   *
-   * @example
-   * ```typescript
-   * await client.campaigns.bulkUpdate('my-account', {
-   *   campaigns: [
-   *     { campaign_id: '12345', update: { is_active: false } },
-   *     { campaign_id: '12346', update: { is_active: false } },
-   *   ],
-   * });
-   * ```
    */
   async bulkUpdate(accountId, updates) {
     return this.http.put(`${accountId}/campaigns/bulk`, updates);
   }
   /**
-   * Patch a campaign collection (targeting, bid modifiers, etc.)
+   * Patch a campaign
    *
    * @param accountId - Account ID
    * @param campaignId - Campaign ID
-   * @param collection - Collection name (e.g., 'publisher_targeting')
-   * @param patches - Patch operations
-   *
-   * @example
-   * ```typescript
-   * await client.campaigns.patch('my-account', '12345', 'publisher_targeting', [
-   *   { op: 'ADD', path: '/value', value: ['pub-123'] },
-   * ]);
-   * ```
+   * @param patch - Patch operation
    */
-  async patch(accountId, campaignId, collection, patches) {
-    return this.http.patch(`${accountId}/campaigns/${campaignId}/${collection}`, patches);
+  async patch(accountId, campaignId, patch) {
+    return this.http.patch(`${accountId}/campaigns/${campaignId}`, patch);
   }
   /**
    * Get all campaigns across a network
    *
    * @param networkAccountId - Network account ID
-   *
-   * @example
-   * ```typescript
-   * const { results } = await client.campaigns.listNetwork('my-network');
-   * ```
    */
   async listNetwork(networkAccountId) {
-    return this.http.get(`network/${networkAccountId}/campaigns`);
+    return this.http.get(`${networkAccountId}/campaigns/base`);
   }
   /**
    * Estimate campaign reach
-   *
-   * Get estimated impressions, clicks, and reach for a campaign configuration.
-   *
-   * @param accountId - Account ID
-   * @param params - Targeting and budget parameters
-   *
-   * @example
-   * ```typescript
-   * const estimate = await client.campaigns.estimateReach('my-account', {
-   *   country_targeting: ['US'],
-   *   platform_targeting: ['DESK', 'PHON'],
-   *   daily_cap: 100,
-   *   cpc: 0.50,
-   * });
-   * console.log('Estimated clicks:', estimate.estimated_clicks);
-   * ```
    */
   async estimateReach(accountId, params) {
     return this.http.post(
@@ -703,17 +545,6 @@ var CampaignsAPI = class {
   }
   /**
    * Get publisher targeting whitelist for a campaign
-   *
-   * Returns the list of publishers that are whitelisted for this campaign.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   *
-   * @example
-   * ```typescript
-   * const whitelist = await client.campaigns.getTargetingWhitelist('my-account', '12345');
-   * console.log('Whitelisted publishers:', whitelist.value);
-   * ```
    */
   async getTargetingWhitelist(accountId, campaignId) {
     return this.http.get(
@@ -777,22 +608,26 @@ var ItemsAPI = class {
     return this.http.get(`${accountId}/campaigns/${campaignId}/items/${itemId}`);
   }
   /**
-   * Create a new item (ad) in a campaign
+   * Create a new item (static ad) in a campaign
+   *
+   * Only the `url` field is accepted. The item is created with a status of CRAWLING
+   * (read-only). Poll until the status changes to RUNNING or NEED_TO_EDIT, then
+   * use `update()` to modify fields.
+   *
+   * For creating items with more fields upfront, or for motion ads,
+   * use `bulkCreateAcrossCampaigns()` instead.
    *
    * @param accountId - Account ID
    * @param campaignId - Campaign ID
-   * @param item - Item data
+   * @param item - Item data (only `url` is accepted)
    *
    * @example
    * ```typescript
    * const item = await client.items.create('my-account', '12345', {
    *   url: 'https://example.com/landing-page',
-   *   title: 'Check Out Our Amazing Product!',
-   *   thumbnail_url: 'https://example.com/image.jpg',
-   *   description: 'Learn more about our product',
-   *   cta: { cta_type: 'LEARN_MORE' },
    * });
-   * console.log('Created item:', item.id);
+   * // Item starts in CRAWLING state - poll until status changes
+   * console.log('Created item:', item.id, item.status); // CRAWLING
    * ```
    */
   async create(accountId, campaignId, item) {
@@ -890,11 +725,13 @@ var ItemsAPI = class {
     return this.update(accountId, campaignId, itemId, { is_active: true });
   }
   /**
-   * Create multiple items at once (mass create)
+   * Create multiple items at once within a single campaign (mass create)
+   *
+   * Supports both static ads and motion ads via the bulk item data format.
    *
    * @param accountId - Account ID
    * @param campaignId - Campaign ID
-   * @param items - Array of items to create
+   * @param request - Bulk create request with items array
    *
    * @example
    * ```typescript
@@ -916,14 +753,31 @@ var ItemsAPI = class {
   /**
    * Bulk create items across multiple campaigns
    *
+   * Unified endpoint that supports both static ads and motion ads.
+   *
    * @param accountId - Account ID
    * @param items - Array of items with campaign IDs
    *
-   * @example
+   * @example Static ads
    * ```typescript
    * await client.items.bulkCreateAcrossCampaigns('my-account', [
-   *   { campaign_id: '12345', url: '...', title: '...' },
-   *   { campaign_id: '12346', url: '...', title: '...' },
+   *   { campaign_id: '12345', url: 'https://example.com/1', title: 'Title 1' },
+   *   { campaign_id: '12346', url: 'https://example.com/2', title: 'Title 2' },
+   * ]);
+   * ```
+   *
+   * @example Motion ads
+   * ```typescript
+   * await client.items.bulkCreateAcrossCampaigns('my-account', [
+   *   {
+   *     campaign_id: '12345',
+   *     url: 'https://example.com/1',
+   *     title: 'Motion Ad',
+   *     performance_video_data: {
+   *       video_url: 'https://example.com/video.mp4',
+   *       fallback_url: 'https://example.com/fallback.jpg',
+   *     },
+   *   },
    * ]);
    * ```
    */
@@ -1027,15 +881,11 @@ var DictionaryAPI = class {
    * Get list of all supported countries
    */
   async getCountries() {
-    const response = await this.http.get(
-      "resources/countries"
-    );
+    const response = await this.http.get("resources/countries");
     return response.results;
   }
   /**
    * Get regions/states within a country
-   *
-   * @param countryCode - Country code (e.g., 'US', 'GB')
    */
   async getRegions(countryCode) {
     const response = await this.http.get(
@@ -1045,9 +895,6 @@ var DictionaryAPI = class {
   }
   /**
    * Get DMAs (Designated Market Areas) for a country
-   * Note: Only available for US
-   *
-   * @param countryCode - Country code (typically 'US')
    */
   async getDMAs(countryCode) {
     const response = await this.http.get(
@@ -1057,9 +904,6 @@ var DictionaryAPI = class {
   }
   /**
    * Get postal codes for a country
-   *
-   * @param countryCode - Country code (e.g., 'US', 'GB')
-   * @param params - Optional search and pagination parameters
    */
   async getPostalCodes(countryCode, params) {
     const searchParams = new URLSearchParams();
@@ -1083,9 +927,7 @@ var DictionaryAPI = class {
    * Get list of supported platforms
    */
   async getPlatforms() {
-    const response = await this.http.get(
-      "resources/platforms"
-    );
+    const response = await this.http.get("resources/platforms");
     return response.results;
   }
   /**
@@ -1119,9 +961,7 @@ var DictionaryAPI = class {
    * Get list of supported browsers
    */
   async getBrowsers() {
-    const response = await this.http.get(
-      "resources/browsers"
-    );
+    const response = await this.http.get("resources/browsers");
     return response.results;
   }
   // ===== Enums =====
@@ -1141,9 +981,7 @@ var DictionaryAPI = class {
    * Get days of week for activity scheduling
    */
   async getDaysOfWeek() {
-    const response = await this.http.get(
-      "resources/days-of-week"
-    );
+    const response = await this.http.get("resources/days-of-week");
     return response.results;
   }
   // ===== Possible Values =====
@@ -1178,9 +1016,7 @@ var DictionaryAPI = class {
    * Get minimum CPC values per country/platform
    */
   async getMinimumCPCs() {
-    const response = await this.http.get(
-      "resources/minimum-cpc"
-    );
+    const response = await this.http.get("resources/minimum-cpc");
     return response.results;
   }
   // ===== Image Library =====
@@ -1195,8 +1031,6 @@ var DictionaryAPI = class {
   }
   /**
    * Get image taxonomies for categorizing images
-   *
-   * @param accountId - Account ID
    */
   async getImageTaxonomies(accountId) {
     const response = await this.http.get(
@@ -1207,58 +1041,46 @@ var DictionaryAPI = class {
   // ===== Audience Targeting =====
   /**
    * Get marketplace audience segments available for targeting
-   *
-   * @param accountId - Account ID
    */
   async getMarketplaceAudiences(accountId) {
     const response = await this.http.get(
-      `${accountId}/dictionary/audience/segments`
+      `${accountId}/dictionary/audience_segments`
     );
     return response.results;
   }
   /**
    * Get marketplace audience segments for a specific country
-   *
-   * @param accountId - Account ID
-   * @param countryCode - Country code (e.g., 'US', 'GB')
    */
   async getMarketplaceAudiencesByCountry(accountId, countryCode) {
     const response = await this.http.get(
-      `${accountId}/dictionary/audience/segments/${countryCode}`
+      `${accountId}/dictionary/audience_segments/${countryCode}`
     );
     return response.results;
   }
   /**
    * Get lookalike audiences available for targeting
-   *
-   * @param accountId - Account ID
    */
   async getLookalikeAudiences(accountId) {
     const response = await this.http.get(
-      `${accountId}/dictionary/lookalike-audiences`
+      `${accountId}/dictionary/lookalike_audiences`
     );
     return response.results;
   }
   /**
    * Get lookalike audiences for a specific country
-   *
-   * @param accountId - Account ID
-   * @param countryCode - Country code (e.g., 'US', 'GB')
    */
   async getLookalikeAudiencesByCountry(accountId, countryCode) {
     const response = await this.http.get(
-      `${accountId}/dictionary/lookalike-audiences/${countryCode}`
+      `${accountId}/dictionary/lookalike_audiences/${countryCode}`
     );
     return response.results;
   }
   /**
    * Get contextual segments available for targeting
-   *
-   * @param accountId - Account ID
    */
   async getContextualSegments(accountId) {
     const response = await this.http.get(
-      `${accountId}/dictionary/contextual-segments`
+      `${accountId}/dictionary/contextual_segments`
     );
     return response.results;
   }
@@ -1271,116 +1093,55 @@ var PublishersAPI = class {
   }
   /**
    * List all available publishers for an account
-   *
-   * @param accountId - Account ID
-   * @returns List of publishers with blocking status
-   *
-   * @example
-   * ```typescript
-   * const publishers = await client.publishers.list('my-account');
-   * console.log(`Found ${publishers.length} publishers`);
-   * ```
    */
   async list(accountId) {
-    const response = await this.http.get(
-      `${accountId}/publishers`
-    );
+    const response = await this.http.get(`${accountId}/allowed-publishers`);
     return response.results;
   }
   /**
    * Get blocked publishers at the account level
-   *
-   * @param accountId - Account ID
-   * @returns List of blocked publishers
-   *
-   * @example
-   * ```typescript
-   * const blocked = await client.publishers.getBlocked('my-account');
-   * console.log(`${blocked.length} publishers blocked at account level`);
-   * ```
    */
   async getBlocked(accountId) {
-    const response = await this.http.get(
-      `${accountId}/block-publisher`
-    );
-    if (Array.isArray(response)) {
-      return response;
-    }
-    return response.results ?? [];
+    const response = await this.http.get(`${accountId}/block-publisher`);
+    return response.sites;
   }
   /**
    * Update blocked publishers at the account level
    *
    * This replaces the current list of blocked publishers with the
-   * provided list. To add to existing blocks, first get the current
-   * list and append.
-   *
-   * @param accountId - Account ID
-   * @param sites - Array of site names to block
-   * @returns Updated list of blocked publishers
-   *
-   * @example
-   * ```typescript
-   * // Block specific publishers
-   * await client.publishers.updateBlocked('my-account', {
-   *   sites: ['site1.com', 'site2.com']
-   * });
-   *
-   * // Add to existing blocks
-   * const current = await client.publishers.getBlocked('my-account');
-   * const currentSites = current.map(p => p.site);
-   * await client.publishers.updateBlocked('my-account', {
-   *   sites: [...currentSites, 'newsite.com']
-   * });
-   * ```
+   * provided list.
    */
   async updateBlocked(accountId, request) {
     const response = await this.http.post(
       `${accountId}/block-publisher`,
       request
     );
-    return response.results;
+    return response.sites;
   }
   /**
    * Block a single publisher at the account level
-   *
-   * Convenience method that adds a publisher to the existing block list.
-   *
-   * @param accountId - Account ID
-   * @param site - Site name to block
-   * @returns Updated list of blocked publishers
    */
   async blockPublisher(accountId, site) {
     const current = await this.getBlocked(accountId);
-    const currentSites = current.map((p) => p.site);
-    if (currentSites.includes(site)) {
+    if (current.includes(site)) {
       return current;
     }
     return this.updateBlocked(accountId, {
-      sites: [...currentSites, site]
+      sites: [...current, site]
     });
   }
   /**
    * Unblock a single publisher at the account level
-   *
-   * Convenience method that removes a publisher from the block list.
-   *
-   * @param accountId - Account ID
-   * @param site - Site name to unblock
-   * @returns Updated list of blocked publishers
    */
   async unblockPublisher(accountId, site) {
     const current = await this.getBlocked(accountId);
-    const filteredSites = current.map((p) => p.site).filter((s) => s !== site);
+    const filteredSites = current.filter((s) => s !== site);
     return this.updateBlocked(accountId, {
       sites: filteredSites
     });
   }
   /**
    * Clear all blocked publishers at the account level
-   *
-   * @param accountId - Account ID
-   * @returns Empty list
    */
   async clearBlocked(accountId) {
     return this.updateBlocked(accountId, { sites: [] });
@@ -1395,17 +1156,6 @@ var TargetingAPI = class {
   // ===== Postal Code Targeting =====
   /**
    * Get postal code targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns Postal code targeting configuration
-   *
-   * @example
-   * ```typescript
-   * const targeting = await client.targeting.getPostalCodes('my-account', '12345');
-   * console.log(`Targeting type: ${targeting.type}`);
-   * console.log(`Postal codes: ${targeting.values.length}`);
-   * ```
    */
   async getPostalCodes(accountId, campaignId) {
     return this.http.get(
@@ -1414,22 +1164,6 @@ var TargetingAPI = class {
   }
   /**
    * Update postal code targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - Postal code targeting configuration
-   * @returns Updated targeting configuration
-   *
-   * @example
-   * ```typescript
-   * await client.targeting.updatePostalCodes('my-account', '12345', {
-   *   type: 'INCLUDE',
-   *   values: [
-   *     { postal_code: '10001', country: 'US' },
-   *     { postal_code: '10002', country: 'US' },
-   *   ]
-   * });
-   * ```
    */
   async updatePostalCodes(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1440,13 +1174,6 @@ var TargetingAPI = class {
   // ===== Marketplace Audience Targeting =====
   /**
    * Get marketplace audience targeting for a campaign
-   *
-   * Marketplace audiences are third-party audience segments
-   * available for targeting through Taboola's marketplace.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns Audience targeting configuration
    */
   async getMarketplaceAudiences(accountId, campaignId) {
     return this.http.get(
@@ -1455,22 +1182,6 @@ var TargetingAPI = class {
   }
   /**
    * Update marketplace audience targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - Audience targeting configuration
-   * @returns Updated targeting configuration
-   *
-   * @example
-   * ```typescript
-   * await client.targeting.updateMarketplaceAudiences('my-account', '12345', {
-   *   type: 'INCLUDE',
-   *   collection: [
-   *     { id: 'segment-1', name: null },
-   *     { id: 'segment-2', name: null },
-   *   ]
-   * });
-   * ```
    */
   async updateMarketplaceAudiences(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1481,13 +1192,6 @@ var TargetingAPI = class {
   // ===== Custom Audience Targeting =====
   /**
    * Get custom audience targeting for a campaign
-   *
-   * Custom audiences are audiences created from pixel data
-   * or uploaded lists.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns Audience targeting configuration
    */
   async getCustomAudiences(accountId, campaignId) {
     return this.http.get(
@@ -1496,11 +1200,6 @@ var TargetingAPI = class {
   }
   /**
    * Update custom audience targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - Audience targeting configuration
-   * @returns Updated targeting configuration
    */
   async updateCustomAudiences(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1511,13 +1210,6 @@ var TargetingAPI = class {
   // ===== Lookalike Audience Targeting =====
   /**
    * Get lookalike audience targeting for a campaign
-   *
-   * Lookalike audiences are modeled after your existing
-   * custom audiences to find similar users.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns Audience targeting configuration
    */
   async getLookalikeAudiences(accountId, campaignId) {
     return this.http.get(
@@ -1526,11 +1218,6 @@ var TargetingAPI = class {
   }
   /**
    * Update lookalike audience targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - Audience targeting configuration
-   * @returns Updated targeting configuration
    */
   async updateLookalikeAudiences(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1541,13 +1228,6 @@ var TargetingAPI = class {
   // ===== Contextual Targeting =====
   /**
    * Get contextual targeting for a campaign
-   *
-   * Contextual targeting allows you to target based on the
-   * content of the pages where your ads appear.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns Contextual targeting configuration
    */
   async getContextual(accountId, campaignId) {
     return this.http.get(
@@ -1556,22 +1236,6 @@ var TargetingAPI = class {
   }
   /**
    * Update contextual targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - Contextual targeting configuration
-   * @returns Updated targeting configuration
-   *
-   * @example
-   * ```typescript
-   * await client.targeting.updateContextual('my-account', '12345', {
-   *   type: 'INCLUDE',
-   *   collection: [
-   *     { id: 'context-1', name: null },
-   *     { id: 'context-2', name: null },
-   *   ]
-   * });
-   * ```
    */
   async updateContextual(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1582,12 +1246,6 @@ var TargetingAPI = class {
   // ===== First Party Audience Targeting =====
   /**
    * Get first party audience targeting for a campaign
-   *
-   * First party audiences are your own uploaded audience data.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns First party audience targeting configuration
    */
   async getFirstPartyAudiences(accountId, campaignId) {
     return this.http.get(
@@ -1596,11 +1254,6 @@ var TargetingAPI = class {
   }
   /**
    * Update first party audience targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - First party audience targeting configuration
-   * @returns Updated targeting configuration
    */
   async updateFirstPartyAudiences(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1611,19 +1264,6 @@ var TargetingAPI = class {
   // ===== Marking Labels Targeting =====
   /**
    * Get marking labels (pixel retargeting) targeting for a campaign
-   *
-   * Marking labels allow you to target users based on pixel-tracked
-   * behavior using custom labels.
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @returns Marking labels targeting configuration
-   *
-   * @example
-   * ```typescript
-   * const targeting = await client.targeting.getMarkingLabels('my-account', '12345');
-   * console.log('Labels:', targeting.collection);
-   * ```
    */
   async getMarkingLabels(accountId, campaignId) {
     return this.http.get(
@@ -1632,19 +1272,6 @@ var TargetingAPI = class {
   }
   /**
    * Update marking labels targeting for a campaign
-   *
-   * @param accountId - Account ID
-   * @param campaignId - Campaign ID
-   * @param targeting - Marking labels targeting configuration
-   * @returns Updated targeting configuration
-   *
-   * @example
-   * ```typescript
-   * await client.targeting.updateMarkingLabels('my-account', '12345', {
-   *   type: 'EXISTS',
-   *   collection: ['label-1', 'label-2'],
-   * });
-   * ```
    */
   async updateMarkingLabels(accountId, campaignId, targeting) {
     return this.http.post(
@@ -1661,105 +1288,40 @@ var CombinedAudiencesAPI = class {
   }
   /**
    * List available audiences for combining
-   *
-   * Returns all audiences that can be used in combined audience rules,
-   * including custom, lookalike, marketplace, and first-party audiences.
-   *
-   * @param accountId - Account ID
-   * @returns List of available audiences
-   *
-   * @example
-   * ```typescript
-   * const available = await client.combinedAudiences.listAvailable('my-account');
-   * console.log(`${available.length} audiences available for combining`);
-   * ```
    */
   async listAvailable(accountId) {
     const response = await this.http.get(
-      `${accountId}/combined-audiences/available`
+      `${accountId}/combined_audiences/resources/audiences`
     );
     return response.results;
   }
   /**
    * List all combined audiences
-   *
-   * @param accountId - Account ID
-   * @returns List of combined audiences
-   *
-   * @example
-   * ```typescript
-   * const audiences = await client.combinedAudiences.list('my-account');
-   * for (const audience of audiences) {
-   *   console.log(`${audience.name}: ${audience.status}`);
-   * }
-   * ```
    */
   async list(accountId) {
     const response = await this.http.get(
-      `${accountId}/combined-audiences`
+      `${accountId}/combined_audiences`
     );
     return response.results;
   }
   /**
    * Get a single combined audience
-   *
-   * @param accountId - Account ID
-   * @param audienceId - Combined audience ID
-   * @returns Combined audience details
    */
   async get(accountId, audienceId) {
-    return this.http.get(
-      `${accountId}/combined-audiences/${audienceId}`
-    );
+    return this.http.get(`${accountId}/combined_audiences/${audienceId}`);
   }
   /**
    * Create a combined audience
-   *
-   * @param accountId - Account ID
-   * @param audience - Combined audience configuration
-   * @returns Created combined audience
-   *
-   * @example
-   * ```typescript
-   * const audience = await client.combinedAudiences.create('my-account', {
-   *   name: 'High-Value Engaged Users',
-   *   description: 'Users who are both high-value and engaged',
-   *   include_rules: [
-   *     {
-   *       audience_type: 'CUSTOM_AUDIENCE',
-   *       audiences: [{ id: 'custom-1', name: null }]
-   *     },
-   *     {
-   *       audience_type: 'LOOKALIKE_AUDIENCE',
-   *       audiences: [{ id: 'lookalike-1', name: null }]
-   *     }
-   *   ],
-   *   exclude_rules: [
-   *     {
-   *       audience_type: 'CUSTOM_AUDIENCE',
-   *       audiences: [{ id: 'converters', name: null }]
-   *     }
-   *   ]
-   * });
-   * ```
    */
   async create(accountId, audience) {
-    return this.http.post(
-      `${accountId}/combined-audiences`,
-      audience
-    );
+    return this.http.post(`${accountId}/combined_audiences`, audience);
   }
   /**
    * Update a combined audience
-   *
-   * @param accountId - Account ID
-   * @param audienceId - Combined audience ID
-   * @param updates - Fields to update
-   * @returns Updated combined audience
    */
   async update(accountId, audienceId, updates) {
     return this.http.post(
-      `${accountId}/combined-audiences/${audienceId}`,
+      `${accountId}/combined_audiences/${audienceId}`,
       updates
     );
   }
@@ -1772,118 +1334,32 @@ var FirstPartyAudiencesAPI = class {
   }
   /**
    * List all first party audiences
-   *
-   * @param accountId - Account ID
-   * @returns List of first party audiences
-   *
-   * @example
-   * ```typescript
-   * const audiences = await client.firstPartyAudiences.list('my-account');
-   * for (const audience of audiences) {
-   *   console.log(`${audience.name}: ${audience.status} (${audience.size} users)`);
-   * }
-   * ```
    */
   async list(accountId) {
     const response = await this.http.get(
-      `${accountId}/audience-onboarding/first-party-audiences`
+      `${accountId}/audience_onboarding/my_audiences`
     );
     return response.results;
   }
   /**
    * Get a single first party audience
-   *
-   * @param accountId - Account ID
-   * @param audienceId - Audience ID
-   * @returns First party audience details
    */
   async get(accountId, audienceId) {
     return this.http.get(
-      `${accountId}/audience-onboarding/first-party-audiences/${audienceId}`
+      `${accountId}/audience_onboarding/my_audiences/${audienceId}`
     );
   }
   /**
    * Create a first party audience
-   *
-   * After creation, use addUsers() to populate the audience with identifiers.
-   *
-   * @param accountId - Account ID
-   * @param audience - Audience configuration
-   * @returns Created audience
-   *
-   * @example
-   * ```typescript
-   * const audience = await client.firstPartyAudiences.create('my-account', {
-   *   name: 'High-Value Customers',
-   *   description: 'Customers with LTV > $1000',
-   *   source_type: 'CRM',
-   *   ttl_days: 90
-   * });
-   *
-   * // Then add users
-   * await client.firstPartyAudiences.addUsers('my-account', audience.id, {
-   *   add: [
-   *     { identifier_type: 'EMAIL_SHA256', identifier_value: 'sha256hash1' },
-   *     { identifier_type: 'EMAIL_SHA256', identifier_value: 'sha256hash2' },
-   *   ]
-   * });
-   * ```
    */
   async create(accountId, audience) {
-    return this.http.post(
-      `${accountId}/audience-onboarding/first-party-audiences`,
-      audience
-    );
+    return this.http.post(`${accountId}/audience_onboarding/create`, audience);
   }
   /**
    * Add or remove users from a first party audience
-   *
-   * Users are identified by hashed identifiers (email, phone, device ID).
-   * It's recommended to use SHA256 hashed values for privacy.
-   *
-   * @param accountId - Account ID
-   * @param audienceId - Audience ID
-   * @param request - Add/remove request with user identifiers
-   * @returns Operation result with counts
-   *
-   * @example
-   * ```typescript
-   * // Add users
-   * const result = await client.firstPartyAudiences.addUsers('my-account', 'audience-1', {
-   *   add: [
-   *     { identifier_type: 'EMAIL_SHA256', identifier_value: 'sha256hash1' },
-   *     { identifier_type: 'EMAIL_SHA256', identifier_value: 'sha256hash2' },
-   *   ]
-   * });
-   * console.log(`Added ${result.added_count} users`);
-   *
-   * // Remove users
-   * const result2 = await client.firstPartyAudiences.addUsers('my-account', 'audience-1', {
-   *   remove: [
-   *     { identifier_type: 'EMAIL_SHA256', identifier_value: 'sha256hash3' },
-   *   ]
-   * });
-   * console.log(`Removed ${result2.removed_count} users`);
-   * ```
-   */
-  async addUsers(accountId, audienceId, request) {
-    return this.http.post(
-      `${accountId}/audience-onboarding/first-party-audiences/${audienceId}/add-remove`,
-      request
-    );
-  }
-  /**
-   * Remove users from a first party audience
-   *
-   * Convenience method that wraps addUsers with only remove operations.
-   *
-   * @param accountId - Account ID
-   * @param audienceId - Audience ID
-   * @param request - Remove request with user identifiers
-   * @returns Operation result with counts
    */
-  async removeUsers(accountId, audienceId, request) {
-    return this.addUsers(accountId, audienceId, request);
+  async manageUsers(accountId, request) {
+    await this.http.post(`${accountId}/audience_onboarding/my_audiences/users`, request);
   }
 };
 
@@ -1922,7 +1398,7 @@ var PixelAPI = class {
    */
   async getConversionRule(accountId, ruleId) {
     return this.http.get(
-      `${accountId}/universal_pixel/conversion_rule/${ruleId}`
+      `${accountId}/universal_pixel/conversion_rule/${String(ruleId)}`
     );
   }
   /**
@@ -1952,23 +1428,17 @@ var PixelAPI = class {
    * // URL-based conversion rule
    * const rule = await client.pixel.createConversionRule('my-account', {
    *   display_name: 'Purchase Completed',
-   *   type: 'URL_BASED',
-   *   category: 'PURCHASE',
-   *   conditions: [
-   *     {
-   *       type: 'URL',
-   *       operator: 'CONTAINS',
-   *       value: '/thank-you'
-   *     }
-   *   ],
-   *   effect: {
-   *     type: 'DYNAMIC_VALUE',
-   *     value: null,
-   *     currency: 'USD',
-   *     value_parameter: 'order_total'
+   *   type: 'BASIC',
+   *   category: 'MAKE_PURCHASE',
+   *   condition: {
+   *     property: 'URL',
+   *     predicate: 'CONTAINS',
+   *     value: '/thank-you',
+   *     children: [],
    *   },
-   *   conversion_window_days: 30,
-   *   view_through_window_days: 1
+   *   effects: [{ type: 'REVENUE', data: '15' }],
+   *   look_back_window: 30,
+   *   view_through_look_back_window: 1,
    * });
    *
    * // Event-based conversion rule
@@ -1977,21 +1447,12 @@ var PixelAPI = class {
    *   type: 'EVENT_BASED',
    *   category: 'ADD_TO_CART',
    *   event_name: 'add_to_cart',
-   *   conditions: [],
-   *   effect: {
-   *     type: 'FIXED_VALUE',
-   *     value: 10,
-   *     currency: 'USD',
-   *     value_parameter: null
-   *   }
+   *   effects: [{ type: 'REVENUE', data: '10' }],
    * });
    * ```
    */
   async createConversionRule(accountId, rule) {
-    return this.http.post(
-      `${accountId}/universal_pixel/conversion_rule`,
-      rule
-    );
+    return this.http.post(`${accountId}/universal_pixel/conversion_rule`, rule);
   }
   /**
    * Update a conversion rule
@@ -2003,7 +1464,7 @@ var PixelAPI = class {
    */
   async updateConversionRule(accountId, ruleId, updates) {
     return this.http.post(
-      `${accountId}/universal_pixel/conversion_rule/${ruleId}`,
+      `${accountId}/universal_pixel/conversion_rule/${String(ruleId)}`,
       updates
     );
   }
@@ -2077,37 +1538,16 @@ var PixelAPI = class {
    *
    * @example
    * ```typescript
-   * // All visitors audience
    * const allVisitors = await client.pixel.createCustomAudienceRule('my-account', {
    *   display_name: 'All Visitors - 30 Days',
    *   conditions: [],
-   *   ttl_days: 30
+   *   ttl_days: 30,
    * });
    *
-   * // Product page visitors
    * const productViewers = await client.pixel.createCustomAudienceRule('my-account', {
    *   display_name: 'Product Page Viewers',
-   *   conditions: [
-   *     {
-   *       type: 'URL',
-   *       operator: 'CONTAINS',
-   *       value: '/products/'
-   *     }
-   *   ],
-   *   ttl_days: 14
-   * });
-   *
-   * // Cart abandoners
-   * const cartAbandoners = await client.pixel.createCustomAudienceRule('my-account', {
-   *   display_name: 'Cart Abandoners',
-   *   conditions: [
-   *     {
-   *       type: 'EVENT_NAME',
-   *       operator: 'EQUALS',
-   *       value: 'add_to_cart'
-   *     }
-   *   ],
-   *   ttl_days: 7
+   *   conditions: [{ type: 'URL', operator: 'CONTAINS', value: '/products/' }],
+   *   ttl_days: 14,
    * });
    * ```
    */
@@ -2404,9 +1844,7 @@ var SharedBudgetAPI = class {
    * ```
    */
   async get(accountId, sharedBudgetId) {
-    return this.http.get(
-      `${accountId}/shared-budget/${sharedBudgetId}`
-    );
+    return this.http.get(`${accountId}/shared-budget/${sharedBudgetId}`);
   }
   /**
    * List all shared budgets (base/partial fields)
@@ -2424,9 +1862,7 @@ var SharedBudgetAPI = class {
    * ```
    */
   async listBase(accountId) {
-    return this.http.get(
-      `${accountId}/shared-budget/base`
-    );
+    return this.http.get(`${accountId}/shared-budget/base`);
   }
   /**
    * Create a new shared budget
@@ -2447,10 +1883,7 @@ var SharedBudgetAPI = class {
    * ```
    */
   async create(accountId, budget) {
-    return this.http.post(
-      `${accountId}/shared-budget`,
-      budget
-    );
+    return this.http.post(`${accountId}/shared-budget`, budget);
   }
   /**
    * Update an existing shared budget
@@ -2468,10 +1901,7 @@ var SharedBudgetAPI = class {
    * ```
    */
   async update(accountId, sharedBudgetId, updates) {
-    return this.http.put(
-      `${accountId}/shared-budget/${sharedBudgetId}`,
-      updates
-    );
+    return this.http.put(`${accountId}/shared-budget/${sharedBudgetId}`, updates);
   }
 };