@koda-sl/baker-cli 0.453.0-dev.faf35eacb → 0.454.0-dev.67ad219ab

package/dist/write-commands-VKKEGFTJ.js

@@ -0,0 +1,713 @@
+import {
+  failValidation,
+  loadJsonArg,
+  loadJsonPayloads,
+  requireTarget,
+  stageOp,
+  stageOps
+} from "./chunk-DTKZEXIF.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-CWW5ITFK.js";
+import "./chunk-5BQCBI2G.js";
+import "./chunk-A7F3C6AJ.js";
+import "./chunk-YZIZEPAQ.js";
+import {
+  registerSchema
+} from "./chunk-5WW456MW.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ga4/write-commands.ts
+import { defineCommand } from "citty";
+var PROPERTY_ARG_DESCRIPTION = "GA4 property id (optional only when one property is connected \u2014 run `baker ga4 properties`)";
+var propertyArg = { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false };
+function createJsonDescription(noun) {
+  return `Inline JSON ${noun} definition, or a JSON array of them to stage several in one call (all or none)`;
+}
+function withProperty(args) {
+  return typeof args["property-id"] === "string" ? { propertyId: args["property-id"] } : {};
+}
+registerSchema({
+  command: "ga4.keyEvent",
+  description: "Mark an event as a key event (what Google Analytics calls a conversion, and what Google Ads imports for bidding), change how it is counted, or stop counting it. Read `baker ga4 config` first: the event has to be one the site actually sends, and marking an automatic event like page_view poisons Smart Bidding.",
+  args: {
+    json: { type: "string", description: createJsonDescription("key-event"), required: false },
+    file: { type: "string", description: "Path to a JSON file with the definition", required: false },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var keyEventCommand = defineCommand({
+  meta: {
+    name: "key-event",
+    description: `Stage key-event (conversion) changes
+
+Examples:
+  baker ga4 key-event create --json '{"eventName":"generate_lead","countingMethod":"ONCE_PER_EVENT"}'
+  baker ga4 key-event create --json '{"eventName":"purchase","countingMethod":"ONCE_PER_EVENT","defaultValue":{"numericValue":50,"currencyCode":"EUR"}}'
+  baker ga4 key-event create --json '[{\u2026}, {\u2026}]'   \u2014 several in one call, one read of the property
+  baker ga4 key-event update 4185 --json '{"countingMethod":"ONCE_PER_SESSION"}'
+  baker ga4 key-event delete 4185`
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: {
+        name: "create",
+        description: "Stage a new key event. Needs eventName and countingMethod (ONCE_PER_EVENT or ONCE_PER_SESSION); defaultValue sets a monetary value when the event does not send one."
+      },
+      args: {
+        json: { type: "string", description: createJsonDescription("key-event"), required: false },
+        file: { type: "string", description: "Path to a JSON file", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const input = args;
+        await stageOps(
+          loadJsonPayloads(input).map((payload) => ({
+            kind: "ga4.keyEvent.create",
+            payload,
+            ...withProperty(input)
+          }))
+        );
+      }
+    }),
+    update: defineCommand({
+      meta: {
+        name: "update",
+        description: "Stage a change to an existing key event (pass its id). Only countingMethod and defaultValue can change \u2014 Google will not rename a key event."
+      },
+      args: {
+        id: { type: "positional", description: "Key event id", required: false },
+        json: { type: "string", description: "Inline JSON with the changed fields", required: false },
+        file: { type: "string", description: "Path to a JSON file", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        await stageOp({
+          kind: "ga4.keyEvent.update",
+          target: requireTarget(args, "key event"),
+          payload: loadJsonArg(args),
+          ...withProperty(args)
+        });
+      }
+    }),
+    delete: defineCommand({
+      meta: {
+        name: "delete",
+        description: "Stage removing a key event, so the event stops counting as a conversion. The event itself keeps being collected. Irreversible once the chat completes \u2014 confirm with the user first."
+      },
+      args: {
+        id: { type: "positional", description: "Key event id", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        await stageOp({
+          kind: "ga4.keyEvent.delete",
+          target: requireTarget(args, "key event"),
+          ...withProperty(args)
+        });
+      }
+    })
+  }
+});
+var DEFINITIONS = [
+  {
+    command: "custom-dimension",
+    kind: "customDimension",
+    noun: "custom dimension",
+    createHint: "Needs parameterName (the event parameter the site sends), displayName, and scope (EVENT, USER or ITEM). Until a parameter has a custom dimension, it is collected but cannot be reported on.",
+    example: '{"parameterName":"plan_tier","displayName":"Plan tier","scope":"EVENT"}'
+  },
+  {
+    command: "custom-metric",
+    kind: "customMetric",
+    noun: "custom metric",
+    createHint: "Needs parameterName, displayName, scope EVENT and measurementUnit (STANDARD, CURRENCY, SECONDS\u2026). A CURRENCY metric must also declare restrictedMetricType: COST_DATA or REVENUE_DATA.",
+    example: '{"parameterName":"deal_value","displayName":"Deal value","scope":"EVENT","measurementUnit":"CURRENCY","restrictedMetricType":["REVENUE_DATA"]}'
+  }
+];
+for (const { kind, noun, createHint } of DEFINITIONS) {
+  registerSchema({
+    command: `ga4.${kind}`,
+    description: `Create, update or archive a Google Analytics ${noun}. ${createHint} Archiving frees the slot and takes it out of reporting; historical data stays. Read \`baker ga4 config\` first \u2014 a duplicate parameter name is refused.`,
+    args: {
+      json: { type: "string", description: createJsonDescription(noun), required: false },
+      file: { type: "string", description: "Path to a JSON file", required: false },
+      "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+    }
+  });
+}
+function definitionCommand(definition) {
+  const { command, kind, noun, example } = definition;
+  return defineCommand({
+    meta: {
+      name: command,
+      description: `Stage ${noun} changes
+
+Examples:
+  baker ga4 ${command} create --json '${example}'
+  baker ga4 ${command} create --json '[${example}, \u2026]'   \u2014 several in one call, one read of the property
+  baker ga4 ${command} update 12 --json '{"displayName":"Renamed"}'
+  baker ga4 ${command} archive 12`
+    },
+    subCommands: {
+      create: defineCommand({
+        meta: { name: "create", description: `Stage a new ${noun} (or a JSON array of them, staged together)` },
+        args: {
+          json: { type: "string", description: createJsonDescription(noun), required: false },
+          file: { type: "string", description: "Path to a JSON file", required: false },
+          "property-id": propertyArg
+        },
+        run: async ({ args }) => {
+          const input = args;
+          await stageOps(
+            loadJsonPayloads(input).map((payload) => ({
+              kind: `ga4.${kind}.create`,
+              payload,
+              ...withProperty(input)
+            }))
+          );
+        }
+      }),
+      update: defineCommand({
+        meta: {
+          name: "update",
+          description: `Stage a change to an existing ${noun} (pass its id). The parameter name and scope cannot change \u2014 archive and recreate for that.`
+        },
+        args: {
+          id: { type: "positional", description: `${noun} id`, required: false },
+          json: { type: "string", description: "Inline JSON with the changed fields", required: false },
+          file: { type: "string", description: "Path to a JSON file", required: false },
+          "property-id": propertyArg
+        },
+        run: async ({ args }) => {
+          await stageOp({
+            kind: `ga4.${kind}.update`,
+            target: requireTarget(args, noun),
+            payload: loadJsonArg(args),
+            ...withProperty(args)
+          });
+        }
+      }),
+      archive: defineCommand({
+        meta: {
+          name: "archive",
+          description: `Stage archiving a ${noun} (pass its id). It stops collecting and leaves reporting; past data stays. Irreversible once the chat completes \u2014 confirm with the user first.`
+        },
+        args: {
+          id: { type: "positional", description: `${noun} id`, required: false },
+          "property-id": propertyArg
+        },
+        run: async ({ args }) => {
+          await stageOp({
+            kind: `ga4.${kind}.archive`,
+            target: requireTarget(args, noun),
+            ...withProperty(args)
+          });
+        }
+      })
+    }
+  });
+}
+var customDimensionCommand = definitionCommand(DEFINITIONS[0]);
+var customMetricCommand = definitionCommand(DEFINITIONS[1]);
+registerSchema({
+  command: "ga4.customEvent",
+  description: "Create a new Google Analytics event out of one the site already sends \u2014 the 'Create event' rule in the Analytics interface. Use it to turn a generic event into a meaningful one (a form_submit on the quote page becomes quote_request) so it can be marked a key event. Needs destinationEvent and 1-10 eventConditions; sourceCopyParameters carries the original parameters over.",
+  args: {
+    json: { type: "string", description: createJsonDescription("custom-event rule"), required: false },
+    file: { type: "string", description: "Path to a JSON file", required: false },
+    "data-stream": {
+      type: "string",
+      description: "Data stream id (optional when the property has one website stream)",
+      required: false
+    },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var CUSTOM_EVENT_EXAMPLE = '{"destinationEvent":"quote_request","eventConditions":[{"field":"event_name","comparisonType":"EQUALS","value":"form_submit"},{"field":"page_location","comparisonType":"CONTAINS","value":"/quote"}],"sourceCopyParameters":true}';
+var dataStreamArg = {
+  type: "string",
+  description: "Data stream id (optional when the property has one website stream)",
+  required: false
+};
+function withStream(args) {
+  return typeof args["data-stream"] === "string" ? { dataStream: args["data-stream"] } : {};
+}
+var customEventCommand = defineCommand({
+  meta: {
+    name: "custom-event",
+    description: `Stage custom events \u2014 new events built from events the site already sends
+
+Examples:
+  baker ga4 custom-event create --json '${CUSTOM_EVENT_EXAMPLE}'
+  baker ga4 custom-event update 7 --json '{"sourceCopyParameters":false}'
+  baker ga4 custom-event delete 7`
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: {
+        name: "create",
+        description: "Stage a new custom event. Conditions match the source event: use field `event_name` to match the event itself, or any parameter name to match its value."
+      },
+      args: {
+        json: { type: "string", description: createJsonDescription("custom event"), required: false },
+        file: { type: "string", description: "Path to a JSON file", required: false },
+        "data-stream": dataStreamArg,
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const input = args;
+        await stageOps(
+          loadJsonPayloads(input).map((payload) => ({
+            kind: "ga4.eventCreateRule.create",
+            payload,
+            ...withStream(input),
+            ...withProperty(input)
+          }))
+        );
+      }
+    }),
+    update: defineCommand({
+      meta: { name: "update", description: "Stage a change to an existing custom event (pass its id)" },
+      args: {
+        id: { type: "positional", description: "Custom event rule id", required: false },
+        json: { type: "string", description: "Inline JSON with the changed fields", required: false },
+        file: { type: "string", description: "Path to a JSON file", required: false },
+        "data-stream": dataStreamArg,
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        await stageOp({
+          kind: "ga4.eventCreateRule.update",
+          target: requireTarget(args, "custom event"),
+          payload: loadJsonArg(args),
+          ...withStream(args),
+          ...withProperty(args)
+        });
+      }
+    }),
+    delete: defineCommand({
+      meta: {
+        name: "delete",
+        description: "Stage removing a custom event (pass its id). The event stops being created from then on; data already collected under it stays. Confirm with the user first."
+      },
+      args: {
+        id: { type: "positional", description: "Custom event rule id", required: false },
+        "data-stream": dataStreamArg,
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        await stageOp({
+          kind: "ga4.eventCreateRule.delete",
+          target: requireTarget(args, "custom event"),
+          ...withStream(args),
+          ...withProperty(args)
+        });
+      }
+    })
+  }
+});
+registerSchema({
+  command: "ga4.dataRetention",
+  description: "Set how long Google Analytics keeps event and user data. Standard properties allow 2 or 14 months; longer windows need an Analytics 360 licence. Two months is the default on many properties and makes year-on-year and long-window attribution impossible, so 14 is almost always the right answer.",
+  args: {
+    "event-data": { type: "string", description: "Months to keep event data: 2, 14, 26, 38 or 50", required: false },
+    "user-data": { type: "string", description: "Months to keep user data: 2, 14, 26, 38 or 50", required: false },
+    "reset-on-activity": {
+      type: "string",
+      description: "true|false \u2014 restart a user's retention window on every new event from them",
+      required: false
+    },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var RETENTION_BY_MONTHS = {
+  "2": "TWO_MONTHS",
+  "14": "FOURTEEN_MONTHS",
+  "26": "TWENTY_SIX_MONTHS",
+  "38": "THIRTY_EIGHT_MONTHS",
+  "50": "FIFTY_MONTHS"
+};
+function retentionValue(input, flag) {
+  const normalized = input.trim();
+  const mapped = RETENTION_BY_MONTHS[normalized] ?? (Object.values(RETENTION_BY_MONTHS).includes(normalized.toUpperCase()) ? normalized.toUpperCase() : void 0);
+  if (!mapped) {
+    failValidation(`--${flag} must be one of 2, 14, 26, 38 or 50 (months)`);
+  }
+  return mapped;
+}
+function booleanArg(input, flag) {
+  if (input === "true") return true;
+  if (input === "false") return false;
+  return failValidation(`--${flag} must be true or false`);
+}
+var dataRetentionCommand = defineCommand({
+  meta: {
+    name: "data-retention",
+    description: `Stage a change to how long Google Analytics keeps data
+
+Examples:
+  baker ga4 data-retention set --event-data 14
+  baker ga4 data-retention set --event-data 14 --user-data 14 --reset-on-activity true`
+  },
+  subCommands: {
+    set: defineCommand({
+      meta: { name: "set", description: "Stage the retention window (months)" },
+      args: {
+        "event-data": { type: "string", description: "2, 14, 26, 38 or 50", required: false },
+        "user-data": { type: "string", description: "2, 14, 26, 38 or 50", required: false },
+        "reset-on-activity": { type: "string", description: "true|false", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const payload = {};
+        if (typeof args["event-data"] === "string") {
+          payload.eventDataRetention = retentionValue(args["event-data"], "event-data");
+        }
+        if (typeof args["user-data"] === "string") {
+          payload.userDataRetention = retentionValue(args["user-data"], "user-data");
+        }
+        if (typeof args["reset-on-activity"] === "string") {
+          payload.resetUserDataOnNewActivity = booleanArg(args["reset-on-activity"], "reset-on-activity");
+        }
+        if (Object.keys(payload).length === 0) {
+          failValidation("pass at least one of --event-data, --user-data or --reset-on-activity");
+        }
+        await stageOp({ kind: "ga4.dataRetention.update", payload, ...withProperty(args) });
+      }
+    })
+  }
+});
+registerSchema({
+  command: "ga4.audience",
+  description: "Create an audience (a saved group of users, e.g. everyone who started a demo but never finished), rename one, or archive one. Read `baker ga4 config` first to see the audiences that already exist. Everything that defines who is in an audience \u2014 the conditions, the membership window \u2014 is frozen the moment it is created and cannot be edited afterwards, so get it right in one go. An audience only reaches Google Ads for retargeting if the property is linked to a Google Ads account.",
+  args: {
+    json: { type: "string", description: createJsonDescription("audience"), required: false },
+    file: { type: "string", description: "Path to a JSON file with the definition", required: false },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var audienceCommand = defineCommand({
+  meta: {
+    name: "audience",
+    description: `Stage audience changes (saved groups of users, for retargeting and analysis)
+
+The definition is PERMANENT: conditions and membership window cannot be edited after creation.
+Fixing one means archiving it and building a replacement, which does not carry its users over.
+
+Examples:
+  # Everyone who visited but never submitted the demo form, kept for 90 days
+  baker ga4 audience create --json '{
+    "displayName":"Visited without demo",
+    "description":"Reached the site, never submitted the demo form",
+    "membershipDurationDays":90,
+    "filterClauses":[
+      {"clauseType":"INCLUDE","simpleFilter":{"scope":"AUDIENCE_FILTER_SCOPE_ACROSS_ALL_SESSIONS",
+        "filterExpression":{"eventFilter":{"eventName":"page_view"}}}},
+      {"clauseType":"EXCLUDE","simpleFilter":{"scope":"AUDIENCE_FILTER_SCOPE_ACROSS_ALL_SESSIONS",
+        "filterExpression":{"eventFilter":{"eventName":"demo_form_submitted"}}}}
+    ]}'
+
+  # Everyone who landed on a pricing page
+  baker ga4 audience create --json '{"displayName":"Saw pricing","description":"Viewed a pricing page",
+    "membershipDurationDays":60,
+    "filterClauses":[{"clauseType":"INCLUDE","simpleFilter":{"scope":"AUDIENCE_FILTER_SCOPE_ACROSS_ALL_SESSIONS",
+      "filterExpression":{"dimensionOrMetricFilter":{"fieldName":"pagePath",
+        "stringFilter":{"matchType":"CONTAINS","value":"/pricing"}}}}}]}'
+
+  baker ga4 audience update 8813 --json '{"displayName":"Visited without demo (90d)"}'   \u2014 name/description only
+  baker ga4 audience archive 8813`
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: createJsonDescription("audience") },
+      args: {
+        json: { type: "string", description: createJsonDescription("audience"), required: false },
+        file: { type: "string", description: "Path to a JSON file", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const payloads = loadJsonPayloads(args);
+        await stageOps(
+          payloads.map((payload) => ({
+            kind: "ga4.audience.create",
+            payload,
+            ...withProperty(args)
+          }))
+        );
+      }
+    }),
+    update: defineCommand({
+      meta: {
+        name: "update",
+        description: "Stage a new name or description (pass the audience id). Who is in it cannot be changed."
+      },
+      args: {
+        json: { type: "string", description: 'Inline JSON, e.g. {"displayName":"\u2026"}', required: false },
+        file: { type: "string", description: "Path to a JSON file", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const target = requireTarget(args, "audience id");
+        const payload = loadJsonArg(args);
+        await stageOp({
+          kind: "ga4.audience.update",
+          target,
+          payload,
+          ...withProperty(args)
+        });
+      }
+    }),
+    archive: defineCommand({
+      meta: {
+        name: "archive",
+        description: "Stage retiring an audience. Cannot be undone \u2014 the users it gathered do not come back."
+      },
+      args: { "property-id": propertyArg },
+      run: async ({ args }) => {
+        await stageOp({
+          kind: "ga4.audience.archive",
+          target: requireTarget(args, "audience id"),
+          ...withProperty(args)
+        });
+      }
+    })
+  }
+});
+registerSchema({
+  command: "ga4.property",
+  description: "Set the property's name or industry category. The industry decides which businesses Google benchmarks this property against, so a property left on OTHER is being compared to nothing useful. Time zone and currency are deliberately not changeable here \u2014 both re-bucket every future day without reprocessing history, so they belong to a person who knows the reporting calendar.",
+  args: {
+    name: { type: "string", description: "New property display name", required: false },
+    industry: {
+      type: "string",
+      description: "Industry category, e.g. TECHNOLOGY, FINANCE, HEALTHCARE, REAL_ESTATE, JOBS_AND_EDUCATION",
+      required: false
+    },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var propertyCommand = defineCommand({
+  meta: {
+    name: "property",
+    description: `Stage a change to the property's own settings
+
+Examples:
+  baker ga4 property set --industry TECHNOLOGY
+  baker ga4 property set --name "Acme \u2014 Web" --industry REAL_ESTATE`
+  },
+  subCommands: {
+    set: defineCommand({
+      meta: { name: "set", description: "Stage the property name and/or industry category" },
+      args: {
+        name: { type: "string", description: "New property display name", required: false },
+        industry: { type: "string", description: "Industry category, e.g. TECHNOLOGY", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const payload = {};
+        if (typeof args.name === "string" && args.name.length > 0) {
+          payload.displayName = args.name;
+        }
+        if (typeof args.industry === "string" && args.industry.length > 0) {
+          payload.industryCategory = args.industry.trim().toUpperCase();
+        }
+        if (Object.keys(payload).length === 0) {
+          failValidation("pass --name, --industry, or both");
+        }
+        await stageOp({ kind: "ga4.property.update", payload, ...withProperty(args) });
+      }
+    })
+  }
+});
+registerSchema({
+  command: "ga4.adsLink",
+  description: "Link this Analytics property to a Google Ads account, or unlink it. This is what lets Google Ads import the property's key events for bidding and makes audiences built here targetable \u2014 `baker ga4 audit` reports the gap as NO_ADS_LINK. It reaches outside Analytics and moves the client's data between two products, so agree it with the user before staging it.",
+  args: {
+    "customer-id": {
+      type: "string",
+      description: "Google Ads customer id, with or without dashes (123-456-7890)",
+      required: false
+    },
+    "ads-personalization": {
+      type: "string",
+      description: "true|false \u2014 may this property's audiences be used for ads personalisation",
+      required: false
+    },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var adsLinkCommand = defineCommand({
+  meta: {
+    name: "ads-link",
+    description: `Stage linking this property to a Google Ads account
+
+Without this link, Google Ads imports no key events from the property and audiences built
+here cannot be retargeted. It moves the client's data between two products \u2014 agree it first.
+
+Examples:
+  baker ga4 ads-link create --customer-id 123-456-7890
+  baker ga4 ads-link create --customer-id 1234567890 --ads-personalization true
+  baker ga4 ads-link update L1234 --ads-personalization false
+  baker ga4 ads-link delete L1234`
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: "Stage linking the property to a Google Ads account" },
+      args: {
+        "customer-id": { type: "string", description: "Google Ads customer id (123-456-7890)", required: false },
+        "ads-personalization": { type: "string", description: "true|false", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const customerId = args["customer-id"];
+        if (typeof customerId !== "string" || customerId.length === 0) {
+          failValidation("pass --customer-id, the Google Ads account to link (123-456-7890)");
+        }
+        const payload = { customerId };
+        if (typeof args["ads-personalization"] === "string") {
+          payload.adsPersonalizationEnabled = booleanArg(args["ads-personalization"], "ads-personalization");
+        }
+        await stageOp({ kind: "ga4.googleAdsLink.create", payload, ...withProperty(args) });
+      }
+    }),
+    update: defineCommand({
+      meta: {
+        name: "update",
+        description: "Stage the ads-personalisation setting on an existing link (pass its id)"
+      },
+      args: {
+        "ads-personalization": { type: "string", description: "true|false", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const target = requireTarget(args, "Google Ads link id");
+        if (typeof args["ads-personalization"] !== "string") {
+          failValidation("pass --ads-personalization true|false \u2014 it is the only thing a link update can change");
+        }
+        await stageOp({
+          kind: "ga4.googleAdsLink.update",
+          target,
+          payload: { adsPersonalizationEnabled: booleanArg(args["ads-personalization"], "ads-personalization") },
+          ...withProperty(args)
+        });
+      }
+    }),
+    delete: defineCommand({
+      meta: {
+        name: "delete",
+        description: "Stage unlinking. Stops conversion imports and strands every audience on this property."
+      },
+      args: { "property-id": propertyArg },
+      run: async ({ args }) => {
+        await stageOp({
+          kind: "ga4.googleAdsLink.delete",
+          target: requireTarget(args, "Google Ads link id"),
+          ...withProperty(args)
+        });
+      }
+    })
+  }
+});
+registerSchema({
+  command: "ga4.enhancedMeasurement",
+  description: "Turn the automatic web-stream events on or off: scrolls, outbound clicks, site search, video engagement, file downloads, page changes (single-page apps), form interactions. These are collected by Google Analytics itself with no tag to add, so this is usually the cheapest measurement win available. Run `baker ga4 config --full` to see what is on today.",
+  args: {
+    scrolls: { type: "string", description: "true|false", required: false },
+    "outbound-clicks": { type: "string", description: "true|false", required: false },
+    "site-search": { type: "string", description: "true|false \u2014 needs --search-parameters", required: false },
+    "search-parameters": {
+      type: "string",
+      description: "URL parameters carrying the search term, e.g. q,s,search,query,keyword",
+      required: false
+    },
+    video: { type: "string", description: "true|false", required: false },
+    "file-downloads": { type: "string", description: "true|false", required: false },
+    "page-changes": { type: "string", description: "true|false \u2014 page views in a single-page app", required: false },
+    "form-interactions": { type: "string", description: "true|false", required: false },
+    enabled: { type: "string", description: "true|false \u2014 the master switch for the whole feature", required: false },
+    "data-stream": {
+      type: "string",
+      description: "Only when the property has several website streams",
+      required: false
+    },
+    "property-id": { type: "string", description: PROPERTY_ARG_DESCRIPTION, required: false }
+  }
+});
+var MEASUREMENT_FLAGS = {
+  enabled: "streamEnabled",
+  scrolls: "scrollsEnabled",
+  "outbound-clicks": "outboundClicksEnabled",
+  "site-search": "siteSearchEnabled",
+  video: "videoEngagementEnabled",
+  "file-downloads": "fileDownloadsEnabled",
+  "page-changes": "pageChangesEnabled",
+  "form-interactions": "formInteractionsEnabled"
+};
+var enhancedMeasurementCommand = defineCommand({
+  meta: {
+    name: "enhanced-measurement",
+    description: `Stage the automatic events GA4 collects on a website stream
+
+No tag to add \u2014 Google Analytics collects these itself. Usually the cheapest measurement win there is.
+
+Examples:
+  baker ga4 enhanced-measurement set --scrolls true --outbound-clicks true --file-downloads true
+  baker ga4 enhanced-measurement set --site-search true --search-parameters "q,s,search,query,keyword"
+  baker ga4 enhanced-measurement set --page-changes true     # page views in a single-page app
+  baker ga4 enhanced-measurement set --video false`
+  },
+  subCommands: {
+    set: defineCommand({
+      meta: { name: "set", description: "Stage which automatic events the website stream collects" },
+      args: {
+        scrolls: { type: "string", description: "true|false", required: false },
+        "outbound-clicks": { type: "string", description: "true|false", required: false },
+        "site-search": { type: "string", description: "true|false", required: false },
+        "search-parameters": { type: "string", description: "e.g. q,s,search,query,keyword", required: false },
+        video: { type: "string", description: "true|false", required: false },
+        "file-downloads": { type: "string", description: "true|false", required: false },
+        "page-changes": { type: "string", description: "true|false", required: false },
+        "form-interactions": { type: "string", description: "true|false", required: false },
+        enabled: { type: "string", description: "true|false \u2014 master switch", required: false },
+        "data-stream": { type: "string", description: "Stream id, when there are several", required: false },
+        "property-id": propertyArg
+      },
+      run: async ({ args }) => {
+        const payload = {};
+        for (const [flag, field] of Object.entries(MEASUREMENT_FLAGS)) {
+          const value = args[flag];
+          if (typeof value === "string") {
+            payload[field] = booleanArg(value, flag);
+          }
+        }
+        if (typeof args["search-parameters"] === "string" && args["search-parameters"].length > 0) {
+          payload.searchQueryParameter = args["search-parameters"];
+        }
+        if (Object.keys(payload).length === 0) {
+          failValidation(
+            "pass at least one setting, e.g. --scrolls true --outbound-clicks true. Run `baker ga4 config --full` to see what is on today."
+          );
+        }
+        await stageOp({
+          kind: "ga4.enhancedMeasurement.update",
+          payload,
+          ...typeof args["data-stream"] === "string" ? { dataStream: args["data-stream"] } : {},
+          ...withProperty(args)
+        });
+      }
+    })
+  }
+});
+export {
+  adsLinkCommand,
+  audienceCommand,
+  customDimensionCommand,
+  customEventCommand,
+  customMetricCommand,
+  dataRetentionCommand,
+  enhancedMeasurementCommand,
+  keyEventCommand,
+  propertyCommand,
+  retentionValue
+};
+//# sourceMappingURL=write-commands-VKKEGFTJ.js.map