@synterai/sdk-js 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1408 @@
+// src/errors.ts
+var SynterError = class _SynterError extends Error {
+  constructor(message, status = 0, code = null, details = null) {
+    super(message);
+    this.name = "SynterError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, _SynterError.prototype);
+  }
+};
+var SynterValidationError = class _SynterValidationError extends Error {
+  constructor(message, field) {
+    super(message);
+    this.name = "SynterValidationError";
+    this.field = field;
+    Object.setPrototypeOf(this, _SynterValidationError.prototype);
+  }
+};
+
+// src/internal/arg-mapping.ts
+var DATE_RANGE_TO_DAYS = {
+  TODAY: 1,
+  YESTERDAY: 1,
+  LAST_7_DAYS: 7,
+  LAST_30_DAYS: 30,
+  THIS_MONTH: 31,
+  LAST_MONTH: 31
+};
+function buildArgsFromMapping(mapping, input, resolvedPlatform) {
+  const args = [];
+  const record = input;
+  for (const entry of mapping) {
+    let value = record[entry.field];
+    if ((value === void 0 || value === null) && entry.default !== void 0) {
+      value = entry.default;
+    }
+    if (value === void 0 || value === null) {
+      if (entry.required) {
+        throw new SynterValidationError(
+          `Missing required field \`${entry.field}\` (maps to \`${entry.flag}\`).`,
+          entry.field
+        );
+      }
+      continue;
+    }
+    if (entry.onlyForPlatform && entry.onlyForPlatform !== resolvedPlatform) {
+      continue;
+    }
+    if (entry.transform === "dateRangeToDays") {
+      const days = DATE_RANGE_TO_DAYS[String(value)];
+      if (days === void 0) {
+        continue;
+      }
+      args.push(entry.flag, String(days));
+      continue;
+    }
+    if (entry.transform === "uppercase") {
+      value = String(value).toUpperCase();
+    }
+    if (entry.type === "array") {
+      if (!Array.isArray(value)) {
+        throw new SynterValidationError(`Field \`${entry.field}\` must be an array.`, entry.field);
+      }
+      for (const item of value) {
+        args.push(entry.flag, String(item));
+      }
+      continue;
+    }
+    args.push(entry.flag, String(value));
+  }
+  return args;
+}
+function resolvePlatformScriptName(scriptNameByPlatform, defaultPlatform, requestedPlatform) {
+  const platform = requestedPlatform ?? defaultPlatform;
+  const scriptName = scriptNameByPlatform[platform];
+  if (!scriptName) {
+    throw new SynterValidationError(
+      `Unsupported platform \`${platform}\`. Expected one of: ${Object.keys(scriptNameByPlatform).join(", ")}.`,
+      "platform"
+    );
+  }
+  return { platform, scriptName };
+}
+function flattenArgsToFlags(args) {
+  const out = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (value === void 0 || value === null) continue;
+    const flag = `--${key.replace(/_/g, "-")}`;
+    if (typeof value === "boolean") {
+      if (value) out.push(flag);
+      continue;
+    }
+    out.push(flag, String(value));
+  }
+  return out;
+}
+
+// src/resources/campaigns.ts
+var LIST_CAMPAIGNS_SCRIPT_BY_PLATFORM = {
+  google: "google_ads_list_campaigns",
+  meta: "meta_ads_list_campaigns",
+  linkedin: "linkedin_ads_list_campaigns",
+  microsoft: "microsoft_ads_list_campaigns",
+  reddit: "reddit_ads_list_campaigns",
+  tiktok: "tiktok_ads_list_campaigns",
+  x: "x_ads_list_campaigns"
+};
+var LIST_CAMPAIGNS_ARG_MAPPING = [
+  { field: "status", flag: "--status", type: "string" },
+  { field: "limit", flag: "--limit", type: "number" }
+];
+var CREATE_SEARCH_ARG_MAPPING = [
+  { field: "campaign_name", flag: "--campaign-name", type: "string", required: true },
+  { field: "daily_budget", flag: "--daily-budget", type: "number", required: true },
+  { field: "final_url", flag: "--final-url", type: "string", required: true },
+  { field: "keywords", flag: "--keyword", type: "array", required: true },
+  { field: "headlines", flag: "--headline", type: "array", required: true },
+  { field: "descriptions", flag: "--description", type: "array", required: true },
+  { field: "geo_targets", flag: "--geo-targets", type: "array" }
+];
+var CREATE_DISPLAY_ARG_MAPPING = [
+  { field: "campaign_name", flag: "--campaign-name", type: "string", required: true },
+  { field: "daily_budget", flag: "--daily-budget", type: "number", required: true },
+  { field: "business_name", flag: "--business-name", type: "string", required: true },
+  { field: "final_url", flag: "--final-url", type: "string", required: true },
+  { field: "landscape_image_url", flag: "--landscape-image", type: "string" },
+  { field: "square_image_url", flag: "--square-image", type: "string" },
+  { field: "headlines", flag: "--headline", type: "array", required: true },
+  { field: "descriptions", flag: "--description", type: "array", required: true },
+  { field: "geo_targets", flag: "--geo-targets", type: "array" }
+];
+var CREATE_PMAX_ARG_MAPPING = [
+  { field: "campaign_name", flag: "--campaign-name", type: "string", required: true },
+  { field: "daily_budget", flag: "--daily-budget", type: "number", required: true },
+  { field: "business_name", flag: "--business-name", type: "string", required: true },
+  { field: "final_url", flag: "--final-url", type: "string", required: true },
+  { field: "long_headline", flag: "--long-headline", type: "string", required: true },
+  { field: "landscape_image_url", flag: "--landscape-image-url", type: "string" },
+  { field: "square_image_url", flag: "--square-image-url", type: "string" },
+  { field: "logo_url", flag: "--logo-url", type: "string" },
+  { field: "target_cpa", flag: "--target-cpa", type: "number" },
+  { field: "headlines", flag: "--headline", type: "array", required: true },
+  { field: "descriptions", flag: "--description", type: "array", required: true },
+  { field: "geo_targets", flag: "--geo-targets", type: "array" }
+];
+var PAUSE_CAMPAIGN_ARG_MAPPING = [
+  { field: "campaign_id", flag: "--campaign-id", type: "string", required: true }
+];
+var UPDATE_BUDGET_ARG_MAPPING = [
+  { field: "campaign_id", flag: "--campaign-id", type: "string", required: true },
+  { field: "daily_budget", flag: "--budget", type: "number", required: true }
+];
+var CampaignsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all campaigns across connected ad platforms. Returns campaign
+   * name, status, budget, and performance metrics.
+   *
+   * Custom-dispatch tool (platform-routed script name) — see SPEC.md's
+   * "Platform resolution" rule 2 and the note on {@link ListCampaignsInput.platform}.
+   */
+  async list(input = {}) {
+    const { platform, scriptName } = resolvePlatformScriptName(
+      LIST_CAMPAIGNS_SCRIPT_BY_PLATFORM,
+      "google",
+      input.platform
+    );
+    const args = buildArgsFromMapping(LIST_CAMPAIGNS_ARG_MAPPING, input);
+    return this.client.runTool(scriptName, args, platform);
+  }
+  /**
+   * Create a Google Ads Search campaign with an ad group, responsive
+   * search ad, and keywords — all in one atomic request. Requires at
+   * least 3 headlines (max 30 chars) and 2 descriptions (max 90 chars).
+   */
+  async createSearch(input) {
+    const args = buildArgsFromMapping(CREATE_SEARCH_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_create_search_campaign", args, "google");
+  }
+  /**
+   * Create a Google Ads Display campaign with responsive display ads.
+   * Supports image uploads from URLs.
+   */
+  async createDisplay(input) {
+    const args = buildArgsFromMapping(CREATE_DISPLAY_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_create_display_campaign", args, "google");
+  }
+  /**
+   * Create a Google Ads Performance Max campaign. Requires images,
+   * headlines, descriptions, and a business name.
+   */
+  async createPmax(input) {
+    const args = buildArgsFromMapping(CREATE_PMAX_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_create_pmax_campaign", args, "google");
+  }
+  /**
+   * Pause a campaign by ID.
+   *
+   * KNOWN ISSUE: see {@link PauseCampaignInput.platform} — always
+   * dispatches with `platform=google` regardless of input.
+   */
+  async pause(input) {
+    if (!input?.platform) {
+      throw new SynterValidationError("`platform` is required.", "platform");
+    }
+    const args = buildArgsFromMapping(PAUSE_CAMPAIGN_ARG_MAPPING, input);
+    return this.client.runTool("pause_campaign", args, "google");
+  }
+  /**
+   * Update the daily budget for a campaign.
+   *
+   * KNOWN ISSUE: see {@link UpdateCampaignBudgetInput.platform} — always
+   * dispatches with `platform=google` regardless of input.
+   */
+  async updateBudget(input) {
+    if (!input?.platform) {
+      throw new SynterValidationError("`platform` is required.", "platform");
+    }
+    const args = buildArgsFromMapping(UPDATE_BUDGET_ARG_MAPPING, input);
+    return this.client.runTool("update_campaign_budget", args, "google");
+  }
+};
+
+// src/resources/analytics.ts
+var GET_PERFORMANCE_SCRIPT_BY_PLATFORM = {
+  google: "pull_google_ads_data",
+  meta: "pull_meta_ads",
+  linkedin: "pull_linkedin_ads_data",
+  microsoft: "pull_microsoft_ads",
+  reddit: "pull_reddit_ads",
+  tiktok: "pull_tiktok_ads",
+  x: "pull_x_ads"
+};
+var GET_PERFORMANCE_ARG_MAPPING = [
+  {
+    field: "campaign_id",
+    flag: "--campaign-id",
+    type: "string",
+    onlyForPlatform: "google"
+    // "campaign_id filtering is only confirmed supported by the Google
+    // script; silently dropped for other platforms rather than sent and
+    // ignored/rejected." — catalog.json
+  },
+  { field: "date_range", flag: "--days", type: "string", transform: "dateRangeToDays" }
+];
+var AnalyticsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get performance metrics (impressions, clicks, spend, conversions,
+   * ROAS) for campaigns.
+   */
+  async getPerformance(input = {}) {
+    const { platform, scriptName } = resolvePlatformScriptName(
+      GET_PERFORMANCE_SCRIPT_BY_PLATFORM,
+      "google",
+      input.platform
+    );
+    const args = buildArgsFromMapping(GET_PERFORMANCE_ARG_MAPPING, input, platform);
+    return this.client.runTool(scriptName, args, platform);
+  }
+  /** Get daily spend breakdown across all connected ad accounts. */
+  async getDailySpend(input = {}) {
+    const platform = input.platform ?? "google";
+    const args = ["--platform", platform.toUpperCase()];
+    if (input.days !== void 0) {
+      args.push("--days", String(input.days));
+    }
+    return this.client.runTool("get_account_daily_spend", args, platform);
+  }
+};
+
+// src/resources/keywords.ts
+var ADD_KEYWORDS_ARG_MAPPING = [
+  { field: "ad_group_id", flag: "--ad-group-id", type: "string", required: true },
+  { field: "keywords", flag: "--keyword", type: "array", required: true },
+  { field: "match_type", flag: "--match-type", type: "string" }
+];
+var ADD_NEGATIVE_KEYWORDS_ARG_MAPPING = [
+  { field: "campaign_id", flag: "--campaign-id", type: "string", required: true },
+  { field: "keywords", flag: "--keyword", type: "array", required: true },
+  { field: "level", flag: "--level", type: "string" }
+];
+var KeywordsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Add keywords to a Google Ads campaign or ad group. */
+  async add(input) {
+    const args = buildArgsFromMapping(ADD_KEYWORDS_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_add_keywords", args, "google");
+  }
+  /** Add negative keywords to block unwanted search terms. */
+  async addNegative(input) {
+    const args = buildArgsFromMapping(ADD_NEGATIVE_KEYWORDS_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_add_negative_keywords", args, "google");
+  }
+};
+
+// src/resources/conversions.ts
+var CREATE_CONVERSION_ARG_MAPPING = [
+  { field: "name", flag: "--name", type: "string", required: true },
+  { field: "value", flag: "--value", type: "number" },
+  { field: "category", flag: "--category", type: "string" }
+];
+var DIAGNOSE_TRACKING_ARG_MAPPING = [
+  { field: "url", flag: "--url", type: "string", required: true }
+];
+var ConversionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a conversion action in Google Ads. Returns the conversion ID
+   * and label for GTM setup.
+   */
+  async create(input) {
+    const args = buildArgsFromMapping(CREATE_CONVERSION_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_create_conversion", args, "google");
+  }
+  /** List all conversion actions configured in Google Ads. */
+  async list() {
+    return this.client.runTool("google_ads_list_conversions", [], "google");
+  }
+  /**
+   * Check if conversion tracking is properly set up on a website.
+   * Verifies gtag.js, GTM, and pixel installation.
+   *
+   * No platform is sent for this tool — it isn't tied to ad-account
+   * credentials (SPEC.md's "Platform resolution" rule 3).
+   */
+  async diagnoseTracking(input) {
+    const args = buildArgsFromMapping(DIAGNOSE_TRACKING_ARG_MAPPING, input);
+    return this.client.runTool("diagnose_conversion_tracking", args);
+  }
+};
+
+// src/resources/creative.ts
+var GENERATE_IMAGE_ARG_MAPPING = [
+  { field: "prompt", flag: "--prompt", type: "string", required: true },
+  { field: "size", flag: "--size", type: "string" },
+  { field: "provider", flag: "--provider", type: "string" },
+  { field: "name", flag: "--name", type: "string" }
+];
+var GENERATE_VIDEO_ARG_MAPPING = [
+  { field: "product_name", flag: "--product", type: "string", required: true },
+  { field: "key_benefit", flag: "--benefit", type: "string", required: true },
+  { field: "concept", flag: "--concept", type: "string" },
+  { field: "target_audience", flag: "--audience", type: "string" },
+  { field: "duration", flag: "--duration", type: "number" },
+  { field: "provider", flag: "--provider", type: "string" }
+];
+var CreativeResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Generate an AI image for ad creatives using Imagen 4, Flux, or Stable Diffusion. */
+  async generateImage(input) {
+    const args = buildArgsFromMapping(GENERATE_IMAGE_ARG_MAPPING, input);
+    return this.client.runTool("generate_image", args);
+  }
+  /** Generate an AI video ad using Veo, Runway, or Luma. Great for YouTube and social ads. */
+  async generateVideo(input) {
+    const args = buildArgsFromMapping(GENERATE_VIDEO_ARG_MAPPING, input);
+    return this.client.runTool("generate_video_ad", args);
+  }
+};
+
+// src/resources/meta.ts
+var CREATE_META_CAMPAIGN_ARG_MAPPING = [
+  { field: "name", flag: "--name", type: "string", required: true },
+  { field: "objective", flag: "--objective", type: "string", required: true },
+  { field: "daily_budget", flag: "--daily-budget", type: "number", required: true }
+];
+var MetaResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a Meta (Facebook/Instagram) advertising campaign. */
+  async createCampaign(input) {
+    const args = buildArgsFromMapping(CREATE_META_CAMPAIGN_ARG_MAPPING, input);
+    return this.client.runTool("meta_ads_create_campaign", args, "meta");
+  }
+};
+
+// src/resources/linkedin.ts
+var CREATE_LINKEDIN_CAMPAIGN_ARG_MAPPING = [
+  { field: "name", flag: "--name", type: "string", required: true },
+  { field: "objective", flag: "--objective", type: "string", required: true },
+  { field: "daily_budget", flag: "--daily-budget", type: "number", required: true },
+  { field: "target_company_sizes", flag: "--company-size", type: "array" },
+  { field: "target_industries", flag: "--industry", type: "array" },
+  { field: "target_job_functions", flag: "--job-function", type: "array" }
+];
+var LinkedInResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a LinkedIn Ads campaign for B2B advertising. */
+  async createCampaign(input) {
+    const args = buildArgsFromMapping(CREATE_LINKEDIN_CAMPAIGN_ARG_MAPPING, input);
+    return this.client.runTool("linkedin_ads_create_campaign_complete", args, "linkedin");
+  }
+};
+
+// src/resources/reddit.ts
+var CREATE_REDDIT_CAMPAIGN_ARG_MAPPING = [
+  { field: "name", flag: "--name", type: "string", required: true },
+  { field: "objective", flag: "--objective", type: "string", required: true },
+  { field: "daily_budget", flag: "--daily-budget", type: "number", required: true },
+  { field: "subreddits", flag: "--subreddit", type: "array" },
+  { field: "interests", flag: "--interest", type: "array" }
+];
+var RedditResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a Reddit Ads campaign for community-based advertising. */
+  async createCampaign(input) {
+    const args = buildArgsFromMapping(CREATE_REDDIT_CAMPAIGN_ARG_MAPPING, input);
+    return this.client.runTool("reddit_ads_create_campaign", args, "reddit");
+  }
+};
+
+// src/resources/audiences.ts
+var CONSENT_WARNING = "[@synterai/sdk-js] i_have_consent was not provided. Confirm lawful basis under GDPR/CCPA and the destination platform's terms for every identifier before staging or syncing PII, then pass `i_have_consent: true`. (Soft-launch notice \u2014 mirrors the backend's own behavior; this call is not blocked.)";
+var ARTIFACT_ENDPOINT = "https://api.syntermedia.ai/artifacts/audience-sync-input";
+var SYNC_AUDIENCE_SCRIPT_BY_PLATFORM = {
+  google: "google_ads_create_customer_match",
+  meta: "meta_ads_create_audience",
+  linkedin: "linkedin_ads_create_matched_audience",
+  microsoft: "microsoft_ads_create_audience",
+  reddit: "reddit_ads_create_audience",
+  tiktok: "tiktok_ads_create_audience",
+  x: "x_ads_create_audience"
+};
+var MANAGE_AUDIENCE_ARG_MAPPING = [
+  { field: "action", flag: "--action", type: "string", required: true },
+  { field: "name", flag: "--name", type: "string" },
+  { field: "emails", flag: "--emails", type: "string" },
+  { field: "phones", flag: "--phones", type: "string" },
+  { field: "company_domains", flag: "--company-domains", type: "string" },
+  { field: "audience_id", flag: "--audience-id", type: "string" },
+  { field: "membership_lifespan", flag: "--membership-lifespan", type: "number" },
+  { field: "job_resource_name", flag: "--job-resource-name", type: "string" }
+];
+var AudiencesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Stage a hashed-PII payload (newline-delimited identifiers — SHA-256
+   * emails, phones, or raw MAIDs) in Synter's private artifact store and
+   * return an opaque `artifact_id`. Pass that id to `sync()` via
+   * `*_artifact_id` parameters. FREE. Use instead of pasting hashed
+   * identifiers inline when over ~500 entries.
+   *
+   * Bypasses the primary `tools/run` dispatcher: different host
+   * (`https://api.syntermedia.ai`) and a different auth header
+   * (`X-Synter-Key`, not `Authorization: Bearer`) — see SPEC.md/catalog.json
+   * `transport.special`.
+   */
+  async stageArtifact(input) {
+    if (!input?.body) {
+      throw new SynterValidationError("`body` is required.", "body");
+    }
+    if (input.i_have_consent === void 0) {
+      console.warn(CONSENT_WARNING);
+    }
+    const payload = { body: input.body };
+    if (input.script_name !== void 0) payload.script_name = input.script_name;
+    if (input.ttl_seconds !== void 0) payload.ttl_seconds = input.ttl_seconds;
+    if (input.i_have_consent !== void 0) payload.i_have_consent = input.i_have_consent;
+    return this.client.sendAbsolute(ARTIFACT_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "X-Synter-Key": this.client.getApiKey(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+  }
+  /**
+   * Upload an audience to an ad platform. Accepts inline hashed
+   * identifiers, raw mobile_ids, company_domains, a public csv_url, or
+   * `*_artifact_id` references staged via `stageArtifact()`. Costs 10
+   * credits on success.
+   *
+   * Custom handler per catalog.json's `dispatch.argBuildingRules` — does
+   * not go through the generic argMapping path.
+   */
+  async sync(input) {
+    if (!input?.platform) {
+      throw new SynterValidationError("`platform` is required.", "platform");
+    }
+    const scriptName = SYNC_AUDIENCE_SCRIPT_BY_PLATFORM[input.platform];
+    if (!scriptName) {
+      throw new SynterValidationError(
+        `Unsupported platform \`${input.platform}\`. Expected one of: ${Object.keys(SYNC_AUDIENCE_SCRIPT_BY_PLATFORM).join(", ")}.`,
+        "platform"
+      );
+    }
+    const args = [];
+    if (input.audience_name !== void 0) args.push("--name", input.audience_name);
+    if (input.account_id !== void 0) args.push("--account-id", input.account_id);
+    if (input.hashed_emails !== void 0) args.push("--hashed-emails", input.hashed_emails);
+    if (input.hashed_emails_artifact_id !== void 0) {
+      args.push("--hashed-emails-artifact-id", input.hashed_emails_artifact_id);
+    }
+    if (input.hashed_phones !== void 0) args.push("--hashed-phones", input.hashed_phones);
+    if (input.hashed_phones_artifact_id !== void 0) {
+      args.push("--hashed-phones-artifact-id", input.hashed_phones_artifact_id);
+      if (input.platform === "google" || input.platform === "meta") {
+        args.push("--phones-artifact-id", input.hashed_phones_artifact_id);
+      }
+    }
+    if (input.mobile_ids !== void 0) args.push("--mobile-ids", input.mobile_ids);
+    if (input.mobile_ids_artifact_id !== void 0 && input.platform === "meta") {
+      args.push("--mobile-ids-artifact-id", input.mobile_ids_artifact_id);
+    }
+    if (input.company_domains !== void 0) args.push("--company-domains", input.company_domains);
+    if (input.csv_url !== void 0) args.push("--csv-url", input.csv_url);
+    if (input.customer_file_source !== void 0 && input.platform === "meta") {
+      args.push("--customer-file-source", input.customer_file_source);
+    }
+    if (input.platform === "meta") {
+      args.push("--subtype", "CUSTOM");
+    }
+    if (input.i_have_consent === void 0) {
+      console.warn(CONSENT_WARNING);
+    }
+    const body = { script_name: scriptName, args, platform: input.platform };
+    if (input.i_have_consent !== void 0) {
+      body.i_have_consent = input.i_have_consent;
+    }
+    return this.client.request("POST", "/api/v1/tools/run", { body });
+  }
+  /**
+   * Create, upload to, or list first-party audiences in Google Ads via
+   * the Data Manager API. Supports Customer Match lists from emails,
+   * phone numbers, and company domains.
+   */
+  async manage(input) {
+    const args = buildArgsFromMapping(MANAGE_AUDIENCE_ARG_MAPPING, input);
+    return this.client.runTool("google_ads_data_manager", args, "google");
+  }
+};
+
+// src/toolbox/amp-tools.ts
+var AmpToolbox = class {
+  constructor(client, config = {}) {
+    this.client = client;
+    this.config = config;
+    this.config = {
+      aiModel: "gpt-4",
+      autoOptimize: true,
+      optimizeInterval: 24,
+      enableABTesting: true,
+      ...config
+    };
+  }
+  /**
+   * Generate a complete campaign from a brief description
+   * 
+   * @example
+   * ```ts
+   * const campaign = await amp.generateCampaign({
+   *   product: 'AI-powered email marketing platform',
+   *   audience: 'SaaS marketers, 25-45, tech-savvy',
+   *   goals: ['lead-generation', 'brand-awareness'],
+   *   budget: { total: 10000, currency: 'USD' },
+   *   platforms: ['google', 'linkedin'],
+   *   brandVoice: 'professional, innovative, data-driven'
+   * });
+   * ```
+   */
+  async generateCampaign(brief) {
+    const response = await this.client.request("POST", "/amp/generate-campaign", {
+      body: {
+        ...brief,
+        aiModel: this.config.aiModel
+      }
+    });
+    return response;
+  }
+  /**
+   * Generate creative variations for A/B testing
+   * 
+   * @example
+   * ```ts
+   * const variants = await amp.generateCreativeVariants({
+   *   baseCreative: {
+   *     headline: 'Transform Your Email Marketing',
+   *     description: 'AI-powered automation for better results'
+   *   },
+   *   count: 5,
+   *   platform: 'google'
+   * });
+   * ```
+   */
+  async generateCreativeVariants(options) {
+    const response = await this.client.request("POST", "/amp/generate-creatives", {
+      body: {
+        ...options,
+        aiModel: this.config.aiModel
+      }
+    });
+    return response.variants;
+  }
+  /**
+   * Analyze campaign performance and get AI-powered optimization recommendations
+   * 
+   * @example
+   * ```ts
+   * const recommendations = await amp.getOptimizationRecommendations({
+   *   campaignIds: ['cmp_123', 'cmp_456'],
+   *   window: '7d',
+   *   minConfidence: 0.7
+   * });
+   * ```
+   */
+  async getOptimizationRecommendations(options) {
+    const response = await this.client.request(
+      "POST",
+      "/amp/optimize",
+      {
+        body: {
+          ...options,
+          aiModel: this.config.aiModel
+        }
+      }
+    );
+    return response.recommendations;
+  }
+  /**
+   * Auto-optimize campaigns based on performance data
+   * 
+   * @example
+   * ```ts
+   * const result = await amp.autoOptimize({
+   *   campaignIds: ['cmp_123'],
+   *   dryRun: true, // Preview changes first
+   *   optimizationTypes: ['budget', 'bidding']
+   * });
+   * ```
+   */
+  async autoOptimize(options) {
+    const response = await this.client.request("POST", "/amp/auto-optimize", {
+      body: {
+        ...options,
+        aiModel: this.config.aiModel
+      }
+    });
+    return response;
+  }
+  /**
+   * Generate keyword suggestions based on product/service
+   * 
+   * @example
+   * ```ts
+   * const keywords = await amp.generateKeywords({
+   *   product: 'AI email marketing platform',
+   *   audience: 'SaaS marketers',
+   *   count: 50
+   * });
+   * ```
+   */
+  async generateKeywords(options) {
+    return this.client.request("POST", "/amp/generate-keywords", {
+      body: {
+        ...options,
+        count: options.count || 30,
+        aiModel: this.config.aiModel
+      }
+    });
+  }
+  /**
+   * Analyze competitor ads and get insights
+   * 
+   * @example
+   * ```ts
+   * const analysis = await amp.analyzeCompetitors({
+   *   competitors: ['competitor1.com', 'competitor2.com'],
+   *   industry: 'SaaS'
+   * });
+   * ```
+   */
+  async analyzeCompetitors(options) {
+    return this.client.request("POST", "/amp/analyze-competitors", {
+      body: options
+    });
+  }
+  /**
+   * Create an A/B test for campaign creatives
+   * 
+   * @example
+   * ```ts
+   * const test = await amp.createABTest({
+   *   campaignId: 'cmp_123',
+   *   variants: [
+   *     { headline: 'Version A', description: 'Test A' },
+   *     { headline: 'Version B', description: 'Test B' }
+   *   ],
+   *   trafficSplit: [50, 50],
+   *   duration: '7d'
+   * });
+   * ```
+   */
+  async createABTest(options) {
+    return this.client.request("POST", "/amp/ab-test", {
+      body: options
+    });
+  }
+  /**
+   * Get A/B test results and winner
+   * 
+   * @example
+   * ```ts
+   * const results = await amp.getABTestResults('test_123');
+   * ```
+   */
+  async getABTestResults(testId) {
+    return this.client.request("GET", `/amp/ab-test/${testId}`);
+  }
+  /**
+   * Generate audience personas based on campaign data
+   * 
+   * @example
+   * ```ts
+   * const personas = await amp.generatePersonas({
+   *   campaignIds: ['cmp_123'],
+   *   count: 3
+   * });
+   * ```
+   */
+  async generatePersonas(options) {
+    return this.client.request("POST", "/amp/generate-personas", {
+      body: {
+        ...options,
+        count: options.count || 3
+      }
+    });
+  }
+  /**
+   * Predict campaign performance before launch
+   * 
+   * @example
+   * ```ts
+   * const prediction = await amp.predictPerformance({
+   *   platform: 'google',
+   *   budget: { daily: 100, total: 3000 },
+   *   targeting: { keywords: ['email marketing', 'automation'] },
+   *   creative: { headline: 'Transform Your Email Marketing' }
+   * });
+   * ```
+   */
+  async predictPerformance(options) {
+    return this.client.request("POST", "/amp/predict-performance", {
+      body: options
+    });
+  }
+  /**
+   * Get intelligent budget allocation across platforms
+   * 
+   * @example
+   * ```ts
+   * const allocation = await amp.optimizeBudgetAllocation({
+   *   totalBudget: 10000,
+   *   platforms: ['google', 'linkedin', 'reddit'],
+   *   goal: 'conversions'
+   * });
+   * ```
+   */
+  async optimizeBudgetAllocation(options) {
+    return this.client.request("POST", "/amp/optimize-budget", {
+      body: options
+    });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://syntermedia.ai";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var RETRY_BASE_MS = 1e3;
+var RETRY_CAP_MS = 1e4;
+function backoffMs(attempt) {
+  return Math.min(RETRY_BASE_MS * 2 ** attempt, RETRY_CAP_MS);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var Synter = class {
+  constructor(config, ampConfig) {
+    const fullConfig = typeof config === "string" ? { apiKey: config } : config;
+    if (!fullConfig?.apiKey) {
+      throw new SynterValidationError("`apiKey` is required to construct a Synter client.", "apiKey");
+    }
+    this.apiKey = fullConfig.apiKey;
+    this.baseUrl = fullConfig.baseUrl ?? DEFAULT_BASE_URL;
+    this.timeout = fullConfig.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = fullConfig.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.fetchImpl = fullConfig.fetch ?? globalThis.fetch.bind(globalThis);
+    this.campaigns = new CampaignsResource(this);
+    this.analytics = new AnalyticsResource(this);
+    this.keywords = new KeywordsResource(this);
+    this.conversions = new ConversionsResource(this);
+    this.creative = new CreativeResource(this);
+    this.meta = new MetaResource(this);
+    this.linkedin = new LinkedInResource(this);
+    this.reddit = new RedditResource(this);
+    this.audiences = new AudiencesResource(this);
+    this.amp = new AmpToolbox(this, ampConfig);
+  }
+  // ---------------------------------------------------------------------
+  // Primary dispatcher: POST /api/v1/tools/run
+  // ---------------------------------------------------------------------
+  /**
+   * Low-level dispatcher used by every typed resource method. Not usually
+   * called directly by SDK consumers — use `execute()` for the public
+   * escape hatch, or a typed resource method for everything else.
+   */
+  async runTool(scriptName, args = [], platform) {
+    const body = { script_name: scriptName, args };
+    if (platform !== void 0) {
+      body.platform = platform;
+    }
+    return this.sendWithRetry(`${this.baseUrl}/api/v1/tools/run`, {
+      method: "POST",
+      headers: this.authHeaders(),
+      body: JSON.stringify(body)
+    });
+  }
+  /**
+   * Universal escape hatch mirroring the `run_tool` catalog tool: run any
+   * of the 140+ backend scripts by name. `args` is an idiomatic flag-name
+   * map (not a raw CLI string array) — converted internally the same way
+   * every other typed method builds its wire args.
+   */
+  async execute(scriptName, args = {}, platform) {
+    if (!scriptName) {
+      throw new SynterValidationError("`scriptName` is required.", "script_name");
+    }
+    return this.runTool(scriptName, flattenArgsToFlags(args), platform);
+  }
+  // ---------------------------------------------------------------------
+  // `utility` category — per SPEC.md's naming table these live at the
+  // top level of the client, not under a nested namespace.
+  // ---------------------------------------------------------------------
+  /** List all connected ad accounts across platforms. */
+  async listAdAccounts() {
+    return this.runTool("google_ads_list_customers", [], "google");
+  }
+  /**
+   * Upload an image as an asset for use in ads.
+   *
+   * KNOWN ISSUE (SPEC.md "Known issues" #2): live dispatch hardcodes
+   * `platform=google` regardless of `input.platform`. Preserved verbatim.
+   */
+  async uploadImage(input) {
+    if (!input?.image_url) {
+      throw new SynterValidationError("`image_url` is required.", "image_url");
+    }
+    if (!input?.asset_name) {
+      throw new SynterValidationError("`asset_name` is required.", "asset_name");
+    }
+    const args = ["--image-url", input.image_url, "--asset-name", input.asset_name];
+    return this.runTool("google_ads_upload_image_asset", args, "google");
+  }
+  /**
+   * List all landing pages for the authenticated workspace.
+   *
+   * Bypasses the primary `tools/run` dispatcher — special endpoint per
+   * SPEC.md/catalog.json `transport.special`: `GET /api/v1/landing-pages`.
+   */
+  async listLandingPages() {
+    return this.sendWithRetry(`${this.baseUrl}/api/v1/landing-pages`, {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+  }
+  // ---------------------------------------------------------------------
+  // Internals used by resource classes and AmpToolbox
+  // ---------------------------------------------------------------------
+  authHeaders() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /** The raw API key, for the small number of tools that need a non-Bearer header (e.g. `stage_audience_artifact`). */
+  getApiKey() {
+    return this.apiKey;
+  }
+  /**
+   * Low-level generic HTTP helper retained for `AmpToolbox` and any other
+   * advanced/internal callers that need to hit an arbitrary path relative
+   * to the configured base URL, with the same retry/timeout/error
+   * semantics as the primary dispatcher.
+   */
+  async request(method, path, options = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return this.sendWithRetry(url.toString(), {
+      method,
+      headers: { ...this.authHeaders(), ...options.headers },
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+  }
+  /**
+   * Sends a request to an arbitrary absolute URL with arbitrary headers —
+   * used by the two special-endpoint tools (`list_landing_pages` uses
+   * `request`/`runTool` against the default base URL; `stage_audience_artifact`
+   * needs a different host and a different auth header entirely).
+   */
+  async sendAbsolute(url, init) {
+    return this.sendWithRetry(url, init);
+  }
+  /**
+   * Core transport: timeout + retry policy from SPEC.md — up to 3 retries,
+   * exponential backoff (1s base, 10s cap), retrying only 429 (honoring
+   * `Retry-After`) and network/timeout errors. Never retries other 4xx
+   * (or 5xx — not listed in SPEC.md's `retryOn`).
+   */
+  async sendWithRetry(url, init) {
+    let attempt = 0;
+    for (; ; ) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      let response;
+      try {
+        response = await this.fetchImpl(url, { ...init, signal: controller.signal });
+      } catch (err) {
+        clearTimeout(timer);
+        if (attempt >= this.maxRetries) {
+          const message = err instanceof Error ? err.message : "Network request failed.";
+          throw new SynterError(message, 0, null, null);
+        }
+        await sleep(backoffMs(attempt));
+        attempt += 1;
+        continue;
+      }
+      clearTimeout(timer);
+      if (response.status === 429) {
+        if (attempt >= this.maxRetries) {
+          throw await this.toSynterError(response);
+        }
+        const retryAfterHeader = response.headers.get("Retry-After");
+        const retryAfterSeconds = retryAfterHeader !== null ? Number(retryAfterHeader) : NaN;
+        const delayMs = Number.isFinite(retryAfterSeconds) ? Math.max(0, retryAfterSeconds) * 1e3 : backoffMs(attempt);
+        await sleep(delayMs);
+        attempt += 1;
+        continue;
+      }
+      if (!response.ok) {
+        throw await this.toSynterError(response);
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      return await response.json();
+    }
+  }
+  async toSynterError(response) {
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const record = (body && typeof body === "object" ? body : {}) ?? {};
+    const message = typeof record.error === "string" && record.error || typeof record.message === "string" && record.message || response.statusText || "Request failed.";
+    const code = typeof record.code === "string" ? record.code : null;
+    const details = record.details && typeof record.details === "object" ? record.details : null;
+    return new SynterError(message, response.status, code, details);
+  }
+};
+
+// src/utils/utm.ts
+var PLATFORM_MACROS = {
+  google: {
+    "{{campaign_id}}": "{campaignid}",
+    "{{adgroup_id}}": "{adgroupid}",
+    "{{ad_id}}": "{creative}",
+    "{{keyword}}": "{keyword}",
+    "{{match_type}}": "{matchtype}",
+    "{{network}}": "{network}",
+    "{{device}}": "{device}",
+    "{{placement}}": "{placement}"
+  },
+  reddit: {
+    "{{campaign_id}}": "{{campaign_id}}",
+    "{{adgroup_id}}": "{{adgroup_id}}",
+    "{{ad_id}}": "{{ad_id}}"
+  },
+  x: {
+    "{{campaign_id}}": "{campaign_id}",
+    "{{line_item_id}}": "{line_item_id}",
+    "{{creative_id}}": "{creative_id}"
+  }
+};
+function buildUTMParameters(template, platform) {
+  const macros = PLATFORM_MACROS[platform];
+  const replaceTemplateVars = (value) => {
+    if (!value) return value;
+    let result = value;
+    for (const [templateVar, platformMacro] of Object.entries(macros)) {
+      result = result.replace(new RegExp(templateVar, "g"), platformMacro);
+    }
+    return result;
+  };
+  return {
+    source: replaceTemplateVars(template.source) || platform,
+    medium: replaceTemplateVars(template.medium) || "cpc",
+    campaign: replaceTemplateVars(template.campaign) || "",
+    content: replaceTemplateVars(template.content),
+    term: replaceTemplateVars(template.term)
+  };
+}
+function buildTrackingURL(baseUrl, utmParams) {
+  const url = new URL(baseUrl);
+  url.searchParams.set("utm_source", utmParams.source);
+  url.searchParams.set("utm_medium", utmParams.medium);
+  url.searchParams.set("utm_campaign", utmParams.campaign);
+  if (utmParams.content) {
+    url.searchParams.set("utm_content", utmParams.content);
+  }
+  if (utmParams.term) {
+    url.searchParams.set("utm_term", utmParams.term);
+  }
+  return url.toString();
+}
+function extractUTMParameters(url) {
+  const urlObj = new URL(url);
+  return {
+    source: urlObj.searchParams.get("utm_source") || void 0,
+    medium: urlObj.searchParams.get("utm_medium") || void 0,
+    campaign: urlObj.searchParams.get("utm_campaign") || void 0,
+    content: urlObj.searchParams.get("utm_content") || void 0,
+    term: urlObj.searchParams.get("utm_term") || void 0
+  };
+}
+function validateUTMTemplate(template) {
+  const errors = [];
+  if (!template.source) {
+    errors.push("utm_source is required");
+  }
+  if (!template.medium) {
+    errors.push("utm_medium is required");
+  }
+  if (!template.campaign) {
+    errors.push("utm_campaign is required");
+  }
+  const invalidChars = /[^a-zA-Z0-9\-_.{}]/;
+  Object.entries(template).forEach(([key, value]) => {
+    if (value && invalidChars.test(value)) {
+      errors.push(`${key} contains invalid characters (use only alphanumeric, -, _, ., {})`);
+    }
+  });
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function generateDefaultUTMTemplate(platform, campaignName) {
+  const sanitizedName = campaignName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return {
+    source: platform,
+    medium: "cpc",
+    campaign: sanitizedName,
+    content: "{{ad_id}}",
+    term: platform === "google" ? "{{keyword}}" : void 0
+  };
+}
+
+// src/utils/conversion-tracking.ts
+var CLICK_ID_PARAMS = {
+  google: ["gclid", "wbraid", "gbraid"],
+  reddit: ["rdt_cid"],
+  x: ["twclid"]
+};
+function detectClickId(urlOrParams) {
+  let params;
+  if (typeof urlOrParams === "string") {
+    try {
+      const url = new URL(urlOrParams);
+      params = Object.fromEntries(url.searchParams.entries());
+    } catch {
+      return { platform: null, clickId: null, paramName: null };
+    }
+  } else {
+    params = urlOrParams;
+  }
+  for (const [platform, paramNames] of Object.entries(CLICK_ID_PARAMS)) {
+    for (const paramName of paramNames) {
+      const clickId = params[paramName];
+      if (clickId) {
+        return {
+          platform,
+          clickId,
+          paramName
+        };
+      }
+    }
+  }
+  return { platform: null, clickId: null, paramName: null };
+}
+function extractTrackingParams(url, referrer) {
+  const urlObj = new URL(url);
+  const params = Object.fromEntries(urlObj.searchParams.entries());
+  const clickIds = {};
+  for (const [platform, paramNames] of Object.entries(CLICK_ID_PARAMS)) {
+    for (const paramName of paramNames) {
+      if (params[paramName]) {
+        clickIds[platform] = params[paramName];
+        break;
+      }
+    }
+  }
+  return {
+    clickIds,
+    utm: {
+      source: params.utm_source,
+      medium: params.utm_medium,
+      campaign: params.utm_campaign,
+      content: params.utm_content,
+      term: params.utm_term
+    },
+    referrer
+  };
+}
+function validateClickId(platform, clickId) {
+  switch (platform) {
+    case "google":
+      return /^[a-zA-Z0-9\-_]+$/.test(clickId);
+    case "reddit":
+      return /^t3_[a-z0-9]+$/i.test(clickId) || /^[a-zA-Z0-9\-_]+$/.test(clickId);
+    case "x":
+      return /^[a-zA-Z0-9\-_]+$/.test(clickId);
+    default:
+      return false;
+  }
+}
+function buildConversionPayload(params) {
+  return {
+    platform: params.platform,
+    clickId: params.clickId,
+    conversionName: params.event,
+    conversionTime: params.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    value: params.value,
+    currency: params.currency || "USD",
+    orderId: params.orderId
+  };
+}
+var EVENT_NAME_MAP = {
+  purchase: {
+    google: "purchase",
+    reddit: "Purchase",
+    x: "tw-purchase"
+  },
+  signup: {
+    google: "sign_up",
+    reddit: "SignUp",
+    x: "tw-signup"
+  },
+  "add-to-cart": {
+    google: "add_to_cart",
+    reddit: "AddToCart",
+    x: "tw-add-to-cart"
+  },
+  "page-view": {
+    google: "page_view",
+    reddit: "PageVisit",
+    x: "tw-page-view"
+  }
+};
+function normalizeEventName(eventName, platform) {
+  const normalized = EVENT_NAME_MAP[eventName.toLowerCase()];
+  return normalized?.[platform] || eventName;
+}
+
+// src/utils/analytics-integrations.ts
+var PostHogAdapter = class {
+  constructor(apiKey, host = "https://app.posthog.com") {
+    this.apiKey = apiKey;
+    this.host = host;
+  }
+  async track(event) {
+    const payload = {
+      api_key: this.apiKey,
+      event: event.event,
+      properties: event.properties,
+      timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      distinct_id: event.userId || event.anonymousId
+    };
+    await fetch(`${this.host}/capture/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+  async identify(userId, traits) {
+    const payload = {
+      api_key: this.apiKey,
+      event: "$identify",
+      distinct_id: userId,
+      properties: {
+        $set: traits
+      }
+    };
+    await fetch(`${this.host}/capture/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+};
+var HeapAdapter = class {
+  constructor(appId) {
+    this.appId = appId;
+  }
+  async track(event) {
+    const payload = {
+      app_id: this.appId,
+      identity: event.userId || event.anonymousId,
+      event: event.event,
+      properties: event.properties,
+      timestamp: event.timestamp
+    };
+    await fetch("https://heapanalytics.com/api/track", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+  async identify(userId, traits) {
+    const payload = {
+      app_id: this.appId,
+      identity: userId,
+      properties: traits
+    };
+    await fetch("https://heapanalytics.com/api/add_user_properties", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+};
+var MixpanelAdapter = class {
+  constructor(token) {
+    this.token = token;
+  }
+  async track(event) {
+    const payload = {
+      event: event.event,
+      properties: {
+        ...event.properties,
+        token: this.token,
+        distinct_id: event.userId || event.anonymousId,
+        time: event.timestamp ? new Date(event.timestamp).getTime() : Date.now()
+      }
+    };
+    const data = Buffer.from(JSON.stringify(payload)).toString("base64");
+    await fetch(`https://api.mixpanel.com/track?data=${data}`, {
+      method: "GET"
+    });
+  }
+  async identify(userId, traits) {
+    const payload = {
+      $token: this.token,
+      $distinct_id: userId,
+      $set: traits
+    };
+    const data = Buffer.from(JSON.stringify(payload)).toString("base64");
+    await fetch(`https://api.mixpanel.com/engage?data=${data}`, {
+      method: "GET"
+    });
+  }
+};
+var AnalyticsIntegrationManager = class {
+  constructor(integrations) {
+    this.adapters = /* @__PURE__ */ new Map();
+    integrations.forEach((integration) => {
+      if (!integration.enabled) return;
+      let adapter;
+      switch (integration.platform) {
+        case "posthog":
+          adapter = new PostHogAdapter(integration.apiKey);
+          break;
+        case "heap":
+          adapter = new HeapAdapter(integration.apiKey);
+          break;
+        case "mixpanel":
+          adapter = new MixpanelAdapter(integration.apiKey);
+          break;
+        default:
+          throw new Error(`Unsupported analytics platform: ${integration.platform}`);
+      }
+      this.adapters.set(integration.platform, adapter);
+    });
+  }
+  /**
+   * Track event across all enabled integrations
+   */
+  async track(event) {
+    const promises = Array.from(this.adapters.values()).map(
+      (adapter) => adapter.track(event).catch((error) => {
+        console.error("Analytics tracking error:", error);
+      })
+    );
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Track event to specific platform
+   */
+  async trackTo(platform, event) {
+    const adapter = this.adapters.get(platform);
+    if (!adapter) {
+      throw new Error(`Analytics platform not configured: ${platform}`);
+    }
+    await adapter.track(event);
+  }
+  /**
+   * Identify user across all enabled integrations
+   */
+  async identify(userId, traits) {
+    const promises = Array.from(this.adapters.values()).map(
+      (adapter) => adapter.identify(userId, traits).catch((error) => {
+        console.error("Analytics identify error:", error);
+      })
+    );
+    await Promise.allSettled(promises);
+  }
+};
+function normalizeAdClickEvent(trackingParams) {
+  return {
+    event: "ad_click",
+    properties: {
+      // Platform click IDs
+      ...Object.entries(trackingParams.clickIds || {}).reduce((acc, [platform, clickId]) => {
+        acc[`${platform}_click_id`] = clickId;
+        return acc;
+      }, {}),
+      // UTM parameters
+      utm_source: trackingParams.utm?.source,
+      utm_medium: trackingParams.utm?.medium,
+      utm_campaign: trackingParams.utm?.campaign,
+      utm_content: trackingParams.utm?.content,
+      utm_term: trackingParams.utm?.term,
+      // Referrer
+      referrer: trackingParams.referrer,
+      // Metadata
+      tracking_type: "paid_ad"
+    }
+  };
+}
+function normalizeConversionEvent(params) {
+  return {
+    event: params.event,
+    properties: {
+      value: params.value,
+      currency: params.currency || "USD",
+      platform: params.platform,
+      campaign_id: params.campaignId,
+      conversion_type: "paid_ad",
+      ...params.metadata
+    }
+  };
+}
+export {
+  AmpToolbox,
+  AnalyticsIntegrationManager,
+  AnalyticsResource,
+  AudiencesResource,
+  CampaignsResource,
+  ConversionsResource,
+  CreativeResource,
+  DEFAULT_BASE_URL,
+  KeywordsResource,
+  LinkedInResource,
+  MetaResource,
+  RedditResource,
+  Synter,
+  SynterError,
+  SynterValidationError,
+  buildConversionPayload,
+  buildTrackingURL,
+  buildUTMParameters,
+  Synter as default,
+  detectClickId,
+  extractTrackingParams,
+  extractUTMParameters,
+  generateDefaultUTMTemplate,
+  normalizeAdClickEvent,
+  normalizeConversionEvent,
+  normalizeEventName,
+  validateClickId,
+  validateUTMTemplate
+};