@koda-sl/baker-cli 0.509.0 → 0.511.0-dev.2d26314a2

package/dist/chunk-2A7KCBFW.js

@@ -0,0 +1,387 @@
+import {
+  CRM_COLUMN_FIELDS,
+  CRM_DEAL_STATUSES,
+  targetAccountsSchema,
+  targetsSummarySchema
+} from "./chunk-3RBTIJPR.js";
+import {
+  calendarDaySchema,
+  todayUtc,
+  windowTooLong
+} from "./chunk-4CNR3MNJ.js";
+
+// ../api/src/accounts/crm-columns.ts
+var COLUMN_HELD = 0.7;
+var SAMPLE_CHARS = 60;
+var EMAIL = /[^\s@]+@[^\s@]+\.[^\s@]+/g;
+var CRITERIA = {
+  id: "The deal's own unique id or number in the CRM (a deal, opportunity or record id of the deal), not the company's id",
+  name: "The deal's own title (a deal or opportunity name), not the name of the company or of a person",
+  companyId: "The CRM's unique id (or record id) of the company or account the row is about or the deal is with",
+  companyName: "The name of the company, account or organization the row is about or the deal is with",
+  companyDomain: "The company's website or web domain, like acme.com",
+  companyLinkedinPage: "The company's LinkedIn page address",
+  amount: "The deal's own value in money (its amount, value or size), not a weighted or forecast amount, not a company's revenue or turnover, not a probability, a percentage or a count",
+  currency: "The currency the amount is in, like EUR or USD",
+  pipeline: "Which sales pipeline the deal belongs to, not its stage",
+  stage: "The deal's stage or state in the sales pipeline, in any words (like Proposal, Negotiation, Closed Won, Ganado), not the status of a lead or a contact",
+  status: "Whether the deal is open, won or lost, written as exactly the English word open, won or lost",
+  createdAt: "The date the deal or the company was created, opened or added to the CRM",
+  closedAt: "The date the deal was closed (won or lost) or is expected to close",
+  none: "Anything else: a person (an owner, a contact, a person's name, email or phone), who created or last changed the record, a probability, a weighted amount, a company's revenue or size, a lead's or contact's status, a next step, a source, notes, an industry, a date of last activity, or any other field"
+};
+var QUESTION = "`column` is the header of a column in a spreadsheet exported from a CRM, in any language or in the CRM's own wording, and `cells` are values from that column. `sheet` lists every header of the spreadsheet, for context. Which field does `column` hold?";
+function sampleCell(cell) {
+  return cell.replace(EMAIL, "<email address>").slice(0, SAMPLE_CHARS);
+}
+function crmColumnQuestions(columns, headers = columns.map((column) => column.header)) {
+  const sheet = headers.join(" | ");
+  return columns.map(({ header, samples }) => ({
+    type: "choice",
+    instructions: {
+      sheet,
+      column: header,
+      cells: samples.length > 0 ? samples.map(sampleCell).join(" | ") : "(empty)",
+      question: QUESTION
+    },
+    criteria: CRITERIA
+  }));
+}
+var isCrmColumnField = (choice) => CRM_COLUMN_FIELDS.includes(choice);
+var isStatusCell = (cell) => CRM_DEAL_STATUSES.includes(cell.trim().toLowerCase());
+function crmColumnMeanings(columns, answers, held = COLUMN_HELD) {
+  const meanings = {};
+  columns.forEach(({ header, samples }, index) => {
+    const answer = answers[index];
+    if (answer === void 0 || !("choice" in answer)) return;
+    const { choice, probabilities } = answer;
+    if (!isCrmColumnField(choice) || (probabilities[choice] ?? 0) < held) return;
+    meanings[header] = choice === "status" && !samples.every(isStatusCell) ? "stage" : choice;
+  });
+  return meanings;
+}
+
+// ../api/src/accounts/index.ts
+import { z } from "zod";
+var INFLUENCE_MODEL_KINDS = ["engagement", "awareness", "intent"];
+var INFLUENCE_METRICS = ["impressions", "engagements", "clicks"];
+var DEFAULT_LOOKBACK_MONTHS = 12;
+var MATCH_CONFIDENCES = ["high", "low"];
+var MODEL_METRIC = {
+  engagement: { metric: "engagements", threshold: 3 },
+  awareness: { metric: "impressions", threshold: 7 },
+  intent: { metric: "clicks", threshold: 3 }
+};
+function influenceParams(settings, override = {}) {
+  const kind = override.model ?? settings.model.kind;
+  const model = MODEL_METRIC[kind];
+  const wholeAtLeastOne = (value) => value !== void 0 && Number.isInteger(value) && value >= 1;
+  const threshold = override.threshold ?? (override.model === void 0 ? settings.model.threshold : void 0);
+  return {
+    metric: model.metric,
+    threshold: wholeAtLeastOne(threshold) ? threshold : model.threshold,
+    lookbackMonths: wholeAtLeastOne(settings.lookbackMonths) ? settings.lookbackMonths : DEFAULT_LOOKBACK_MONTHS
+  };
+}
+var ACCOUNTS_MAX_MONTHS = 24;
+var windowFields = {
+  /** Calendar months including the current one. */
+  lastMonths: z.number().int().min(1).max(ACCOUNTS_MAX_MONTHS).optional(),
+  start: calendarDaySchema.optional(),
+  end: calendarDaySchema.optional()
+};
+var ruleOverrideFields = {
+  model: z.enum(INFLUENCE_MODEL_KINDS).optional(),
+  threshold: z.number().int().min(1).optional()
+};
+var targetsField = { targets: targetAccountsSchema.optional() };
+var targetsSummaryField = { targets: targetsSummarySchema.optional() };
+function windowRules(req, ctx) {
+  if (req.start !== void 0 && req.lastMonths !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["lastMonths"], message: "pass lastMonths or start/end, not both" });
+  }
+  if (req.end !== void 0 && req.start === void 0) {
+    ctx.addIssue({ code: "custom", path: ["end"], message: "end needs a start" });
+  }
+  if (req.start !== void 0 && req.end !== void 0 && req.end < req.start) {
+    ctx.addIssue({ code: "custom", path: ["end"], message: "end is before start" });
+    return;
+  }
+  const tooLong = req.start === void 0 ? null : windowTooLong(req.start, req.end ?? todayUtc(), ACCOUNTS_MAX_MONTHS);
+  if (tooLong !== null) ctx.addIssue({ code: "custom", path: ["start"], message: tooLong });
+}
+var accountsWindowSchema = z.object({ start: z.string(), end: z.string() });
+var influenceParamsSchema = z.object({
+  metric: z.enum(INFLUENCE_METRICS),
+  threshold: z.number(),
+  lookbackMonths: z.number()
+});
+var ACCOUNTS_ENGAGEMENT_DEFAULT_LIMIT = 500;
+var ACCOUNTS_ENGAGEMENT_MAX_LIMIT = 5e3;
+var accountEngagementRowSchema = z.object({
+  /** LinkedIn organization id; `urn:li:organization:<orgId>` on LinkedIn. */
+  orgId: z.string(),
+  /** Empty until the nightly sync has looked the company up. */
+  name: z.string(),
+  domain: z.string(),
+  impressions: z.number(),
+  clicks: z.number(),
+  engagements: z.number(),
+  videoViews: z.number(),
+  /** LinkedIn does not always report spend per company; 0 then. */
+  costLocal: z.number(),
+  currency: z.string(),
+  /** Months in the window the company saw or did anything. */
+  monthsActive: z.number(),
+  lastMonth: z.string().nullable(),
+  /** The same-length period just before the window. */
+  previous: z.object({ impressions: z.number(), clicks: z.number(), engagements: z.number() }),
+  /** By engagements against the previous period. */
+  flag: z.enum(["new", "rising"]).nullable(),
+  crmCompanyId: z.string().nullable(),
+  /** The matched CRM company's name; null without a match. Optional for older servers. */
+  crmCompanyName: z.string().nullable().optional(),
+  matchConfidence: z.enum(MATCH_CONFIDENCES).nullable(),
+  hasOpenDeal: z.boolean(),
+  hasWonDeal: z.boolean(),
+  hasLostDeal: z.boolean(),
+  /** When the company's most recent lost deal closed (created, when it has no close date), ISO; null without one. */
+  lastLostAt: z.string().nullable(),
+  /**
+   * People whose work email named the company's domain on the website or the
+   * API in the period, and how many became leads — the touches beside the ads.
+   * Null when none did; absent from older servers.
+   */
+  website: z.object({ people: z.number(), leads: z.number() }).nullable().optional(),
+  /**
+   * Visits from the company's own network in the period (`baker analytics
+   * companies`): visits, distinct pages read, and when it was last seen.
+   * Matched by normalised name (`companyNameKey`) against the LinkedIn name or
+   * the CRM match's name — the network gives no website to match on. Null when
+   * none matched; absent from older servers.
+   */
+  visitorCompany: z.object({ visits: z.number(), pages: z.number(), lastSeen: z.string() }).nullable().optional()
+});
+var accountWebsiteRowSchema = z.object({
+  domain: z.string(),
+  people: z.number(),
+  leads: z.number(),
+  /** ISO. */
+  firstSeen: z.string(),
+  /** ISO. */
+  lastSeen: z.string()
+});
+function accountDealStatus(row) {
+  if (row.hasWonDeal) return "won";
+  if (row.hasOpenDeal) return "open";
+  if (row.hasLostDeal) return "lost";
+  return "none";
+}
+var LOST_DEAL_COOLDOWN_MONTHS = 6;
+function monthsBefore(day, months) {
+  const [year, month, date] = day.split("-").map(Number);
+  const index = (year ?? 1970) * 12 + ((month ?? 1) - 1) - months;
+  const lastDate = new Date(Date.UTC(Math.floor(index / 12), index % 12 + 1, 0)).getUTCDate();
+  return new Date(Date.UTC(Math.floor(index / 12), index % 12, Math.min(date ?? 1, lastDate))).toISOString().slice(0, 10);
+}
+function warmAccounts(rows, today, options = {}) {
+  const cooldownStart = monthsBefore(today, LOST_DEAL_COOLDOWN_MONTHS);
+  const { minimum } = options;
+  return rows.filter(
+    (row) => row.flag !== null && (minimum === void 0 || row[minimum.metric] >= minimum.value) && !row.hasOpenDeal && !row.hasWonDeal && !(row.lastLostAt !== null && row.lastLostAt.slice(0, 10) >= cooldownStart)
+  );
+}
+var accountsEngagementRequestSchema = z.object({
+  ...windowFields,
+  /** One campaign's companies; every campaign together when absent. */
+  campaignId: z.string().regex(/^\d+$/, "use the numeric campaign id").optional(),
+  /** Companies per page. */
+  limit: z.number().int().min(1).max(ACCOUNTS_ENGAGEMENT_MAX_LIMIT).default(ACCOUNTS_ENGAGEMENT_DEFAULT_LIMIT),
+  /** Which page, 1-based, most engaged first. */
+  page: z.number().int().min(1).default(1),
+  ...targetsField
+}).superRefine(windowRules);
+var accountsEngagementResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    window: accountsWindowSchema,
+    previousWindow: accountsWindowSchema,
+    companies: z.array(accountEngagementRowSchema),
+    /** True when more companies were reached than this page and the ones before it hold. */
+    truncated: z.boolean(),
+    /** Which page this is, and how many companies there are in all. Absent from older servers. */
+    pageInfo: z.object({ page: z.number(), pageSize: z.number(), total: z.number(), hasMore: z.boolean() }).optional(),
+    /** The company's influence rule (the default one before setup): the minimum `baker accounts warm` applies. */
+    rule: influenceParamsSchema.optional(),
+    ...targetsSummaryField
+  })
+});
+var INFLUENCE_BASES = ["pipeline", "revenue"];
+var accountDealRowSchema = z.object({
+  dealId: z.string(),
+  dealName: z.string(),
+  crmCompanyId: z.string(),
+  companyName: z.string(),
+  domain: z.string(),
+  /** Null when the deal has no amount — unknown, not zero. */
+  amount: z.number().nullable(),
+  currency: z.string(),
+  /** Created (pipeline) or closed won (revenue), ISO. The date the lookback counts back from. */
+  referenceAt: z.string(),
+  /** By the won and lost stages chosen in the settings. */
+  status: z.enum(["open", "won", "lost"]),
+  /** The model's metric, summed over the company's lookback months. */
+  touchValue: z.number(),
+  /** The first month inside the lookback the company was reached, `YYYY-MM-01`. */
+  firstTouchMonth: z.string().nullable(),
+  /** How surely the CRM company is the LinkedIn one; null when no LinkedIn company matched. */
+  matchConfidence: z.enum(MATCH_CONFIDENCES).nullable(),
+  /** The company crossed the threshold — whatever the match confidence. */
+  influenced: z.boolean()
+});
+var moneyByCurrencySchema = z.record(z.string(), z.number());
+var influenceSummarySchema = z.object({
+  /** Every deal in the window for this basis. */
+  deals: z.number(),
+  /** Influenced, confirmed matches only — the headline. */
+  influencedDeals: z.number(),
+  influencedValue: moneyByCurrencySchema,
+  /** Influenced deals with no amount entered: counted, not valued. */
+  dealsWithoutAmount: z.number(),
+  /** Influenced through a match nobody confirmed yet; not in the headline. */
+  lowConfidenceDeals: z.number(),
+  lowConfidenceValue: moneyByCurrencySchema,
+  /** LinkedIn spend on the companies reached in the window, per currency. */
+  spend: moneyByCurrencySchema,
+  /** Influenced value per 1 of spend — only when both are in the same single currency. */
+  valuePerSpend: z.object({ currency: z.string(), value: z.number() }).nullable()
+});
+var accountsInfluencedRequestSchema = z.object({
+  ...windowFields,
+  /** `pipeline`: deals created in the window and not won. `revenue`: deals closed won in the window. */
+  basis: z.enum(INFLUENCE_BASES).default("pipeline"),
+  /** Every deal in the window, influenced or not; compact returns the influenced ones. */
+  full: z.boolean().default(false),
+  ...ruleOverrideFields,
+  ...targetsField
+}).superRefine(windowRules);
+var accountsInfluencedResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    window: accountsWindowSchema,
+    basis: z.enum(INFLUENCE_BASES),
+    rule: influenceParamsSchema,
+    summary: influenceSummarySchema,
+    /** Influenced deals on confirmed matches; with `full`, every deal in the window. */
+    deals: z.array(accountDealRowSchema),
+    /** Influenced through a match nobody confirmed yet. Not in `summary`'s headline. */
+    lowConfidence: z.array(accountDealRowSchema),
+    /** True when the window held more deals than one read returns. */
+    truncated: z.boolean(),
+    ...targetsSummaryField
+  })
+});
+var accountsCompanyRequestSchema = z.object({
+  /** LinkedIn organization id, or its `urn:li:organization:` URN. */
+  orgId: z.string().transform((value) => value.replace(/^urn:li:organization:/, "")).pipe(z.string().regex(/^\d+$/, "use the LinkedIn company id or its urn:li:organization URN")).optional(),
+  /** The company's website domain, `acme.com`. */
+  domain: z.string().min(3).max(253).transform(
+    (value) => value.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/.*$/, "")
+  ).optional()
+}).refine((req) => req.orgId === void 0 !== (req.domain === void 0), {
+  message: "Give a LinkedIn company id or a domain, one of the two."
+});
+var accountCompanyMonthSchema = z.object({
+  orgId: z.string(),
+  /** Empty for the whole ad account; a campaign id otherwise. */
+  campaignId: z.string(),
+  /** LinkedIn's name for the campaign; null for the account-wide row, or when LinkedIn could not be asked. */
+  campaignName: z.string().nullable(),
+  month: z.string(),
+  impressions: z.number(),
+  clicks: z.number(),
+  engagements: z.number()
+});
+var accountCompanyDealSchema = z.object({
+  dealId: z.string(),
+  dealName: z.string(),
+  amount: z.number().nullable(),
+  currency: z.string(),
+  status: z.enum(["open", "won", "lost"]),
+  createdAt: z.string(),
+  closedAt: z.string().nullable(),
+  /**
+   * The rule's metric over the lookback ending with the deal's reference month
+   * (created; closed for a won deal), from the pages in `orgs`. Absent before
+   * setup or when the company matched no CRM company.
+   */
+  touchValue: z.number().optional(),
+  /** `touchValue` reached the rule's threshold. */
+  influenced: z.boolean().optional()
+});
+var accountCompanyOrgSchema = z.object({
+  orgId: z.string(),
+  name: z.string(),
+  domain: z.string(),
+  crmCompanyId: z.string().nullable(),
+  matchConfidence: z.enum(MATCH_CONFIDENCES).nullable()
+});
+var accountsCompanyResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    /** Usually one; a domain can name several LinkedIn pages of the same company. */
+    orgs: z.array(accountCompanyOrgSchema),
+    /** Month by month, per campaign (and the account-wide row, `campaignId: ""`), oldest first. */
+    months: z.array(accountCompanyMonthSchema),
+    /** Deals of the matched CRM company, oldest first. */
+    deals: z.array(accountCompanyDealSchema),
+    /** The rule `influenced` and `touchValue` on each deal were read with; absent before setup. */
+    rule: influenceParamsSchema.optional()
+  })
+});
+var accountsCampaignsRequestSchema = z.object({
+  ...windowFields,
+  ...ruleOverrideFields,
+  basis: z.enum(INFLUENCE_BASES).default("pipeline"),
+  ...targetsField
+}).superRefine(windowRules);
+var accountCampaignRowSchema = z.object({
+  campaignId: z.string(),
+  /** LinkedIn's name for the campaign; null when LinkedIn could not be asked or no longer lists it. */
+  campaignName: z.string().nullable(),
+  /** Companies that saw at least one impression in the window. */
+  companiesReached: z.number(),
+  /** Companies with at least one engagement in the window. */
+  companiesEngaged: z.number(),
+  /** Influenced deals (of the read's basis) this campaign touched in their lookback. Overlaps other campaigns. */
+  influencedDeals: z.number(),
+  influencedValue: moneyByCurrencySchema
+});
+var accountsCampaignsResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    window: accountsWindowSchema,
+    /** Optional for older servers, which read pipeline only. */
+    basis: z.enum(INFLUENCE_BASES).optional(),
+    rule: influenceParamsSchema,
+    campaigns: z.array(accountCampaignRowSchema),
+    ...targetsSummaryField
+  })
+});
+var ACCOUNTS_NO_SETTINGS_MESSAGE = "Account insights are not set up yet: in Measure \u2192 Accounts, say where your deals are (HubSpot or another CRM) and what won and lost mean.";
+
+export {
+  crmColumnQuestions,
+  crmColumnMeanings,
+  INFLUENCE_MODEL_KINDS,
+  influenceParams,
+  ACCOUNTS_ENGAGEMENT_MAX_LIMIT,
+  accountDealStatus,
+  warmAccounts,
+  accountsEngagementRequestSchema,
+  accountsInfluencedRequestSchema,
+  accountsCompanyRequestSchema,
+  accountsCampaignsRequestSchema,
+  ACCOUNTS_NO_SETTINGS_MESSAGE
+};
+//# sourceMappingURL=chunk-2A7KCBFW.js.map

