@koda-sl/baker-cli 0.498.0 → 0.499.0

package/dist/funnel-6FWZR37B.js

@@ -0,0 +1,395 @@
+import {
+  FUNNEL_VERTICALS,
+  funnelRequestSchema
+} from "./chunk-LAL4PKNJ.js";
+import {
+  flowEventKeys
+} from "./chunk-4XIF4ZHU.js";
+import {
+  flowDataPath,
+  listFlowSlugs
+} from "./chunk-KMK6SCCT.js";
+import {
+  parseEventKey
+} from "./chunk-KT5HHR4A.js";
+import "./chunk-EDLZGTGN.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import "./chunk-RLDQDCW3.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/funnel/index.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/funnel/formMoments.ts
+function offeredEndings(form) {
+  return flowEventKeys(form.tree, form.slug).filter((ending) => ending.isCompletion || ending.nodeId === null);
+}
+function formMoments(events, forms, counted) {
+  const endings = /* @__PURE__ */ new Map();
+  for (const form of forms) {
+    for (const ending of offeredEndings(form)) endings.set(ending.eventKey, { slug: form.slug, ending });
+  }
+  const known = events.map((event) => {
+    const found = endings.get(event.eventKey);
+    if (found === void 0) return event;
+    endings.delete(event.eventKey);
+    return { ...event, step: found.ending.nodeName };
+  });
+  const unfired = [...endings.values()].map(({ slug, ending }) => {
+    const countedAs = counted.get(ending.eventKey);
+    return {
+      eventKey: ending.eventKey,
+      origin: "site",
+      flowSlug: slug,
+      ...ending.nodeType === null ? {} : { nodeType: ending.nodeType },
+      events: 0,
+      sessions: 0,
+      step: ending.nodeName,
+      seen: false,
+      ...countedAs === void 0 ? {} : { countedAs }
+    };
+  });
+  return [...known, ...unfired];
+}
+function withFormMoments(moments, forms, counted) {
+  return { ...moments, events: formMoments(moments.events, forms, counted) };
+}
+function formsNamedHere(forms) {
+  return forms.filter((form) => flowEventKeys(form.tree, form.slug).length > 0).map((form) => form.slug);
+}
+function unplacedFormHints(steps, forms, counted) {
+  const onAStep = new Set(
+    steps.flatMap((step) => (step.triggers ?? []).flatMap((trigger) => trigger.eventKey ? [trigger.eventKey] : []))
+  );
+  const unplaced = [];
+  for (const form of forms) {
+    const endings = flowEventKeys(form.tree, form.slug);
+    if (endings.length === 0 || endings.some((ending) => onAStep.has(ending.eventKey))) continue;
+    const countedOn = endings.filter((ending) => counted.has(ending.eventKey));
+    unplaced.push(
+      countedOn.length === 0 ? form.slug : `${form.slug} (counted as ${countedOn.map((ending) => `"${counted.get(ending.eventKey)}" on \`${ending.eventKey}\``).join(", ")})`
+    );
+  }
+  if (unplaced.length === 0) return [];
+  return [
+    `${unplaced.length} Form(s) in this workspace reach no funnel step, so they move nobody along it however many people finish them: ${unplaced.join("; ")}. Which ending moves somebody to which step is your call: \`baker funnel --moments\` lists every Form's endings by the step each happens on, and when the step names do not make it obvious \u2014 a Form that branches into a rejection and a confirmation \u2014 ask the person which one means a lead or a customer. Place it with \`baker funnel --add-trigger <step> --event <key>\`. A Form already counted as a page conversion goes on the funnel by THAT SAME key, or the two numbers disagree for ever.`
+  ];
+}
+
+// src/commands/funnel/funnelArgs.ts
+var FunnelArgsError = class extends Error {
+  /** Structured remediation, in the shape the CLI's error envelope carries. */
+  fix;
+  constructor(message, fix) {
+    super(message);
+    this.name = "FunnelArgsError";
+    if (fix) {
+      this.fix = fix;
+    }
+  }
+};
+function parseFunnelArgs(raw) {
+  const steps = parseSteps(raw.steps);
+  const step = parseStep(raw.step);
+  const removeStep = parseRemoveStep(raw["remove-step"] ?? raw.removeStep);
+  const preset = parsePreset(raw.preset);
+  const addTrigger = parseWayIn(raw["add-trigger"] ?? raw.addTrigger, raw.event, "--add-trigger");
+  const removeTrigger = parseWayIn(raw["remove-trigger"] ?? raw.removeTrigger, raw.event, "--remove-trigger");
+  const doors = [steps, step, removeStep, preset, addTrigger, removeTrigger].filter(
+    (door) => door !== void 0
+  ).length;
+  if (doors > 1) {
+    throw new FunnelArgsError(
+      "Give one of --steps, --step, --remove-step, --preset, --add-trigger or --remove-trigger, not two."
+    );
+  }
+  const days = raw.days === void 0 ? void 0 : Number(raw.days);
+  if (days !== void 0 && (!Number.isInteger(days) || days <= 0 || days > 400)) {
+    throw new FunnelArgsError("--days must be a whole number of days, from 1 to 400.");
+  }
+  return {
+    ...steps === void 0 ? {} : { steps },
+    ...step === void 0 ? {} : { step },
+    ...removeStep === void 0 ? {} : { removeStep },
+    ...preset === void 0 ? {} : { preset },
+    ...addTrigger === void 0 ? {} : { addTrigger },
+    ...removeTrigger === void 0 ? {} : { removeTrigger },
+    templates: raw.templates === true,
+    moments: raw.moments === true,
+    ...days === void 0 ? {} : { days }
+  };
+}
+function funnelWrite(args2) {
+  const body = {
+    ...args2.steps === void 0 ? {} : { steps: args2.steps },
+    ...args2.step === void 0 ? {} : { step: args2.step },
+    ...args2.removeStep === void 0 ? {} : { removeStep: args2.removeStep },
+    ...args2.preset === void 0 ? {} : { preset: args2.preset },
+    ...args2.addTrigger === void 0 ? {} : { addTrigger: args2.addTrigger },
+    ...args2.removeTrigger === void 0 ? {} : { removeTrigger: args2.removeTrigger },
+    ...args2.templates ? { templates: true } : {},
+    ...args2.moments ? { moments: true } : {},
+    ...args2.days === void 0 ? {} : { days: args2.days }
+  };
+  const parsed = funnelRequestSchema.safeParse(body);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new FunnelArgsError(
+      `That funnel cannot be sent \u2014 ${issue?.path.join(".") || "steps"}: ${issue?.message ?? "invalid"}`,
+      {
+        action: "read_the_schema",
+        explanation: "Run `baker schema funnel` for the exact shape of one step, or `baker funnel --templates` for sixteen worked examples plus every field an event carries."
+      }
+    );
+  }
+  return parsed.data;
+}
+function parseSteps(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new FunnelArgsError("--steps takes a JSON array of steps.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new FunnelArgsError(`--steps is not valid JSON: ${cause instanceof Error ? cause.message : "parse failed"}`, {
+      action: "quote_the_json",
+      explanation: `Wrap the whole array in single quotes so the shell leaves the double quotes alone: --steps '[{"key":"lead",...}]'.`
+    });
+  }
+  if (!Array.isArray(parsed)) {
+    throw new FunnelArgsError("--steps takes an ARRAY of steps, even when the funnel has one step.");
+  }
+  refuseRetiredShapes(parsed);
+  return parsed;
+}
+function parseStep(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new FunnelArgsError("--step takes one step as a JSON object.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new FunnelArgsError(`--step is not valid JSON: ${cause instanceof Error ? cause.message : "parse failed"}`, {
+      action: "quote_the_json",
+      explanation: `Wrap the object in single quotes so the shell leaves the double quotes alone: --step '{"key":"demo",...}'.`
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new FunnelArgsError("--step takes ONE step as an object. To restate several, use --steps with an array.");
+  }
+  refuseRetiredShapes([parsed]);
+  return parsed;
+}
+function parseRemoveStep(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new FunnelArgsError("--remove-step takes the key of the step to take off, as `baker funnel` lists it.");
+  }
+  return raw.trim();
+}
+function refuseRetiredShapes(steps) {
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null) continue;
+    const key = String(step.key ?? "?");
+    if ("offlineConversions" in step) {
+      throw new FunnelArgsError(`Step "${key}" puts sends on the step, and a send belongs to the conversion.`, {
+        action: "set_sends_on_the_conversion",
+        explanation: "Drop `offlineConversions`. Name the outcome with `baker analytics conversions`, then `baker analytics sends --set --conversion <name> --platform <p> --tag <tagId> --event <e>`; the step reads its conversions' sends back as `sends[]`."
+      });
+    }
+    const triggers = step.triggers;
+    if (!Array.isArray(triggers)) continue;
+    const kinds = triggers.map(
+      (trigger) => typeof trigger === "object" && trigger !== null ? trigger.kind : void 0
+    );
+    if (kinds.includes("analytics") || kinds.includes("conversion")) {
+      const word = kinds.includes("analytics") ? "analytics" : "conversion";
+      throw new FunnelArgsError(
+        `Step "${key}" has a \`${word}\` trigger, and a step is reached by an event or a landing only.`,
+        {
+          action: "use_an_event_trigger",
+          explanation: 'Pick the moment from `baker funnel --moments` and write it as `{"kind":"event","eventKey":"<from moments.events or moments.sources>"}` \u2014 nothing has to be named first. A landing is `{"kind":"landing","landingId":"<from moments.landings>"}`.'
+        }
+      );
+    }
+  }
+}
+function parsePreset(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || !FUNNEL_VERTICALS.includes(raw)) {
+    throw new FunnelArgsError(`--preset must be one of: ${FUNNEL_VERTICALS.join(", ")}`, {
+      action: "list_the_presets",
+      explanation: "Run `baker funnel --templates` to see what each preset contains before picking one."
+    });
+  }
+  return raw;
+}
+function parseWayIn(stepKey, eventKey, flag) {
+  if (stepKey === void 0) return void 0;
+  if (typeof stepKey !== "string" || stepKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} takes the key of the step to change: \`${flag} lead\`.`);
+  }
+  if (typeof eventKey !== "string" || eventKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} needs --event, naming what gets somebody there.`, {
+      action: "read_the_moments",
+      explanation: `Run \`baker funnel --moments\` and copy an \`events[].eventKey\` \u2014 a Form's own outcome is listed there at zero before anybody has filled it in. Then: \`${flag} ${stepKey.trim()} --event "<key>"\`.`
+    });
+  }
+  const key = eventKey.trim();
+  if (flag === "--add-trigger" && parseEventKey(key) === null) {
+    throw new FunnelArgsError(`"${key}" is not an event key, so nothing would ever reach that step through it.`, {
+      action: "read_the_moments",
+      explanation: "Run `baker funnel --moments` and copy an `events[].eventKey`. They look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or view:<landing>."
+    });
+  }
+  return { stepKey: stepKey.trim(), eventKey: key };
+}
+
+// src/commands/funnel/index.ts
+var args = {
+  steps: {
+    type: "string",
+    description: 'The WHOLE funnel, as a JSON array. One object per step: {"key":"meeting_held","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}. It REPLACES the funnel rather than adding to it, so read first and restate everything you want to keep. `key` is permanent and reaches reporting and URLs (lowercase, digits, underscores); `displayName` is the client\'s own words and can be anything. `stepClass` is the stage, one of visited, lead, engaged, customer, repeat, lost \u2014 six plain words every business has, used to compare one company\'s funnel with another\'s. `after` is a LIST, so two ways into one step is expressible and normal. `triggers` is what MOVES somebody onto the step, any one of them being enough, and there are three kinds: `{"id":"t1","kind":"event","eventKey":"submit:contact"}` for anything the company\'s Forms, pages or systems produced, used by its own key with nothing named first; `{"id":"t2","kind":"landing","landingId":"<from --moments>"}` for one landing page being viewed; `{"id":"t3","kind":"any_landing"}` for any landing being viewed. Take every key and id from `--moments`. A trigger carries no amount: an event is worth what it says, and a step is worth the sum. Where a step SENDS its people is not written here: a send belongs to the system\'s event (`baker analytics sends`), and the step reads it back as `sends[]`',
+    required: false
+  },
+  step: {
+    type: "string",
+    description: 'ONE step as a JSON object, in the same shape as an entry of --steps. It is added to the funnel as it now stands, or replaces the step with the same `key`, and every other step is left exactly as it is \u2014 the door for adding or changing a stage without restating the rest. Example: --step \'{"key":"demo","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}\'',
+    required: false
+  },
+  "add-trigger": {
+    type: "string",
+    description: 'The key of ONE step to add a way in to, with `--event` naming what gets somebody there: `--add-trigger lead --event "submit:contact"`. Start here for "this Form should count as a lead" \u2014 it adds that one way in and leaves the step\'s name, stage, `after[]` and every other trigger exactly as they are. Prefer it to `--step`, which takes a WHOLE step and therefore silently removes any trigger the restatement forgets. Adding a key the step already listens for changes nothing. Take the key from `--moments`, never from memory',
+    required: false
+  },
+  "remove-trigger": {
+    type: "string",
+    description: 'The key of ONE step to take a way in OFF, with `--event` naming which: `--remove-trigger lead --event "submit:contact"`. By event key rather than by trigger id, because the id is not something you ever saw. Everything else about the step is untouched',
+    required: false
+  },
+  event: {
+    type: "string",
+    description: "The event key `--add-trigger` or `--remove-trigger` acts on \u2014 an `events[].eventKey` from `--moments`, never invented. Every Form's endings are listed there by the step each happens on, at zero before anybody has filled the Form in; which one means the step is your decision",
+    required: false
+  },
+  "remove-step": {
+    type: "string",
+    description: "The key of one step to take off the funnel. Whatever came after it moves up to whatever came before it, so the chain stays joined. The response lists it under `removed`",
+    required: false
+  },
+  preset: {
+    type: "string",
+    description: `Draw one of the ready-made graphs instead of stating steps: b2b_sales, b2b_inbound, saas_self_serve, saas_sales_assisted, ecommerce_purchase. It draws over the whole funnel \u2014 every company already has one, so prefer --step to change a step. Run --templates first to see what each one contains. With a Shopify store connected, ecommerce_purchase comes wired to the store's own events (page:view_item, page:add_to_cart, page:begin_checkout, and page:purchase for a paid order); "Ordered again" stays unwired`,
+    required: false
+  },
+  moments: {
+    type: "boolean",
+    description: "Also return everything a trigger can name, so a trigger is PICKED rather than invented: `events` (every event this company's Forms, pages and systems produced in the window, with volume, the Form it belongs to, `origin` \u2014 `site` for a page or Form, `systems` for the client's own server, `both` \u2014 and `countedAs` when the company also counts it as a page conversion, which a trigger does not need; PLUS **every workspace Form's endings** \u2014 each step's completion and its `submit:` \u2014 with the `step` each happens on, at zero and `seen: false` until somebody fires one, so a Form built minutes ago is pickable with nothing set up first, and `countedAs` when the company already counts it. Nothing is marked as the outcome: which ending means a step is YOUR decision \u2014 read the step names, and ask the person when they do not make it obvious (a Form that branches into \u201CNot a fit\u201D and \u201CQuote confirmed\u201D). If the Form is already counted, use that same key, so the step and the conversion agree. `baker analytics conversions --flow <slug>` also lists a widget's housekeeping), `sources` (the client's own systems that post events to Baker, by the `page:<name>` key each raises, pickable before its first send arrives) and `landings` (its pages, by the id a `landing` trigger takes). Use this before writing any `triggers`: a key typed from memory saves, publishes and counts nobody forever. A Form's events need NOTHING set up first \u2014 no Source, no conversion: a Baker page raises them by itself",
+    required: false
+  },
+  days: {
+    type: "string",
+    description: "How many days the counts beside each step cover (default 30, up to 400). Every step comes back with `people` (reached it), `atLeast` (reached it or anything after it), `before` (got as far as the step before) and `share` (atLeast / before) \u2014 counted in PEOPLE across visits and devices, not in visits",
+    required: false
+  },
+  templates: {
+    type: "boolean",
+    description: "Also return the libraries: the suggested steps with their stages, the presets, and `stages[]` (the six stages with the test to apply). Where a step can be sent is not here \u2014 a send belongs to the system's event, and `baker analytics sends` lists the platforms and the tags that can send",
+    required: false
+  }
+};
+registerSchema({
+  command: "funnel",
+  description: "Read the company's funnel, or draw one",
+  args
+});
+var funnelCommand = defineCommand({
+  meta: {
+    name: "funnel",
+    description: 'Start here: run with no flags to see the funnel this company has, with the last 30 days of PEOPLE counted beside every step \u2014 `people` reached it, `atLeast` got at least that far, `before` got as far as the step before, `share` is the ratio, and `worstStep` names where the most people are lost. Every company has one from the day it exists: Visited (any landing) \u2192 Became a lead \u2192 Became a customer, the last two with no way in until somebody gives them one. Then `--moments` for everything a trigger can name (every event the company\'s Forms, pages and systems produced, its sources, its landings, plus each Form\'s own outcome at zero). **To make an event count on a step \u2014 the usual job \u2014 use `--add-trigger <step> --event <key>`:** it adds that one way in and touches nothing else about the step. `--step \'<json>\'` is for adding or renaming a STEP; it replaces the step with that key, so it means restating its `after` and every trigger it keeps, and one left out is gone. A step is reached by three kinds of thing and nothing else: an event by its own key (`{"id":"t1","kind":"event","eventKey":"<from moments.events or moments.sources>"}`), one landing being viewed (`{"id":"t2","kind":"landing","landingId":"<from moments.landings>"}`) or any landing (`{"id":"t3","kind":"any_landing"}`). Nothing has to be named first. Pick every trigger from `--moments`, never from memory. A step with no `triggers` advances NOBODY and reports zero forever without warning \u2014 that is what the hints keep pointing at. There is no default door: a Form is only counted where a trigger names it. Keep it true: a chat that adds a Form, a Source or an event that moves people forward places it on its step in the same chat. Each step comes back with `sends[]`, read-only: where the people who reach it are sent and what happened, read off the system events behind its ways in. A send is set on the event with `baker analytics sends`, never on a step, and once published it spends ad budget \u2014 a failed one is named in the hints. Everything here is STAGED: it becomes the company\'s funnel in one piece when the chat is published \u2014 the client sees it on the canvas in this chat and can edit it there too \u2014 and the previous version stays on file so what was already measured under it is not lost.'
+  },
+  args,
+  run: async ({ args: raw }) => {
+    try {
+      const parsed = parseFunnelArgs(raw);
+      const forms = workspaceForms();
+      const namedByCaller = formsNamedHere(forms);
+      const request = {
+        ...funnelWrite(parsed),
+        ...namedByCaller.length === 0 ? {} : { namedByCaller }
+      };
+      const response = await apiPost("/api/funnel", request);
+      const counted = new Map((response.data.counted ?? []).map((row) => [row.eventKey, row.name]));
+      const data = response.data.moments === void 0 ? response.data : { ...response.data, moments: withFormMoments(response.data.moments, forms, counted) };
+      const hints = [...response.hints ?? [], ...unplacedFormHints(response.data.steps ?? [], forms, counted)];
+      writeJsonEnvelope({
+        ok: true,
+        data,
+        ...hints.length > 0 ? { hints } : {}
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  }
+});
+function handleError(err) {
+  if (err instanceof FunnelArgsError) {
+    writeJsonEnvelope({
+      ok: false,
+      error: { code: "VALIDATION_ERROR", message: err.message, ...err.fix ? { fix: err.fix } : {} }
+    });
+    process.exit(1);
+  }
+  if (err instanceof ApiError) {
+    writeJsonEnvelope({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  writeJsonEnvelope({
+    ok: false,
+    error: { code: "NETWORK_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+  });
+  process.exit(1);
+}
+function workspaceForms() {
+  const forms = [];
+  for (const slug of listFlowSlugs()) {
+    try {
+      forms.push({ slug, tree: JSON.parse(readFileSync(flowDataPath(slug), "utf-8")) });
+    } catch {
+    }
+  }
+  return forms;
+}
+export {
+  funnelCommand
+};
+//# sourceMappingURL=funnel-6FWZR37B.js.map

package/dist/ga4-HTD6WC3P.js

@@ -0,0 +1,55 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ga4/index.ts
+import { defineCommand } from "citty";
+var ga4Command = defineCommand({
+  meta: {
+    name: "ga4",
+    description: `Google Analytics 4. Report on a property, audit its config, and change what it measures.
+
+Start here:
+  baker ga4 properties                    \u2014 list accessible properties
+  baker ga4 config                        \u2014 what the property measures today (and whether Baker may change it)
+  baker ga4 query --list-presets          \u2014 see available report presets
+
+Report:
+  baker ga4 audit                                                    \u2014 full property health check
+  baker ga4 query --preset tracking-health                           \u2014 compare GA4 vs GAds data
+  baker ga4 query --dimensions "date" --metrics "sessions" --days 7  \u2014 free-form query
+
+Then stage changes (nothing is sent to Google Analytics until the chat completes):
+  baker ga4 key-event create --json '{"eventName":"generate_lead","countingMethod":"ONCE_PER_EVENT"}'
+  baker ga4 custom-event create --json '{"destinationEvent":"quote_request","eventConditions":[...]}'
+  baker ga4 custom-dimension create --json '{"parameterName":"plan_tier","displayName":"Plan tier","scope":"EVENT"}'
+  baker ga4 audience create --json '{"displayName":"Visited without demo", \u2026}'   \u2014 a group to retarget
+  baker ga4 property set --industry TECHNOLOGY                                   \u2014 benchmarking cohort
+  baker ga4 ads-link create --customer-id 123-456-7890                           \u2014 what makes audiences targetable
+  baker ga4 enhanced-measurement set --scrolls true --outbound-clicks true        \u2014 automatic events, no tag needed
+  baker ga4 draft list                    \u2014 review everything staged
+
+An applied change takes effect on the property immediately \u2014 there is no version to publish afterwards
+and no undo. Agree the changes with the user before the chat completes, not after.
+
+Full guide: __tooling__/docs/tools/baker/ga4.md`
+  },
+  subCommands: {
+    properties: () => import("./properties-RBLJCVSG.js").then((m) => m.propertiesCommand),
+    config: () => import("./config-SMVIY6RW.js").then((m) => m.configCommand),
+    audit: () => import("./audit-7ED6CUTQ.js").then((m) => m.auditCommand),
+    query: () => import("./query-KQ675KJZ.js").then((m) => m.queryCommand),
+    "key-event": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.keyEventCommand),
+    "custom-dimension": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.customDimensionCommand),
+    "custom-metric": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.customMetricCommand),
+    "custom-event": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.customEventCommand),
+    "data-retention": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.dataRetentionCommand),
+    audience: () => import("./write-commands-OTWH6BKZ.js").then((m) => m.audienceCommand),
+    property: () => import("./write-commands-OTWH6BKZ.js").then((m) => m.propertyCommand),
+    "ads-link": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.adsLinkCommand),
+    "enhanced-measurement": () => import("./write-commands-OTWH6BKZ.js").then((m) => m.enhancedMeasurementCommand),
+    draft: () => import("./draft-ZCL7FVBH.js").then((m) => m.draftCommand)
+  }
+});
+export {
+  ga4Command
+};
+//# sourceMappingURL=ga4-HTD6WC3P.js.map