@koda-sl/baker-cli 0.467.0 → 0.468.0

package/dist/follow-BB5KUEXZ.js

@@ -0,0 +1,94 @@
+import {
+  PLATFORM_NAMES,
+  reportError
+} from "./chunk-ICJFL7DU.js";
+import {
+  apiPost
+} from "./chunk-MMOTJIV6.js";
+import "./chunk-2ZZR2SOF.js";
+import "./chunk-YPCVPDU7.js";
+import {
+  brandAccountInput,
+  registerSchema,
+  writeJson
+} from "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/follow.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.follow",
+  description: "Follow a brand so ALL its ads join your library \u2014 every platform (Meta, LinkedIn, TikTok, Google Ads), every account it runs there (one Facebook page per market, each Google entity) and every country. Paste whatever you have: a website (best \u2014 finds every account it links), a brand name, or any profile / ad-library link. Already-in-corpus brands are subscribed instantly; new brands are queued for ingestion. Accounts only named like the brand come back as `suggestions` with a ready `add-accounts` command.",
+  args: {
+    input: {
+      type: "string",
+      description: "Website (best), brand name, or any profile/ad-library link",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label (defaults to the resolved name)", required: false }
+  }
+});
+function followHints(data) {
+  const hints = [];
+  if (data.status === "added") {
+    hints.push(
+      "This brand is new \u2014 we're adding every ad we can find across all platforms and countries. They appear as ingestion completes; check `baker winning-ads following`."
+    );
+  } else if (data.status === "ambiguous") {
+    hints.push(
+      "Multiple brands matched. Pick one from `candidates` and re-run `follow` with its exact website or link."
+    );
+  }
+  const suggestions = data.suggestions ?? [];
+  const names = suggestions.map((s) => `${s.name} (${PLATFORM_NAMES[s.platform]})`).join(", ");
+  if (data.status === "unconfirmed") {
+    const [first] = suggestions;
+    hints.push(
+      `Nothing followed yet: we found no account we're sure is this brand's, only accounts named like it: ${names}. Follow the brand's own with its link, e.g. baker winning-ads follow "${first ? brandAccountInput(first) : ""}", then add its other markets' accounts with \`add-accounts\`. Or retry with the brand's website.`
+    );
+    return hints;
+  }
+  if (data.advertiser && suggestions.length > 0) {
+    const inputs = suggestions.map(brandAccountInput).join(",");
+    hints.push(
+      `Also found accounts named like this brand, not tracked yet: ${names}. If they are the same brand (another country or language), track them with: baker winning-ads add-accounts ${data.advertiser.advertiser_id} "${inputs}" \u2014 drop any that belong to someone else.`
+    );
+  }
+  return hints.length > 0 ? hints : void 0;
+}
+var followCommand = defineCommand({
+  meta: {
+    name: "follow",
+    description: 'Follow a brand to track ALL its ads \u2014 every platform, every account and country. Paste a website (best), a brand name, or any profile/ad-library link. Example: baker winning-ads follow "barkibu.com"'
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Website (best), brand name, or any profile/ad-library link",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label", required: false },
+    platform: {
+      type: "string",
+      description: "Ignored \u2014 every platform is searched. Kept so older commands still run.",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { input: String(args.input) };
+      if (args.label) {
+        body.label = String(args.label);
+      }
+      const data = await apiPost("/api/ad-library/follow", body);
+      writeJson({ ok: true, data, hints: followHints(data) });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  followCommand,
+  followHints
+};
+//# sourceMappingURL=follow-BB5KUEXZ.js.map

package/dist/follow-competitors-EURYGGXE.js

@@ -0,0 +1,112 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-ICJFL7DU.js";
+import {
+  apiPost
+} from "./chunk-MMOTJIV6.js";
+import "./chunk-2ZZR2SOF.js";
+import "./chunk-YPCVPDU7.js";
+import {
+  FOLLOW_BATCH_MAX,
+  registerSchema,
+  writeJson
+} from "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/follow-competitors.ts
+import { defineCommand } from "citty";
+var BATCH_TIMEOUT_MS = 3e5;
+function buildFollowBatchBody(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const inputs = [];
+  for (const domain of splitList(input.domains)) {
+    const key = domain.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    inputs.push(domain);
+  }
+  return { inputs };
+}
+registerSchema({
+  command: "winning-ads.follow-competitors",
+  description: "Follow MANY brands at once \u2014 the fast way to add every competitor to your library. Pass a comma-separated list of domains (best \u2014 each resolves every platform and every account we can find, every country). One brand failing never blocks the others: the response reports per-brand status (following/added/ambiguous/failed) plus rollup counts. Ideal right after a competitor scan.",
+  args: {
+    domains: {
+      type: "string",
+      description: `Comma-separated domains (best), profile/ad-library URLs, or brand names \u2014 up to ${FOLLOW_BATCH_MAX}. e.g. "deel.com,notion.so,hubspot.com"`,
+      required: true
+    }
+  }
+});
+var followCompetitorsCommand = defineCommand({
+  meta: {
+    name: "follow-competitors",
+    description: 'Follow many brands at once by domain \u2014 add every competitor in one call. Example: baker winning-ads follow-competitors "deel.com,notion.so,hubspot.com"'
+  },
+  args: {
+    domains: {
+      type: "positional",
+      description: "Comma-separated domains (best), URLs, or brand names",
+      required: true
+    },
+    platform: {
+      type: "string",
+      description: "Ignored \u2014 every platform is searched. Kept so older commands still run.",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = buildFollowBatchBody({ domains: String(args.domains ?? "") });
+      if (body.inputs.length === 0) {
+        writeJson({
+          ok: false,
+          error: { code: "VALIDATION_ERROR", message: "Pass at least one domain in --domains." }
+        });
+        process.exit(1);
+      }
+      if (body.inputs.length > FOLLOW_BATCH_MAX) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: `Too many brands (${body.inputs.length}). Follow at most ${FOLLOW_BATCH_MAX} per call.`
+          }
+        });
+        process.exit(1);
+      }
+      const data = await apiPost("/api/ad-library/follow-batch", body, {
+        timeoutMs: BATCH_TIMEOUT_MS
+      });
+      const hints = [];
+      if (data.failed_count > 0) {
+        const failed = data.results.filter((r) => r.status === "failed").map((r) => r.input);
+        hints.push(
+          `${data.failed_count} brand(s) couldn't be added: ${failed.join(", ")}. Retry each with its website or Facebook/LinkedIn URL via \`baker winning-ads follow\`.`
+        );
+      }
+      if (data.ambiguous_count > 0) {
+        const ambiguous = data.results.filter((r) => r.status === "ambiguous").map((r) => r.input);
+        hints.push(
+          `${data.ambiguous_count} brand(s) matched multiple advertisers: ${ambiguous.join(", ")}. Re-run \`baker winning-ads follow\` with an exact domain/URL to pick one.`
+        );
+      }
+      if (data.added_count > 0) {
+        hints.push(
+          "Newly added brands are ingesting now \u2014 their winners fill in over the next few minutes. Check `baker winning-ads following` or `baker winning-ads feed`."
+        );
+      }
+      writeJson({ ok: true, data, hints: hints.length > 0 ? hints : void 0 });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  buildFollowBatchBody,
+  followCompetitorsCommand
+};
+//# sourceMappingURL=follow-competitors-EURYGGXE.js.map

package/dist/following-CA5BQXYB.js

@@ -0,0 +1,113 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-ICJFL7DU.js";
+import {
+  apiGet
+} from "./chunk-MMOTJIV6.js";
+import "./chunk-2ZZR2SOF.js";
+import "./chunk-YPCVPDU7.js";
+import {
+  applyFieldMask,
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/following.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.following",
+  description: "List the brands you follow in your ad-dna library, with each one's status (ready vs still adding) and cached ad counts. A brand still adding has counts that are a lie in progress; one with `discovery_failed` has counts that are short because we couldn't finish looking, which is not the same as it running no ads.",
+  args: {}
+});
+function displayStatus(status) {
+  return status === "ready" ? "ready" : "adding\u2026";
+}
+function compactFollowed(record) {
+  return {
+    followed_id: String(record.followed_id ?? ""),
+    advertiser_id: String(record.advertiser_id ?? ""),
+    label: String(record.label ?? ""),
+    status: displayStatus(record.status),
+    active_ad_count: record.active_ad_count ?? null,
+    total_ad_count: record.total_ad_count ?? null,
+    family_count: record.family_count ?? null,
+    adding_discovered: record.adding_discovered ?? null,
+    adding_enqueued: record.adding_enqueued ?? null,
+    adding_ingested: record.adding_ingested ?? null,
+    // Without this a brand we failed to finish looking at is indistinguishable
+    // from one that genuinely runs no ads — both read `ready` with 0 ads.
+    discovery_failed: record.discovery_failed ?? null
+  };
+}
+function followingHints(records) {
+  const hints = [];
+  const label = (r) => String(r.label ?? r.advertiser_id ?? "");
+  const incomplete = records.filter((r) => r.discovery_failed === true && r.status !== "adding\u2026");
+  if (incomplete.length > 0) {
+    hints.push(
+      `${incomplete.length} brand(s) couldn't be fully added: ${incomplete.map(label).join(", ")}. Their counts are incomplete \u2014 re-run \`baker winning-ads follow <domain>\` for each to try again.`
+    );
+  }
+  const adding = records.filter((r) => r.status === "adding\u2026");
+  if (adding.length > 0) {
+    hints.push(
+      `${adding.length} brand(s) are still being added: ${adding.map(label).join(", ")}. Their ad counts fill in over the next few minutes \u2014 don't report them as final, and don't re-follow to speed it up.`
+    );
+  }
+  return hints;
+}
+function followingNormalizer(record, full) {
+  const compact = compactFollowed(record);
+  if (!full) {
+    return compact;
+  }
+  return {
+    ...compact,
+    image_url: record.image_url ?? null,
+    platforms: Array.isArray(record.platforms) ? record.platforms : []
+  };
+}
+var followingCommand = defineCommand({
+  meta: {
+    name: "following",
+    description: "List brands you follow, with status (ready / adding\u2026) and cached counts. A brand's counts are only final once it is ready. Example: baker winning-ads following --output md"
+  },
+  args: {
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include image + platforms", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ad-library/following");
+      const output = args.output || "json";
+      const full = args.full;
+      const rawList = Array.isArray(data?.following) ? data.following : [];
+      const following = rawList.map((f) => followingNormalizer(f, full));
+      const hints = followingHints(following);
+      if (output === "json") {
+        const fields = splitList(args.fields);
+        const rows = fields.length > 0 ? following.map((f) => applyFieldMask(f, fields)) : following;
+        writeJson({ ok: true, data: { following: rows }, hints: hints.length > 0 ? hints : void 0 });
+        return;
+      }
+      writeOutput(
+        { ok: true, data: rawList, hints: hints.length > 0 ? hints : void 0 },
+        output,
+        args.fields ? args.fields.split(",") : void 0,
+        full,
+        followingNormalizer
+      );
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  followingCommand,
+  followingHints
+};
+//# sourceMappingURL=following-CA5BQXYB.js.map

package/dist/fonts-KV3BZCYB.js

@@ -0,0 +1,34 @@
+import {
+  fetchJson,
+  fontsAdoptCommand,
+  fontsCheckCommand,
+  fontsCommand,
+  fontsFetchCommand,
+  lookupGoogleCss
+} from "./chunk-HNUY47SD.js";
+import "./chunk-VHDJCYPD.js";
+import "./chunk-AVOIIRTG.js";
+import "./chunk-JF5LNI6O.js";
+import "./chunk-F3IVR3V3.js";
+import "./chunk-4KBWL7S4.js";
+import "./chunk-DJPCTTUN.js";
+import "./chunk-BJEW3LST.js";
+import "./chunk-SSVZM3P6.js";
+import "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-2ZZR2SOF.js";
+import "./chunk-YPCVPDU7.js";
+import "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  fetchJson,
+  fontsAdoptCommand,
+  fontsCheckCommand,
+  fontsCommand,
+  fontsFetchCommand,
+  lookupGoogleCss
+};
+//# sourceMappingURL=fonts-KV3BZCYB.js.map