package/dist/chunk-2LEW2WH2.js

@@ -0,0 +1,63 @@
+import {
+  sheetDelimiter,
+  targetAccountsFrom
+} from "./chunk-3RBTIJPR.js";
+
+// src/commands/accounts/targets.ts
+import { parse } from "csv-parse/sync";
+var COLUMN_OF_HEADER = {
+  domain: "domain",
+  website: "domain",
+  url: "domain",
+  companydomain: "domain",
+  companywebsite: "domain",
+  name: "name",
+  company: "name",
+  companyname: "name",
+  account: "name",
+  accountname: "name",
+  tier: "tier"
+};
+var headerKey = (header) => header.toLowerCase().replace(/[\s_-]+/g, "");
+function csvEntries(text) {
+  const rows = parse(text, {
+    bom: true,
+    columns: true,
+    delimiter: sheetDelimiter(text),
+    skip_empty_lines: true,
+    relax_column_count: true,
+    trim: true
+  });
+  const columns = Object.keys(rows[0] ?? {}).flatMap((header) => {
+    const field = COLUMN_OF_HEADER[headerKey(header)];
+    return field ? [[header, field]] : [];
+  });
+  if (!columns.some(([, field]) => field === "domain")) {
+    throw new Error(
+      `The file has no domain column (found: ${Object.keys(rows[0] ?? {}).join(", ") || "nothing"}). Name one "domain" or "website".`
+    );
+  }
+  return rows.map((row) => {
+    const entry = {};
+    for (const [header, field] of columns) entry[field] ??= row[header] ?? "";
+    return entry;
+  });
+}
+function jsonEntries(text) {
+  const parsed = JSON.parse(text);
+  if (!Array.isArray(parsed)) {
+    throw new Error('The JSON file must be an array: ["acme.com", \u2026] or [{"domain": "acme.com", "tier": 1}, \u2026].');
+  }
+  return parsed.map(
+    (item) => typeof item === "string" ? { domain: item } : typeof item === "object" && item !== null ? item : {}
+  );
+}
+function readTargetsFile(path, text) {
+  const entries = path.toLowerCase().endsWith(".json") ? jsonEntries(text) : csvEntries(text);
+  return targetAccountsFrom(entries);
+}
+
+export {
+  readTargetsFile
+};
+//# sourceMappingURL=chunk-2LEW2WH2.js.map

package/dist/chunk-32KUF3RV.js

@@ -0,0 +1,228 @@
+import {
+  NUMERIC_ID_REGEX
+} from "./chunk-HNNCAJNF.js";
+
+// ../api/src/ads-google/change-history.ts
+var CHANGE_SCOPES = ["detail", "summary"];
+var CHANGE_SCOPE_MAX_DAYS = {
+  detail: 30,
+  summary: 90
+};
+var DEFAULT_CHANGE_DAYS = 7;
+var MAX_CHANGE_DAYS = CHANGE_SCOPE_MAX_DAYS.summary;
+function isChangeLookbackWithinReach(days, scope) {
+  return days <= CHANGE_SCOPE_MAX_DAYS[scope];
+}
+
+// ../api/src/ads-google/keyword-planning.ts
+import { z } from "zod";
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var micros = z.number().int().positive();
+var FORECAST_MATCH_TYPES = ["EXACT", "PHRASE", "BROAD"];
+var googleForecastBiddingSchema = z.discriminatedUnion("strategy", [
+  z.object({ strategy: z.literal("MANUAL_CPC"), maxCpcBidMicros: micros, dailyBudgetMicros: micros.optional() }),
+  z.object({
+    strategy: z.literal("MAXIMIZE_CLICKS"),
+    dailyTargetSpendMicros: micros,
+    maxCpcBidCeilingMicros: micros.optional()
+  }),
+  z.object({ strategy: z.literal("MAXIMIZE_CONVERSIONS"), dailyTargetSpendMicros: micros })
+]);
+var googleKeywordForecastRequestSchema = z.object({
+  customerId: z.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z.string().optional(),
+  /** One forecast ad group per entry; most forecasts are a single group. */
+  adGroups: z.array(
+    z.object({
+      keywords: z.array(z.object({ text: z.string().trim().min(1).max(80), matchType: z.enum(FORECAST_MATCH_TYPES) })).min(1)
+    })
+  ).min(1),
+  locationIds: z.array(z.string().regex(NUMERIC_ID_REGEX)).optional(),
+  languageId: z.string().regex(NUMERIC_ID_REGEX).optional(),
+  bidding: googleForecastBiddingSchema,
+  /** Must start in the future and end within a year. Without them Baker forecasts the 30 days from tomorrow. */
+  startDate: z.string().regex(ISO_DATE).optional(),
+  endDate: z.string().regex(ISO_DATE).optional(),
+  currencyCode: z.string().length(3).optional()
+}).refine((body) => body.startDate === void 0 === (body.endDate === void 0), {
+  message: "Give both --start and --end, or neither (the forecast then covers the 30 days from tomorrow)",
+  path: ["endDate"]
+});
+var KEYWORD_FORECAST_SOURCE = "keyword_planner_forecast";
+var googleKeywordForecastResponseSchema = z.object({
+  source: z.literal(KEYWORD_FORECAST_SOURCE),
+  period: z.object({ startDate: z.string(), endDate: z.string() }),
+  forecast_clicks: z.number().nullable(),
+  forecast_cost_micros: z.number().nullable(),
+  forecast_conversions: z.number().nullable(),
+  forecast_average_cpc_micros: z.number().nullable(),
+  forecast_average_cpa_micros: z.number().nullable()
+});
+var googleAdGroupThemesRequestSchema = z.object({
+  customerId: z.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z.string().optional(),
+  keywords: z.array(z.string().trim().min(1)).min(1),
+  /** Existing ad groups to sort the keywords into: numeric ids or `customers/{cid}/adGroups/{id}`. */
+  adGroups: z.array(z.string().min(1)).min(1)
+});
+var googleAdGroupThemesResponseSchema = z.object({
+  suggestions: z.array(
+    z.object({
+      keyword: z.string(),
+      suggested_keyword: z.string(),
+      match_type: z.string(),
+      ad_group: z.string(),
+      campaign: z.string()
+    })
+  ),
+  unusable_ad_groups: z.array(z.object({ ad_group: z.string(), campaign: z.string() }))
+});
+
+// ../api/src/ads-google/url-options.ts
+import { z as z2 } from "zod";
+var URL_OPTION_LEVELS = ["account", "campaign", "ad_group", "ad"];
+var googleUrlOptionValueSchema = z2.discriminatedUnion("state", [
+  z2.object({ state: z2.literal("set"), value: z2.string() }),
+  z2.object({ state: z2.literal("not_set") }),
+  z2.object({ state: z2.literal("not_read"), reason: z2.string() })
+]);
+var googleUrlOptionsRequestSchema = z2.object({
+  customerId: z2.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z2.string().optional(),
+  /** Compact by default: only campaigns that actually override the account. `full` lists every campaign. */
+  full: z2.boolean().optional(),
+  skipCache: z2.boolean().optional()
+});
+var googleUrlOptionsCampaignSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsAdGroupSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.string(),
+  campaign_id: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsAdSchema = z2.object({
+  id: z2.string(),
+  status: z2.string(),
+  ad_group_id: z2.string(),
+  campaign_id: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsResponseSchema = z2.object({
+  customer_id: z2.string(),
+  account: z2.object({
+    level: z2.literal("account"),
+    read: z2.boolean(),
+    final_url_suffix: googleUrlOptionValueSchema,
+    tracking_url_template: googleUrlOptionValueSchema
+  }),
+  campaigns: z2.object({
+    level: z2.literal("campaign"),
+    read: z2.boolean(),
+    /** Campaigns actually observed. 0 with `read: true` means the account has no non-removed campaigns. */
+    campaigns_read: z2.number().int().nonnegative(),
+    /** Campaigns observed to carry no override of their own — an explicit finding, not an omission. */
+    campaigns_without_override: z2.number().int().nonnegative(),
+    overrides: z2.array(googleUrlOptionsCampaignSchema),
+    /** Compact mode only: campaigns read but not listed because they carry no override. */
+    omitted: z2.number().int().nonnegative()
+  }),
+  /**
+   * Ad groups and ads that carry an override of their own — read by asking Google only for the
+   * entities whose suffix or template IS NOT NULL, so an account of thousands of ads costs one page.
+   * `read: true` with no overrides is a finding: nothing at this level overrides the levels above.
+   * `truncated` means more overriding entities exist than one page listed.
+   */
+  ad_groups: z2.object({
+    level: z2.literal("ad_group"),
+    read: z2.boolean(),
+    overrides: z2.array(googleUrlOptionsAdGroupSchema),
+    truncated: z2.boolean()
+  }),
+  ads: z2.object({
+    level: z2.literal("ad"),
+    read: z2.boolean(),
+    overrides: z2.array(googleUrlOptionsAdSchema),
+    truncated: z2.boolean()
+  }),
+  /** Levels this command could not read. Nothing here may be reported as "not configured". */
+  levels_not_read: z2.array(z2.object({ level: z2.enum(URL_OPTION_LEVELS), reason: z2.string() }))
+});
+var ACCOUNT_URL_OPTIONS_LOCATION = "Google Ads UI \u2192 Admin \u2192 Account settings \u2192 Tracking (account-level tracking template and final URL suffix)";
+var ACCOUNT_URL_OPTIONS_STAGE_COMMAND = 'baker ads google account update --customer-id <id> --final-url-suffix "utm_agency=baker"';
+function isSet(value) {
+  return value.state === "set";
+}
+function entityOverrideHints(label, plural, field, level) {
+  if (!level.read) return [];
+  const hints = [];
+  const overriding = level.overrides.filter((entity) => isSet(entity.final_url_suffix));
+  if (overriding.length > 0) {
+    const named = overriding.slice(0, 5).map((entity) => entity.name || entity.id).join(", ");
+    hints.push(
+      `${overriding.length} ${label}(s) set their own final URL suffix (${named}${overriding.length > 5 ? ", \u2026" : ""}). It REPLACES the campaign and account suffix for every click through it, so an account-wide parameter must be added to theirs too.`
+    );
+  }
+  if (level.truncated) {
+    hints.push(
+      `More ${plural} override the URL options than one page lists \u2014 read them all with \`baker ads google query\` on ${field}.final_url_suffix IS NOT NULL --all before saying which ones do.`
+    );
+  }
+  return hints;
+}
+function urlOptionsHints(report) {
+  const hints = [];
+  const { account, campaigns } = report;
+  if (!account.read) {
+    hints.push(
+      "The account level did NOT read \u2014 its URL options are unknown, not empty. Re-run before telling the user anything about account-wide tagging."
+    );
+  } else if (account.final_url_suffix.state === "not_set") {
+    hints.push(
+      `No account-level final URL suffix is set. An account-wide parameter (agency/partner tagging such as utm_agency=\u2026) belongs at the account level so it reaches every ad \u2014 stage it with \`${ACCOUNT_URL_OPTIONS_STAGE_COMMAND}\` (applies at Publish; the user sees it under ${ACCOUNT_URL_OPTIONS_LOCATION}).`
+    );
+  }
+  if (!campaigns.read) {
+    hints.push(
+      "Campaign-level URL options did NOT read \u2014 do not report that no campaign overrides exist. Re-run before concluding."
+    );
+  } else {
+    const overriding = campaigns.overrides.filter((c) => isSet(c.final_url_suffix));
+    if (overriding.length > 0) {
+      const named = overriding.slice(0, 5).map((c) => c.name || c.id).join(", ");
+      hints.push(
+        `A campaign's final URL suffix REPLACES the account-level one for that campaign \u2014 it does not merge. ${overriding.length} campaign(s) set their own (${named}${overriding.length > 5 ? ", \u2026" : ""}) and will not pick up an account-wide parameter until their own suffix carries it too. Every other campaign read here inherits the account level normally.`
+      );
+    }
+  }
+  hints.push(...entityOverrideHints("ad group", "ad groups", "ad_group", report.ad_groups));
+  hints.push(...entityOverrideHints("ad", "ads", "ad_group_ad.ad", report.ads));
+  const overridingLevelsNotRead = report.levels_not_read.filter((level) => level.level !== "account");
+  if (overridingLevelsNotRead.length > 0) {
+    hints.push(
+      `Not read at this level: ${overridingLevelsNotRead.map((l) => l.level).join(", ")}. A suffix set there still wins over the levels above it.`
+    );
+  }
+  if (campaigns.omitted > 0) {
+    hints.push(`${campaigns.omitted} campaign(s) read with no override of their own are not listed \u2014 pass --full.`);
+  }
+  return hints;
+}
+
+export {
+  CHANGE_SCOPES,
+  CHANGE_SCOPE_MAX_DAYS,
+  DEFAULT_CHANGE_DAYS,
+  isChangeLookbackWithinReach,
+  googleKeywordForecastRequestSchema,
+  urlOptionsHints
+};
+//# sourceMappingURL=chunk-32KUF3RV.js.map