package/dist/forecast-L44QIHCC.js

@@ -0,0 +1,168 @@
+import {
+  exitWithServiceReadError
+} from "./chunk-CLK2FPAV.js";
+import {
+  failWriteValidation,
+  keywordEntries,
+  microsFlag,
+  requireCustomerId
+} from "./chunk-PKCD5FX5.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-536R4RRM.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-YTWNY3RF.js";
+import {
+  googleKeywordForecastRequestSchema
+} from "./chunk-7VHPAGPK.js";
+import {
+  getManagerIdForCustomer,
+  writeJsonEnvelope
+} from "./chunk-6SL6463H.js";
+import "./chunk-JF5LNI6O.js";
+import "./chunk-F3IVR3V3.js";
+import "./chunk-LFGCOAB4.js";
+import "./chunk-DJPCTTUN.js";
+import "./chunk-BJEW3LST.js";
+import "./chunk-SSVZM3P6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-MMOTJIV6.js";
+import "./chunk-2ZZR2SOF.js";
+import "./chunk-YPCVPDU7.js";
+import {
+  registerSchema
+} from "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/keywords/forecast.ts
+import { defineCommand } from "citty";
+var ARGS = {
+  "customer-id": { type: "string", description: "Google Ads customer ID (10 digits, no dashes)" },
+  text: {
+    type: "string",
+    description: 'Keywords to forecast, comma-separated, optional ":MATCH_TYPE" suffix each (e.g. "solar panels:PHRASE,placas solares")'
+  },
+  file: { type: "string", description: "Text file with one keyword[:MATCH_TYPE] per line" },
+  "match-type": { type: "string", description: "Default match type: EXACT | PHRASE | BROAD" },
+  "max-cpc": {
+    type: "string",
+    description: "Max CPC bid in major currency units \u2014 Manual CPC (or the ceiling under Maximize clicks)"
+  },
+  "daily-spend": {
+    type: "string",
+    description: "Daily spend in major currency units \u2014 Maximize clicks / Maximize conversions (or the daily budget under Manual CPC)"
+  },
+  strategy: {
+    type: "string",
+    description: "MANUAL_CPC | MAXIMIZE_CLICKS | MAXIMIZE_CONVERSIONS (default: MANUAL_CPC with --max-cpc alone, else MAXIMIZE_CLICKS)"
+  },
+  location: { type: "string", description: "Geo target id(s), comma-separated (see `keywords locations`)" },
+  language: { type: "string", description: "Language id (see `keywords languages`)" },
+  start: {
+    type: "string",
+    description: "First day forecast, YYYY-MM-DD (future). With --end; default: the 30 days from tomorrow"
+  },
+  end: { type: "string", description: "Last day forecast, YYYY-MM-DD (within a year)" },
+  currency: { type: "string", description: "Currency for the money figures (default: the account's)" }
+};
+registerSchema({
+  command: "ads.google.keywords.forecast",
+  description: 'Forecast clicks, cost, conversions and average CPC / CPA for a set of keywords under one bidding strategy, over a period (Keyword Planner, v25). Start here: `baker ads google keywords forecast --customer-id 1234567890 --text "solar panels:PHRASE,placas solares:EXACT" --max-cpc 1.5 --location 2724 --language 1003`. Returns { source: "keyword_planner_forecast", period, forecast_* } \u2014 Google\'s prediction for the whole period, never an account result.',
+  args: Object.fromEntries(
+    Object.entries(ARGS).map(([name, arg]) => [
+      name,
+      { type: arg.type, description: arg.description, required: false }
+    ])
+  )
+});
+function amount(args, flag) {
+  return args[flag] === void 0 ? void 0 : microsFlag(args[flag], `--${flag}`);
+}
+function namedStrategy(args, maxCpc, spend) {
+  if (typeof args.strategy === "string") return args.strategy.toUpperCase();
+  return maxCpc !== void 0 && spend === void 0 ? "MANUAL_CPC" : "MAXIMIZE_CLICKS";
+}
+function forecastBidding(args) {
+  const maxCpc = amount(args, "max-cpc");
+  const spend = amount(args, "daily-spend");
+  const strategy = namedStrategy(args, maxCpc, spend);
+  if (strategy === "MANUAL_CPC") {
+    if (maxCpc === void 0) return { ok: false, message: "Manual CPC needs --max-cpc" };
+    return { ok: true, bidding: { strategy, maxCpcBidMicros: maxCpc, ...spend ? { dailyBudgetMicros: spend } : {} } };
+  }
+  if (strategy !== "MAXIMIZE_CLICKS" && strategy !== "MAXIMIZE_CONVERSIONS") {
+    return {
+      ok: false,
+      message: `--strategy ${strategy} is not one Google forecasts: MANUAL_CPC | MAXIMIZE_CLICKS | MAXIMIZE_CONVERSIONS`
+    };
+  }
+  if (spend === void 0) return { ok: false, message: `${strategy} needs --daily-spend` };
+  if (strategy === "MAXIMIZE_CONVERSIONS") return { ok: true, bidding: { strategy, dailyTargetSpendMicros: spend } };
+  return {
+    ok: true,
+    bidding: { strategy, dailyTargetSpendMicros: spend, ...maxCpc ? { maxCpcBidCeilingMicros: maxCpc } : {} }
+  };
+}
+function hints(data) {
+  const out = [
+    `Google's prediction for ${data.period.startDate}\u2013${data.period.endDate}, not an account result: quote it as a forecast.`
+  ];
+  if (data.forecast_clicks === null && data.forecast_cost_micros === null) {
+    out.push(
+      "Google forecast nothing for these keywords \u2014 too little search volume in the chosen locations, or the bid is too low to win auctions."
+    );
+  }
+  return out;
+}
+var forecastCommand = defineCommand({
+  meta: {
+    name: "forecast",
+    description: `Forecast clicks, cost and conversions for keywords under one bidding strategy (Keyword Planner).
+
+Examples:
+  baker ads google keywords forecast --customer-id 1234567890 --text "solar panels:PHRASE,placas solares:EXACT" --max-cpc 1.5 --location 2724 --language 1003
+  baker ads google keywords forecast --customer-id 1234567890 --text "crm software" --match-type BROAD --daily-spend 20 --strategy MAXIMIZE_CONVERSIONS --start 2026-11-01 --end 2026-11-30`
+  },
+  args: ARGS,
+  run: async ({ args, rawArgs }) => {
+    const customerId = requireCustomerId(args);
+    const keywords = keywordEntries(args, rawArgs);
+    const bidding = forecastBidding(args);
+    if (!bidding.ok) failWriteValidation(bidding.message);
+    const managerId = getManagerIdForCustomer(customerId);
+    const request = googleKeywordForecastRequestSchema.safeParse({
+      customerId,
+      ...managerId ? { managerId } : {},
+      adGroups: [{ keywords }],
+      ...args.location ? {
+        locationIds: String(args.location).split(",").map((id) => id.trim())
+      } : {},
+      ...args.language ? { languageId: String(args.language) } : {},
+      bidding: bidding.bidding,
+      ...args.start ? { startDate: args.start } : {},
+      ...args.end ? { endDate: args.end } : {},
+      ...args.currency ? { currencyCode: String(args.currency).toUpperCase() } : {}
+    });
+    if (!request.success) {
+      const issue = request.error.issues[0];
+      failWriteValidation(issue ? `${issue.path.join(".")}: ${issue.message}` : "Invalid forecast");
+    }
+    try {
+      const { data } = await apiPost(
+        "/api/ads/google/keywords/forecast",
+        request.data
+      );
+      writeJsonEnvelope({ ok: true, data, hints: hints(data) });
+    } catch (err) {
+      exitWithServiceReadError(err);
+    }
+  }
+});
+export {
+  forecastBidding,
+  forecastCommand
+};
+//# sourceMappingURL=forecast-L44QIHCC.js.map

package/dist/forecast-PVO63KCE.js

@@ -0,0 +1,104 @@
+import {
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-KDUMGBXU.js";
+import {
+  writeAdsJson
+} from "./chunk-6SL6463H.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-T64IRDKW.js";
+import "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-MMOTJIV6.js";
+import "./chunk-2ZZR2SOF.js";
+import "./chunk-YPCVPDU7.js";
+import "./chunk-D3RTGIT4.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/forecast.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+function loadTargeting(args) {
+  const inline = args.targeting;
+  if (inline) {
+    try {
+      return JSON.parse(inline);
+    } catch {
+      handleLinkedinError(new Error("--targeting must be valid JSON."));
+    }
+  }
+  const file = args["targeting-file"];
+  if (file) {
+    try {
+      return JSON.parse(readFileSync(file, "utf-8"));
+    } catch (e) {
+      handleLinkedinError(
+        new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
+      );
+    }
+  }
+  handleLinkedinError(new Error("Pass --targeting-file <path> or --targeting '{...JSON...}'"));
+}
+function parseMoney(raw) {
+  if (!raw) return void 0;
+  const m = /^(\d+(?:\.\d+)?)(?:\s+([A-Z]{3}))?$/.exec(raw.trim());
+  if (!m) {
+    handleLinkedinError(new Error(`Invalid money "${raw}". Use "100" or "100 EUR".`));
+  }
+  return { amount: m[1] ?? "0", currencyCode: m[2] ?? "USD" };
+}
+var forecastCommand = defineCommand({
+  meta: {
+    name: "forecast",
+    description: `Forecast reach + impressions + clicks + spend for a hypothetical campaign.
+
+Wraps /rest/adSupplyForecasts. Useful for greenfield (\xA714) \u2014 answers
+"if we launch with this budget + targeting + objective, what's the expected delivery?"
+
+Examples:
+  baker ads linkedin forecast --account-id 503001492 --objective LEAD_GENERATION --cost-type CPC \\
+    --daily-budget "200 USD" --bid "8 USD" --targeting-file targeting.json`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    objective: { type: "string", description: "Objective type", required: true },
+    "cost-type": { type: "string", description: "CPC | CPM | CPV | CPS", required: true },
+    "daily-budget": { type: "string", description: "e.g. '200 USD' or '200'" },
+    "total-budget": { type: "string", description: "e.g. '6000 USD'" },
+    bid: { type: "string", description: "Bid e.g. '8 USD'" },
+    targeting: { type: "string", description: "Inline JSON targetingCriteria" },
+    "targeting-file": { type: "string", description: "Path to JSON file with targetingCriteria" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    const targetingCriteria = loadTargeting(args);
+    try {
+      const data = await apiPost("/api/ads/linkedin/forecast", {
+        accountId,
+        objectiveType: String(args.objective),
+        costType: String(args["cost-type"]).toUpperCase(),
+        targetingCriteria,
+        dailyBudget: parseMoney(args["daily-budget"]),
+        totalBudget: parseMoney(args["total-budget"]),
+        bid: parseMoney(args.bid),
+        skipCache: Boolean(args["no-cache"])
+      });
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  forecastCommand
+};
+//# sourceMappingURL=forecast-PVO63KCE.js.map