@aranova/tracking-next 0.27.0 → 1.0.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -62,6 +72,7 @@ __export(src_exports, {
   createTrackingClientContext: () => createTrackingClientContext,
   createTrackingEventCreatePayload: () => createTrackingEventCreatePayload,
   createTrackingSessionUpsertPayload: () => createTrackingSessionUpsertPayload,
+  currencySchema: () => currencySchema,
   durationMinutes: () => durationMinutes,
   endOfDayInTz: () => endOfDayInTz,
   fetchServices: () => fetchServices,
@@ -162,7 +173,7 @@ function normalizeEmail(raw) {
   return EMAIL_SHAPE.test(cleaned) ? cleaned : null;
 }
 function stashUserData(data, country) {
-  const email = normalizeEmail(data.email);
+  const email4 = normalizeEmail(data.email);
   let phoneNumber = null;
   if (typeof data.phone === "string" && data.phone.length > 0) {
     try {
@@ -172,7 +183,7 @@ function stashUserData(data, country) {
     }
   }
   stash = {
-    email: email ?? stash.email,
+    email: email4 ?? stash.email,
     phoneNumber: phoneNumber ?? stash.phoneNumber
   };
 }
@@ -181,11 +192,11 @@ function clearStashedUserData() {
 }
 function applyUserDataForConversion(explicit, country) {
   if (typeof window === "undefined" || typeof window.gtag !== "function") return false;
-  let email = stash.email;
+  let email4 = stash.email;
   let phoneNumber = stash.phoneNumber;
   if (explicit) {
     const normalizedEmail = normalizeEmail(explicit.email);
-    if (normalizedEmail) email = normalizedEmail;
+    if (normalizedEmail) email4 = normalizedEmail;
     if (typeof explicit.phone === "string" && explicit.phone.length > 0) {
       try {
         phoneNumber = toE164(explicit.phone, country) ?? phoneNumber;
@@ -193,10 +204,10 @@ function applyUserDataForConversion(explicit, country) {
       }
     }
   }
-  if (email === null && phoneNumber === null) return false;
+  if (email4 === null && phoneNumber === null) return false;
   try {
     window.gtag("set", "user_data", {
-      ...email !== null ? { email } : {},
+      ...email4 !== null ? { email: email4 } : {},
       ...phoneNumber !== null ? { phone_number: phoneNumber } : {}
     });
     return true;
@@ -552,10 +563,10 @@ function readStoredRecord() {
     return null;
   }
 }
-function writeRecord(record) {
-  memoryRecord = record;
+function writeRecord(record5) {
+  memoryRecord = record5;
   try {
-    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record));
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record5));
   } catch {
   }
 }
@@ -577,9 +588,9 @@ function getOrCaptureLandingParams(sessionId, url) {
   if (memoryRecord && memoryRecord.session_id === sessionId) {
     return memoryRecord.params;
   }
-  const record = { session_id: sessionId, params: captureFromUrl(url) };
-  writeRecord(record);
-  return record.params;
+  const record5 = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record5);
+  return record5.params;
 }
 function buildLandingPayloadFields(sessionId, override) {
   const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
@@ -956,9 +967,9 @@ function automaticThresholdMet(goal, eventType, metadata) {
 }
 
 // ../tracking-core/src/resources/intl/date.ts
-function formatDateInTz(iso, timeZone, opts, locale) {
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return iso;
+function formatDateInTz(iso4, timeZone, opts, locale) {
+  const date = new Date(iso4);
+  if (Number.isNaN(date.getTime())) return iso4;
   return new Intl.DateTimeFormat(locale, {
     year: "numeric",
     month: "short",
@@ -1370,29 +1381,6 @@ function getTrackingConfigRuntime(ref, fetchImpl) {
   return runtime;
 }
 
-// ../tracking-core/src/session.ts
-var SESSION_IDLE_MS = 30 * 60 * 1e3;
-
-// ../tracking-core/src/events/page-view.ts
-var import_zod = require("zod");
-var pageViewMetadataSchema = import_zod.z.object({
-  page: import_zod.z.object({
-    title: import_zod.z.string().nullable(),
-    path: import_zod.z.string(),
-    search: import_zod.z.string(),
-    hash: import_zod.z.string()
-  }).strict(),
-  referrer: import_zod.z.string().nullable(),
-  // `.nullable().optional()` — absent (undefined) OR explicit null OR a
-  // real viewport object. Mirrors Pydantic's `_Viewport | None = None`
-  // on the backend side so the drift test stays clean.
-  viewport: import_zod.z.object({
-    w: import_zod.z.number(),
-    h: import_zod.z.number()
-  }).strict().nullable().optional()
-}).strict();
-var pageViewConfigSchema = import_zod.z.object({}).strict();
-
 // ../tracking-core/src/ingest.ts
 var API_KEY_HEADER = "X-Aranova-Api-Key";
 var SDK_VERSION_HEADER = "X-Aranova-Sdk-Version";
@@ -1400,187 +1388,6 @@ var SDK_PACKAGE_HEADER = "X-Aranova-Sdk-Package";
 var SDK_SURFACE_HEADER = "X-Aranova-Sdk-Surface";
 var SDK_ENVIRONMENT_HEADER = "X-Aranova-Sdk-Environment";
 
-// ../tracking-core/src/events/cta-click.ts
-var import_zod2 = require("zod");
-var ctaClickMetadataSchema = import_zod2.z.object({
-  cta_name: import_zod2.z.string(),
-  page: import_zod2.z.object({
-    path: import_zod2.z.string()
-  }).strict(),
-  section: import_zod2.z.string().nullable().optional(),
-  destination_url: import_zod2.z.string().nullable().optional(),
-  // Set by auto-capture (and available to manual callers): the link target
-  // and a short element descriptor (tag#id) for tying clicks to specific UI.
-  href: import_zod2.z.string().nullable().optional(),
-  element: import_zod2.z.string().nullable().optional()
-}).strict();
-var ctaClickConfigSchema = import_zod2.z.object({
-  autoCapture: import_zod2.z.object({
-    selector: import_zod2.z.string().optional()
-  }).strict().optional()
-}).strict();
-
-// ../tracking-core/src/events/sdk-heartbeat.ts
-var import_zod3 = require("zod");
-var sdkHeartbeatTriggersSchema = import_zod3.z.object({
-  automatic: import_zod3.z.array(import_zod3.z.string()),
-  manual: import_zod3.z.array(import_zod3.z.string())
-}).strict();
-var sdkHeartbeatMetadataSchema = import_zod3.z.object({
-  sdk_version: import_zod3.z.string(),
-  package_name: import_zod3.z.string().nullable(),
-  surface: import_zod3.z.enum(["next", "react", "script"]),
-  triggers: sdkHeartbeatTriggersSchema,
-  trigger_config: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())).nullable().optional(),
-  configured_gtag_ids: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).nullable().optional(),
-  // Site whose config object the SDK resolves; null on a legacy business ref.
-  config_site_id: import_zod3.z.string().uuid().nullable().optional()
-}).strict();
-var sdkHeartbeatConfigSchema = import_zod3.z.object({}).strict();
-
-// ../tracking-core/src/events/form-start.ts
-var import_zod4 = require("zod");
-var formStartMetadataSchema = import_zod4.z.object({
-  form: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    action: import_zod4.z.string().nullable()
-  }).strict(),
-  page: import_zod4.z.object({
-    path: import_zod4.z.string()
-  }).strict()
-}).strict();
-var formStartConfigSchema = import_zod4.z.object({
-  selector: import_zod4.z.string().optional()
-}).strict();
-
-// ../tracking-core/src/events/form-submit.ts
-var import_zod5 = require("zod");
-var jsonValueSchema = import_zod5.z.lazy(
-  () => import_zod5.z.union([
-    import_zod5.z.string(),
-    import_zod5.z.number().finite(),
-    import_zod5.z.boolean(),
-    import_zod5.z.null(),
-    import_zod5.z.array(jsonValueSchema),
-    import_zod5.z.record(jsonValueSchema)
-  ])
-);
-var formSubmitMetadataSchema = import_zod5.z.object({
-  form: import_zod5.z.object({
-    id: import_zod5.z.string(),
-    action: import_zod5.z.string().nullable(),
-    fields: import_zod5.z.array(
-      import_zod5.z.object({
-        name: import_zod5.z.string(),
-        type: import_zod5.z.string(),
-        label: import_zod5.z.string().nullable(),
-        value: jsonValueSchema
-      }).strict()
-    ).optional()
-  }).strict(),
-  page: import_zod5.z.object({
-    path: import_zod5.z.string()
-  }).strict()
-}).strict();
-var formSubmitConfigSchema = import_zod5.z.object({}).strict();
-
-// ../tracking-core/src/events/multi-page-session.ts
-var import_zod6 = require("zod");
-var multiPageSessionMetadataSchema = import_zod6.z.object({
-  page_count: import_zod6.z.number().int().min(2),
-  page: import_zod6.z.object({
-    path: import_zod6.z.string()
-  }).strict()
-}).strict();
-var multiPageSessionConfigSchema = import_zod6.z.object({
-  pageThreshold: import_zod6.z.number().int().min(2)
-}).strict();
-
-// ../tracking-core/src/events/page-exit.ts
-var import_zod7 = require("zod");
-var pageExitMetadataSchema = import_zod7.z.object({
-  dwell_ms: import_zod7.z.number().int().min(0),
-  // null = left without any scroll signal; floor is 0 so a valid 0% is never
-  // rejected (a single bad field 422s the whole keepalive beacon batch).
-  max_scroll_percent: import_zod7.z.number().int().min(0).max(100).nullable(),
-  // The gating baseline: the fraction of the page visible at load with
-  // zero scrolling — or, for pages that grew after the post-paint snapshot
-  // (skeleton/streaming renders), the first-scroll position that
-  // established it. null = page had no scrollable range, or the segment
-  // ended before the snapshot. `.optional()` is load-bearing: SDK builds
-  // predating this field keep POSTing page_exit without the key —
-  // requiring it would 422 whole keepalive beacon batches.
-  scroll_baseline_percent: import_zod7.z.number().int().min(0).max(100).nullable().optional(),
-  page: import_zod7.z.object({
-    path: import_zod7.z.string()
-  }).strict()
-}).strict();
-var pageExitConfigSchema = import_zod7.z.object({}).strict();
-
-// ../tracking-core/src/events/phone-click.ts
-var import_zod8 = require("zod");
-var phoneClickMetadataSchema = import_zod8.z.object({
-  phone_number: import_zod8.z.string(),
-  page: import_zod8.z.object({
-    path: import_zod8.z.string()
-  }).strict(),
-  section: import_zod8.z.string().nullable().optional()
-}).strict();
-var phoneClickConfigSchema = import_zod8.z.object({
-  autoCapture: import_zod8.z.object({
-    selector: import_zod8.z.string().optional()
-  }).strict().optional()
-}).strict();
-
-// ../tracking-core/src/events/scroll-depth.ts
-var import_zod9 = require("zod");
-var scrollDepthMetadataSchema = import_zod9.z.object({
-  depth_percent: import_zod9.z.number().int().min(1).max(100),
-  page: import_zod9.z.object({
-    path: import_zod9.z.string()
-  }).strict()
-}).strict();
-var scrollDepthConfigSchema = import_zod9.z.object({
-  thresholds: import_zod9.z.array(import_zod9.z.number().int().min(1).max(100)).min(1)
-}).strict();
-
-// ../tracking-core/src/events/specific-page-visit.ts
-var import_zod10 = require("zod");
-var PAGE_IDENTITY_MAX_LENGTH = 64;
-var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-var pageIdentitySchema = import_zod10.z.string().max(PAGE_IDENTITY_MAX_LENGTH).regex(PAGE_IDENTITY_PATTERN, {
-  message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
-});
-var specificPageNameSchema = pageIdentitySchema;
-var specificPageVisitMetadataSchema = import_zod10.z.object({
-  page_name: specificPageNameSchema,
-  page: import_zod10.z.object({
-    path: import_zod10.z.string()
-  }).strict()
-}).strict();
-var specificPageVisitConfigSchema = import_zod10.z.object({
-  pages: import_zod10.z.array(
-    import_zod10.z.object({
-      name: specificPageNameSchema,
-      pathPattern: import_zod10.z.custom((value) => value instanceof RegExp, {
-        message: "pathPattern must be a RegExp"
-      })
-    }).strict()
-  ).min(1)
-}).strict();
-
-// ../tracking-core/src/events/time-on-site.ts
-var import_zod11 = require("zod");
-var timeOnSiteMetadataSchema = import_zod11.z.object({
-  duration_ms: import_zod11.z.number().int().nonnegative(),
-  page: import_zod11.z.object({
-    path: import_zod11.z.string()
-  }).strict()
-}).strict();
-var timeOnSiteConfigSchema = import_zod11.z.object({
-  thresholdSeconds: import_zod11.z.number().int().positive()
-}).strict();
-
 // ../tracking-core/src/events/semantics.ts
 var EVENT_SEMANTICS = {
   page_view: {
@@ -1654,82 +1461,6 @@ function getEventSemantics(eventName) {
   return eventName in EVENT_SEMANTICS ? EVENT_SEMANTICS[eventName] : null;
 }
 
-// ../tracking-core/src/events/registry.ts
-var EVENT_REGISTRY = {
-  // --- automatic triggers ---
-  page_view: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.page_view,
-    metadataSchema: pageViewMetadataSchema,
-    configSchema: pageViewConfigSchema
-  },
-  time_on_site: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.time_on_site,
-    metadataSchema: timeOnSiteMetadataSchema,
-    configSchema: timeOnSiteConfigSchema
-  },
-  specific_page_visit: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.specific_page_visit,
-    metadataSchema: specificPageVisitMetadataSchema,
-    configSchema: specificPageVisitConfigSchema
-  },
-  scroll_depth: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.scroll_depth,
-    metadataSchema: scrollDepthMetadataSchema,
-    configSchema: scrollDepthConfigSchema
-  },
-  multi_page_session: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.multi_page_session,
-    metadataSchema: multiPageSessionMetadataSchema,
-    configSchema: multiPageSessionConfigSchema
-  },
-  form_start: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.form_start,
-    metadataSchema: formStartMetadataSchema,
-    configSchema: formStartConfigSchema
-  },
-  // --- SDK-internal automatic (not consumer-configurable) ---
-  sdk_heartbeat: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.sdk_heartbeat,
-    metadataSchema: sdkHeartbeatMetadataSchema,
-    configSchema: sdkHeartbeatConfigSchema
-  },
-  page_exit: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.page_exit,
-    metadataSchema: pageExitMetadataSchema,
-    configSchema: pageExitConfigSchema
-  },
-  // --- manual triggers ---
-  form_submit: {
-    kind: "manual",
-    semantics: EVENT_SEMANTICS.form_submit,
-    metadataSchema: formSubmitMetadataSchema,
-    configSchema: formSubmitConfigSchema
-  },
-  phone_click: {
-    kind: "manual",
-    semantics: EVENT_SEMANTICS.phone_click,
-    metadataSchema: phoneClickMetadataSchema,
-    configSchema: phoneClickConfigSchema
-  },
-  cta_click: {
-    kind: "manual",
-    semantics: EVENT_SEMANTICS.cta_click,
-    metadataSchema: ctaClickMetadataSchema,
-    configSchema: ctaClickConfigSchema
-  }
-};
-var ALL_AUTOMATIC_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "automatic").map(([name]) => name);
-var ALL_MANUAL_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "manual").map(([name]) => name);
-var ALL_LEAD_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.semantics.outcomeRole === "lead").map(([name]) => name);
-
 // ../tracking-core/src/resources/http/errors.ts
 var AranovaApiError = class extends Error {
   constructor(message, options) {
@@ -1767,9 +1498,9 @@ async function apiRequest(config, method, path, body, extraHeaders) {
     try {
       const parsed = await response.json();
       if (parsed && typeof parsed === "object") {
-        const record = parsed;
-        if (typeof record.detail === "string") detail = record.detail;
-        if (typeof record.code === "string") code = record.code;
+        const record5 = parsed;
+        if (typeof record5.detail === "string") detail = record5.detail;
+        if (typeof record5.code === "string") code = record5.code;
       }
     } catch {
     }
@@ -1818,7 +1549,7 @@ function fireRecordedConversions(firing, input, recorded, sale, currency) {
 }
 function createSalesClient(config) {
   if (config.firing) registerCapability("conversion_goals_manual");
-  async function record(input) {
+  async function record5(input) {
     const currency = input.currency ?? config.defaultCurrency;
     if (!currency) {
       throw new Error(
@@ -1844,9 +1575,9 @@ function createSalesClient(config) {
     return sale;
   }
   return {
-    record,
+    record: record5,
     // recordSale is the intent-revealing alias — same behavior, clearer call site.
-    recordSale: record,
+    recordSale: record5,
     trackConversion(key, options) {
       if (config.firing && "fireConversion" in config.firing) {
         if (options?.userData && getConsentState() !== "denied") stashUserData(options.userData);
@@ -1965,115 +1696,264 @@ function createSalesClient(config) {
 }
 
 // ../tracking-core/src/resources/sales/schema.ts
-var import_zod12 = require("zod");
-var SUPPORTED_CURRENCIES = ["USD", "CAD"];
-var TRACKING_ENVIRONMENTS = ["production", "development"];
-var currencySchema = import_zod12.z.enum(SUPPORTED_CURRENCIES);
-var centsSchema = import_zod12.z.number().int().nonnegative();
-var quantitySchema = import_zod12.z.string().regex(/^\d+(\.\d{1,3})?$/);
-var metadataSchema = import_zod12.z.record(import_zod12.z.unknown());
-var saleItemSchema = import_zod12.z.object({
-  external_item_id: import_zod12.z.string().nullable().optional(),
-  name: import_zod12.z.string().nullable().optional(),
-  category: import_zod12.z.string().nullable().optional(),
-  quantity: quantitySchema,
-  unit_price_cents: centsSchema,
-  // Non-negativity validated on the wire — same contract as the other cents
-  // fields — and backstopped by the DB CHECK.
-  unit_cost_cents: centsSchema.nullable().optional()
-}).strict();
-var saleServiceSchema = import_zod12.z.object({
-  service: import_zod12.z.string(),
-  amount_cents: centsSchema
-}).strict();
-var customerNameSchema = import_zod12.z.string().max(200);
-var customerPhoneSchema = import_zod12.z.string().max(64);
-var customerEmailSchema = import_zod12.z.string().max(320).email();
+var z2 = __toESM(require("zod/mini"));
+
+// ../tracking-core/src/resources/sales/generated/zod.gen.ts
+var z = __toESM(require("zod/mini"));
+var zErrorCode = z.enum([
+  "missing_credentials",
+  "invalid_api_key",
+  "not_authenticated",
+  "wrong_key_type",
+  "origin_missing",
+  "origin_not_allowed",
+  "capability_denied",
+  "session_required",
+  "operator_only",
+  "cross_tenant",
+  "business_id_required",
+  "bad_request",
+  "not_found",
+  "conflict",
+  "incompatible_payload",
+  "repeat_confirmation_required",
+  "idempotency_conflict",
+  "validation_error",
+  "unknown_service",
+  "invalid_sale_properties",
+  "invalid_cursor",
+  "rate_limited",
+  "internal_error"
+]);
+var zSaleItemEntitySchema = z.object({
+  category: z.nullable(z.string()),
+  external_item_id: z.nullable(z.string()),
+  id: z.uuid(),
+  name: z.nullable(z.string()),
+  quantity: z.string().check(z.regex(/^(?!^[-+.]*$)[+-]?0*\d*\.?\d*$/)),
+  unit_cost_cents: z.nullable(z.int()),
+  unit_price_cents: z.int()
+});
+var zSaleItemInputSchema = z.strictObject({
+  category: z.nullish(z.string()),
+  external_item_id: z.nullish(z.string()),
+  name: z.nullish(z.string()),
+  quantity: z.string().check(z.regex(/^\d+(\.\d{1,3})?$/)),
+  unit_cost_cents: z.nullish(z.int().check(z.gte(0))),
+  unit_price_cents: z.int().check(z.gte(0))
+});
+var zSaleServiceEntitySchema = z.object({
+  amount_cents: z.int(),
+  id: z.uuid(),
+  mapped: z.nullable(z.boolean()),
+  service_id: z.uuid(),
+  service_key: z.string(),
+  service_label: z.string()
+});
+var zSaleServiceInputSchema = z.strictObject({
+  amount_cents: z.int().check(z.gte(0)),
+  service: z.string()
+});
+var zSmsAutomationState = z.enum([
+  "needs_check",
+  "failed",
+  "undelivered",
+  "blocked_opted_out",
+  "withheld",
+  "queued",
+  "sent",
+  "delivered",
+  "eligible",
+  "not_applicable"
+]);
+var zSmsWithheldReason = z.enum([
+  "automation_disabled",
+  "sms_disabled",
+  "no_phone",
+  "no_consent",
+  "no_customer_identity",
+  "missing_customer_name",
+  "placeholder_customer_name",
+  "opted_out",
+  "already_messaged",
+  "sender_not_ready",
+  "missing_review_url",
+  "no_handler",
+  "dispatch_already_recorded"
+]);
+var zSaleSmsStatusSchema = z.object({
+  can_send_now: z._default(z.boolean(), false),
+  last_message_at: z.nullable(z.iso.datetime({ offset: true })),
+  reason_detail: z.nullable(z.string()),
+  state: zSmsAutomationState,
+  suppressed_by_other_sale: z._default(z.boolean(), false),
+  withheld_reason: z.nullable(zSmsWithheldReason)
+});
+var zSupportedCurrency = z.enum(["USD", "CAD"]);
+var zTrackingEnvironment = z.enum(["production", "development"]);
+var zSaleCreateSchema = z.strictObject({
+  amount_total_cents: z.nullish(z.int().check(z.gte(0))),
+  currency: zSupportedCurrency,
+  customer_email: z.nullish(z.email().check(z.maxLength(320))),
+  customer_name: z.nullish(z.string().check(z.maxLength(200))),
+  customer_phone: z.nullish(z.string().check(z.maxLength(64))),
+  description: z.nullish(z.string()),
+  environment: z._default(z.optional(zTrackingEnvironment), "production"),
+  external_id: z.nullish(z.string()),
+  items: z.optional(z.array(zSaleItemInputSchema)),
+  metadata: z.nullish(z.record(z.string(), z.unknown())),
+  occurred_at: z.iso.datetime({ offset: true }),
+  service: z.nullish(z.string()),
+  services: z.nullish(z.array(zSaleServiceInputSchema)),
+  sms_consent: z.nullish(z.boolean())
+});
+var zValidationError = z.object({
+  ctx: z.optional(z.record(z.string(), z.unknown())),
+  input: z.optional(z.unknown()),
+  loc: z.array(z.union([z.string(), z.int()])),
+  msg: z.string(),
+  type: z.string()
+});
+var zHttpValidationError = z.object({
+  detail: z.optional(z.array(zValidationError))
+});
+var zValidationErrorItem = z.object({
+  loc: z.array(z.union([z.string(), z.int()])),
+  msg: z.string(),
+  type: z.string()
+});
+var zApiErrorSchema = z.object({
+  code: zErrorCode,
+  context: z._default(z.nullish(z.record(z.string(), z.unknown())), null),
+  detail: z.string(),
+  errors: z._default(z.nullish(z.array(zValidationErrorItem)), null),
+  request_id: z._default(z.nullish(z.string()), null)
+});
+var zWritebackEmailSource = z.enum(["NONE", "SALE", "CUSTOMER", "HARVESTED"]);
+var zWritebackEnrichmentStatus = z.enum(["NONE", "MATCHED", "AMBIGUOUS"]);
+var zWritebackSaleUploadCounts = z.object({
+  failed: z._default(z.int(), 0),
+  pending: z._default(z.int(), 0),
+  skipped: z._default(z.int(), 0),
+  submitted: z._default(z.int(), 0),
+  total: z._default(z.int(), 0),
+  uploaded: z._default(z.int(), 0)
+});
+var zSaleWritebackStatusSchema = z.object({
+  blocked_reason: z.nullable(z.string()),
+  can_dispatch: z._default(z.boolean(), false),
+  email_source: z.nullable(zWritebackEmailSource),
+  enrichment_status: z.nullable(zWritebackEnrichmentStatus),
+  gclid_attached: z._default(z.boolean(), false),
+  identifiers_sent: z.nullable(z.string()),
+  mapped_service_ids: z.array(z.uuid()),
+  matched_submit_count: z.nullable(z.int()),
+  needs_force: z._default(z.boolean(), false),
+  rollup: z.enum([
+    "failed",
+    "skipped",
+    "pending",
+    "submitted",
+    "uploaded",
+    "not_uploaded",
+    "out_of_window",
+    "blocked"
+  ]),
+  stale: z._default(z.boolean(), false),
+  uncovered_service_ids: z.array(z.uuid()),
+  uploads: zWritebackSaleUploadCounts
+});
+var zSaleEntitySchema = z.object({
+  amount_total_cents: z.int(),
+  business_id: z.uuid(),
+  business_name: z.nullable(z.string()),
+  created_at: z.iso.datetime({ offset: true }),
+  currency: z.string(),
+  customer_email: z.nullable(z.string()),
+  customer_name: z.nullable(z.string()),
+  customer_name_placeholder_confirmed: z._default(z.boolean(), false),
+  customer_name_placeholder_confirmed_at: z.nullable(z.iso.datetime({ offset: true })),
+  customer_phone: z.nullable(z.string()),
+  description: z.nullable(z.string()),
+  environment: zTrackingEnvironment,
+  external_id: z.nullable(z.string()),
+  id: z.uuid(),
+  items: z.array(zSaleItemEntitySchema),
+  metadata: z.nullable(z.record(z.string(), z.unknown())),
+  occurred_at: z.iso.datetime({ offset: true }),
+  service_id: z.nullable(z.uuid()),
+  service_key: z.nullable(z.string()),
+  service_label: z.nullable(z.string()),
+  services: z.array(zSaleServiceEntitySchema),
+  sms_automation: z.nullable(zSaleSmsStatusSchema),
+  sms_consent: z._default(z.boolean(), false),
+  sms_consent_granted_at: z.nullable(z.iso.datetime({ offset: true })),
+  updated_at: z.iso.datetime({ offset: true }),
+  writeback: z.nullable(zSaleWritebackStatusSchema)
+});
+
+// ../tracking-core/src/resources/sales/schema.ts
+var saleItemSchema = zSaleItemInputSchema;
+var saleServiceSchema = zSaleServiceInputSchema;
+var currencySchema = zSupportedCurrency;
+var SUPPORTED_CURRENCIES = currencySchema.options;
+var centsSchema = z2.int().check(z2.gte(0));
+var metadataSchema = z2.record(z2.string(), z2.unknown());
+var customerNameSchema = z2.string().check(z2.maxLength(200));
+var customerPhoneSchema = z2.string().check(z2.maxLength(64));
+var customerEmailSchema = z2.email().check(z2.maxLength(320));
+function addIssue(ctx, path, message) {
+  ctx.issues.push({ code: "custom", input: ctx.value, path, message });
+}
 function refineServiceXor(val, ctx, { requireAmount }) {
   if (val.services != null) {
     if (val.service != null) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "pass either `service` or `services`, not both",
-        path: ["services"]
-      });
+      addIssue(ctx, ["services"], "pass either `service` or `services`, not both");
     }
     if (val.services.length === 0) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "`services` must not be empty",
-        path: ["services"]
-      });
+      addIssue(ctx, ["services"], "`services` must not be empty");
     }
     const keys = val.services.map((s) => s.service);
     if (new Set(keys).size !== keys.length) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "`services` must not list the same service more than once",
-        path: ["services"]
-      });
+      addIssue(ctx, ["services"], "`services` must not list the same service more than once");
     }
     if (val.amount_total_cents != null) {
       const sum = val.services.reduce((acc, s) => acc + s.amount_cents, 0);
       if (val.amount_total_cents !== sum) {
-        ctx.addIssue({
-          code: import_zod12.z.ZodIssueCode.custom,
-          message: "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)",
-          path: ["amount_total_cents"]
-        });
+        addIssue(
+          ctx,
+          ["amount_total_cents"],
+          "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)"
+        );
       }
     }
   } else if (requireAmount && val.amount_total_cents == null) {
-    ctx.addIssue({
-      code: import_zod12.z.ZodIssueCode.custom,
-      message: "amount_total_cents is required unless `services` is provided",
-      path: ["amount_total_cents"]
-    });
+    addIssue(
+      ctx,
+      ["amount_total_cents"],
+      "amount_total_cents is required unless `services` is provided"
+    );
   }
 }
-var saleCreateSchema = import_zod12.z.object({
-  external_id: import_zod12.z.string().nullable().optional(),
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema,
-  // Optional only because the plural `services` form derives it from the sum
-  // (see refineServiceXor); the singular/serviceless path still requires it.
-  amount_total_cents: centsSchema.nullable().optional(),
-  occurred_at: import_zod12.z.string().datetime(),
-  environment: import_zod12.z.enum(TRACKING_ENVIRONMENTS).default("production"),
-  items: import_zod12.z.array(saleItemSchema).default([]),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
-  // CASL consent attestation: the customer agreed to receive SMS. Recorded
-  // with a timestamp server-side; every SMS send path gates on it.
-  //
-  // Tri-state: omit it (or send null) to let the server apply the business's
-  // configured default-opt-in policy, honouring a returning customer's
-  // remembered preference. Send an explicit boolean to assert consent state
-  // yourself — `false` records a deliberate opt-out.
-  sms_consent: import_zod12.z.boolean().nullable().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
-var saleUpdateSchema = import_zod12.z.object({
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema.optional(),
-  amount_total_cents: centsSchema.optional(),
-  occurred_at: import_zod12.z.string().datetime().optional(),
-  items: import_zod12.z.array(saleItemSchema).optional(),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
+var saleCreateSchema = z2.extend(zSaleCreateSchema, { items: z2._default(z2.array(saleItemSchema), []) }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: true }));
+var saleUpdateSchema = z2.strictObject({
+  description: z2.nullish(z2.string()),
+  service: z2.nullish(z2.string()),
+  services: z2.nullish(z2.array(saleServiceSchema)),
+  currency: z2.optional(currencySchema),
+  amount_total_cents: z2.optional(centsSchema),
+  occurred_at: z2.optional(z2.iso.datetime()),
+  items: z2.optional(z2.array(saleItemSchema)),
+  metadata: z2.nullish(metadataSchema),
+  customer_name: z2.nullish(customerNameSchema),
   // Re-attest when changing a filler-looking name; the server clears the
   // prior attestation whenever `customer_name` changes.
-  customer_name_placeholder_confirmed: import_zod12.z.boolean().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
+  customer_name_placeholder_confirmed: z2.optional(z2.boolean()),
+  customer_phone: z2.nullish(customerPhoneSchema),
+  customer_email: z2.nullish(customerEmailSchema),
   // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
-  sms_consent: import_zod12.z.boolean().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: false }));
+  sms_consent: z2.optional(z2.boolean())
+}).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: false }));
 var TRACKING_RANGES = ["24h", "7d", "30d"];
 var NAMED_RANGES = [
   "today",
@@ -2144,8 +2024,8 @@ function instantFromWallClock(timeZone, year, month, day, hour = 0, minute = 0)
   const corrected = naive - offsetMinutesAt(firstGuess, timeZone) * 6e4;
   return new Date(corrected);
 }
-function localDateKey(iso, timeZone) {
-  const p = partsInTz(new Date(iso), timeZone);
+function localDateKey(iso4, timeZone) {
+  const p = partsInTz(new Date(iso4), timeZone);
   const pad = (n) => String(n).padStart(2, "0");
   return `${p.year}-${pad(p.month)}-${pad(p.day)}`;
 }
@@ -2200,7 +2080,167 @@ function isCalendarError(error, code) {
 }
 
 // ../tracking-core/src/resources/calendar/schema.ts
-var import_zod13 = require("zod");
+var z4 = __toESM(require("zod/mini"));
+
+// ../tracking-core/src/resources/calendar/generated/zod.gen.ts
+var z3 = __toESM(require("zod/mini"));
+var zBookingAttendee = z3.strictObject({
+  display_name: z3.nullish(z3.string().check(z3.maxLength(200))),
+  email: z3.email().check(z3.maxLength(320)),
+  optional: z3._default(z3.optional(z3.boolean()), false)
+});
+var zBookingCancelSchema = z3.strictObject({
+  notify_attendees: z3._default(z3.optional(z3.boolean()), true),
+  reason: z3.nullish(z3.string().check(z3.maxLength(500)))
+});
+var zBookingCustomerInput = z3.strictObject({
+  email: z3.email().check(z3.maxLength(320)),
+  name: z3.nullish(z3.string().check(z3.maxLength(200))),
+  phone: z3.nullish(z3.string().check(z3.maxLength(64))),
+  sms_consent: z3._default(z3.optional(z3.boolean()), false)
+});
+var zBookingCustomerOutput = z3.strictObject({
+  email: z3.email().check(z3.maxLength(320)),
+  name: z3.nullable(z3.string().check(z3.maxLength(200))),
+  phone: z3.nullable(z3.string().check(z3.maxLength(64))),
+  sms_consent: z3._default(z3.boolean(), false)
+});
+var zBookingRescheduleSchema = z3.strictObject({
+  duration_minutes: z3.nullish(z3.int().check(z3.gt(0), z3.lte(1440))),
+  end_at: z3.nullish(z3.iso.datetime({ offset: true })),
+  notify_attendees: z3._default(z3.optional(z3.boolean()), true),
+  reason: z3.nullish(z3.string().check(z3.maxLength(500))),
+  start_at: z3.iso.datetime({ offset: true }),
+  time_zone: z3.string().check(z3.minLength(1), z3.maxLength(64), z3.regex(/^[A-Za-z0-9_+\-\/]+$/))
+});
+var zBookingResponse = z3.strictObject({
+  appointment_type: z3.nullable(z3.string()),
+  calendar_key: z3.string(),
+  customer: zBookingCustomerOutput,
+  end_at: z3.iso.datetime({ offset: true }),
+  google_html_link: z3.nullable(z3.string()),
+  google_sync_state: z3.string(),
+  id: z3.string(),
+  manage_token: z3.nullable(z3.string()),
+  meet_url: z3.nullable(z3.string()),
+  start_at: z3.iso.datetime({ offset: true }),
+  status: z3.string(),
+  time_zone: z3.string(),
+  title: z3.string()
+});
+var zBookingSource = z3.enum(["website", "phone", "walk_in", "import", "operator"]);
+var zBookingMetadata = z3.strictObject({
+  custom: z3.nullish(
+    z3.record(z3.string(), z3.nullable(z3.union([z3.string(), z3.int(), z3.number(), z3.boolean()])))
+  ),
+  fbclid: z3.nullish(z3.string().check(z3.maxLength(256))),
+  gclid: z3.nullish(z3.string().check(z3.maxLength(256))),
+  landing_page: z3.nullish(z3.string().check(z3.maxLength(2048))),
+  notes: z3.nullish(z3.string().check(z3.maxLength(2e3))),
+  referrer: z3.nullish(z3.string().check(z3.maxLength(2048))),
+  schema_version: z3._default(z3.optional(z3.int()), 1),
+  service: z3.nullish(z3.string().check(z3.maxLength(64))),
+  session_id: z3.nullish(z3.string().check(z3.maxLength(64))),
+  source: z3.nullish(zBookingSource),
+  utm_campaign: z3.nullish(z3.string().check(z3.maxLength(128))),
+  utm_content: z3.nullish(z3.string().check(z3.maxLength(128))),
+  utm_medium: z3.nullish(z3.string().check(z3.maxLength(128))),
+  utm_source: z3.nullish(z3.string().check(z3.maxLength(128))),
+  utm_term: z3.nullish(z3.string().check(z3.maxLength(128))),
+  visitor_id: z3.nullish(z3.string().check(z3.maxLength(64)))
+});
+var zCustomLocation = z3.strictObject({
+  kind: z3.literal("custom"),
+  text: z3.string().check(z3.maxLength(1024))
+});
+var zErrorCode2 = z3.enum([
+  "missing_credentials",
+  "invalid_api_key",
+  "not_authenticated",
+  "wrong_key_type",
+  "origin_missing",
+  "origin_not_allowed",
+  "capability_denied",
+  "session_required",
+  "operator_only",
+  "cross_tenant",
+  "business_id_required",
+  "bad_request",
+  "not_found",
+  "conflict",
+  "incompatible_payload",
+  "repeat_confirmation_required",
+  "idempotency_conflict",
+  "validation_error",
+  "unknown_service",
+  "invalid_sale_properties",
+  "invalid_cursor",
+  "rate_limited",
+  "internal_error"
+]);
+var zMeetLocation = z3.strictObject({
+  kind: z3.literal("google_meet")
+});
+var zPhoneLocation = z3.strictObject({
+  kind: z3.literal("phone"),
+  phone: z3.string().check(z3.maxLength(64))
+});
+var zPhysicalLocation = z3.strictObject({
+  address: z3.string().check(z3.maxLength(1024)),
+  kind: z3.literal("physical")
+});
+var zReminderMethod = z3.enum(["email", "popup"]);
+var zBookingReminder = z3.strictObject({
+  method: zReminderMethod,
+  minutes_before: z3.int().check(z3.gte(0), z3.lte(40320))
+});
+var zBookingReminders = z3.strictObject({
+  overrides: z3.optional(z3.array(zBookingReminder).check(z3.maxLength(5))),
+  use_calendar_defaults: z3._default(z3.optional(z3.boolean()), true)
+});
+var zBookingCreateSchema = z3.strictObject({
+  appointment_type: z3.nullish(z3.string().check(z3.maxLength(64))),
+  attendees: z3.optional(z3.array(zBookingAttendee).check(z3.maxLength(20))),
+  buffer_after_minutes: z3._default(z3.optional(z3.int().check(z3.gte(0), z3.lte(1440))), 0),
+  buffer_before_minutes: z3._default(z3.optional(z3.int().check(z3.gte(0), z3.lte(1440))), 0),
+  calendar_key: z3.string().check(z3.minLength(1), z3.maxLength(64)),
+  customer: zBookingCustomerInput,
+  description: z3.nullish(z3.string().check(z3.maxLength(8e3))),
+  duration_minutes: z3.nullish(z3.int().check(z3.gt(0), z3.lte(1440))),
+  end_at: z3.nullish(z3.iso.datetime({ offset: true })),
+  idempotency_key: z3.nullish(z3.string().check(z3.maxLength(128))),
+  location: z3.nullish(z3.union([zMeetLocation, zPhysicalLocation, zPhoneLocation, zCustomLocation])),
+  metadata: z3.nullish(zBookingMetadata),
+  reminders: z3.nullish(zBookingReminders),
+  send_invites: z3._default(z3.optional(z3.boolean()), true),
+  start_at: z3.iso.datetime({ offset: true }),
+  time_zone: z3.string().check(z3.minLength(1), z3.maxLength(64), z3.regex(/^[A-Za-z0-9_+\-\/]+$/)),
+  title: z3.nullish(z3.string().check(z3.maxLength(300)))
+});
+var zValidationError2 = z3.object({
+  ctx: z3.optional(z3.record(z3.string(), z3.unknown())),
+  input: z3.optional(z3.unknown()),
+  loc: z3.array(z3.union([z3.string(), z3.int()])),
+  msg: z3.string(),
+  type: z3.string()
+});
+var zHttpValidationError2 = z3.object({
+  detail: z3.optional(z3.array(zValidationError2))
+});
+var zValidationErrorItem2 = z3.object({
+  loc: z3.array(z3.union([z3.string(), z3.int()])),
+  msg: z3.string(),
+  type: z3.string()
+});
+var zApiErrorSchema2 = z3.object({
+  code: zErrorCode2,
+  context: z3._default(z3.nullish(z3.record(z3.string(), z3.unknown())), null),
+  detail: z3.string(),
+  errors: z3._default(z3.nullish(z3.array(zValidationErrorItem2)), null),
+  request_id: z3._default(z3.nullish(z3.string()), null)
+});
+
+// ../tracking-core/src/resources/calendar/schema.ts
 var CALENDAR_METADATA_SCHEMA_VERSION = 1;
 var MAX_ATTENDEES = 20;
 var MAX_REMINDER_OVERRIDES = 5;
@@ -2226,7 +2266,6 @@ var CALENDAR_ERROR_CODES = [
   "rate_limited",
   "google_error"
 ];
-var isoInstant = import_zod13.z.string().datetime({ offset: true });
 function isKnownTimeZone(timeZone) {
   try {
     new Intl.DateTimeFormat(void 0, { timeZone });
@@ -2235,107 +2274,65 @@ function isKnownTimeZone(timeZone) {
     return false;
   }
 }
-var ianaTz = import_zod13.z.string().min(1).max(64).regex(/^[A-Za-z0-9_+\-/]+$/).refine(isKnownTimeZone, { message: "unknown IANA time zone" });
-var bookingAttendeeSchema = import_zod13.z.object({
-  email: import_zod13.z.string().max(320).email(),
-  display_name: import_zod13.z.string().max(200).nullable().optional(),
-  optional: import_zod13.z.boolean().default(false)
-}).strict();
-var bookingReminderSchema = import_zod13.z.object({
-  method: import_zod13.z.enum(["email", "popup"]),
-  minutes_before: import_zod13.z.number().int().min(0).max(MAX_REMINDER_MINUTES)
-}).strict();
-var bookingRemindersSchema = import_zod13.z.object({
-  use_calendar_defaults: import_zod13.z.boolean().default(true),
-  overrides: import_zod13.z.array(bookingReminderSchema).max(MAX_REMINDER_OVERRIDES).default([])
-}).strict();
-var bookingLocationSchema = import_zod13.z.union([
-  import_zod13.z.object({ kind: import_zod13.z.literal("google_meet") }).strict(),
-  import_zod13.z.object({ kind: import_zod13.z.literal("physical"), address: import_zod13.z.string().max(1024) }).strict(),
-  import_zod13.z.object({ kind: import_zod13.z.literal("phone"), phone: import_zod13.z.string().max(64) }).strict(),
-  import_zod13.z.object({ kind: import_zod13.z.literal("custom"), text: import_zod13.z.string().max(1024) }).strict()
+var ianaTz = z4.string().check(
+  z4.minLength(1),
+  z4.maxLength(64),
+  z4.regex(/^[A-Za-z0-9_+\-/]+$/),
+  z4.refine(isKnownTimeZone, { error: "unknown IANA time zone" })
+);
+var bookingAttendeeSchema = zBookingAttendee;
+var bookingReminderSchema = zBookingReminder;
+var bookingCustomerSchema = zBookingCustomerInput;
+var bookingMetadataSchema = z4.extend(zBookingMetadata, {
+  custom: z4.nullish(
+    z4.record(z4.string(), z4.union([z4.string(), z4.int(), z4.number(), z4.boolean(), z4.null()]))
+  )
+});
+var bookingLocationSchema = z4.union([
+  zMeetLocation,
+  zPhysicalLocation,
+  zPhoneLocation,
+  zCustomLocation
 ]);
-var bookingLocationNullableSchema = import_zod13.z.union([...bookingLocationSchema.options, import_zod13.z.null()]);
-var bookingCustomerSchema = import_zod13.z.object({
-  // Required: Google needs an address to send the invite that confirms the
-  // booking, and that invite is the whole confirmation mechanism.
-  email: import_zod13.z.string().max(320).email(),
-  name: import_zod13.z.string().max(200).nullable().optional(),
-  phone: import_zod13.z.string().max(64).nullable().optional(),
-  sms_consent: import_zod13.z.boolean().default(false)
-}).strict();
-var jsonScalar = import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number(), import_zod13.z.boolean(), import_zod13.z.null()]);
-var bookingMetadataSchema = import_zod13.z.object({
-  schema_version: import_zod13.z.number().int().default(CALENDAR_METADATA_SCHEMA_VERSION),
-  source: import_zod13.z.enum(BOOKING_SOURCES).nullable().optional(),
-  service: import_zod13.z.string().max(64).nullable().optional(),
-  visitor_id: import_zod13.z.string().max(64).nullable().optional(),
-  session_id: import_zod13.z.string().max(64).nullable().optional(),
-  gclid: import_zod13.z.string().max(256).nullable().optional(),
-  fbclid: import_zod13.z.string().max(256).nullable().optional(),
-  utm_source: import_zod13.z.string().max(128).nullable().optional(),
-  utm_medium: import_zod13.z.string().max(128).nullable().optional(),
-  utm_campaign: import_zod13.z.string().max(128).nullable().optional(),
-  utm_term: import_zod13.z.string().max(128).nullable().optional(),
-  utm_content: import_zod13.z.string().max(128).nullable().optional(),
-  landing_page: import_zod13.z.string().max(2048).nullable().optional(),
-  referrer: import_zod13.z.string().max(2048).nullable().optional(),
-  notes: import_zod13.z.string().max(2e3).nullable().optional(),
-  custom: import_zod13.z.record(jsonScalar).nullable().optional()
-}).strict();
+var bookingLocationNullableSchema = z4.union([
+  ...bookingLocationSchema.def.options,
+  z4.null()
+]);
+function addIssue2(ctx, path, message) {
+  ctx.issues.push({ code: "custom", input: ctx.value, path, message });
+}
 function refineEndXor(value, ctx) {
   const hasEnd = value.end_at !== void 0 && value.end_at !== null;
   const hasDuration = value.duration_minutes !== void 0 && value.duration_minutes !== null;
   if (hasEnd === hasDuration) {
-    ctx.addIssue({
-      code: import_zod13.z.ZodIssueCode.custom,
-      message: "provide exactly one of end_at or duration_minutes",
-      path: ["end_at"]
-    });
+    addIssue2(ctx, ["end_at"], "provide exactly one of end_at or duration_minutes");
     return;
   }
   if (hasEnd && new Date(value.end_at) <= new Date(value.start_at)) {
-    ctx.addIssue({
-      code: import_zod13.z.ZodIssueCode.custom,
-      message: "end_at must be after start_at",
-      path: ["end_at"]
-    });
+    addIssue2(ctx, ["end_at"], "end_at must be after start_at");
   }
 }
-var bookingCreateSchema = import_zod13.z.object({
-  calendar_key: import_zod13.z.string().min(1).max(64),
-  // Free-form: appointment types are the client site's own vocabulary, not
-  // configuration the dashboard holds.
-  appointment_type: import_zod13.z.string().max(64).nullable().optional(),
-  start_at: isoInstant,
-  end_at: isoInstant.nullable().optional(),
-  duration_minutes: import_zod13.z.number().int().positive().max(MAX_BOOKING_MINUTES).nullable().optional(),
-  /** The booker's zone — distinct from the business's and the calendar's. */
-  time_zone: ianaTz,
-  title: import_zod13.z.string().max(300).nullable().optional(),
-  description: import_zod13.z.string().max(8e3).nullable().optional(),
-  location: bookingLocationNullableSchema.optional(),
-  customer: bookingCustomerSchema,
-  attendees: import_zod13.z.array(bookingAttendeeSchema).max(MAX_ATTENDEES).default([]),
-  send_invites: import_zod13.z.boolean().default(true),
-  reminders: bookingRemindersSchema.nullable().optional(),
-  metadata: bookingMetadataSchema.nullable().optional(),
-  idempotency_key: import_zod13.z.string().max(128).nullable().optional(),
-  buffer_before_minutes: import_zod13.z.number().int().min(0).max(MAX_BOOKING_MINUTES).default(0),
-  buffer_after_minutes: import_zod13.z.number().int().min(0).max(MAX_BOOKING_MINUTES).default(0)
-}).strict().superRefine(refineEndXor);
-var bookingRescheduleSchema = import_zod13.z.object({
-  start_at: isoInstant,
-  end_at: isoInstant.nullable().optional(),
-  duration_minutes: import_zod13.z.number().int().positive().max(MAX_BOOKING_MINUTES).nullable().optional(),
+var bookingRemindersSchema = z4.extend(zBookingReminders, {
+  overrides: z4._default(
+    z4.array(bookingReminderSchema).check(z4.maxLength(MAX_REMINDER_OVERRIDES)),
+    []
+  )
+});
+var bookingCreateSchema = z4.extend(zBookingCreateSchema, {
   time_zone: ianaTz,
-  notify_attendees: import_zod13.z.boolean().default(true),
-  reason: import_zod13.z.string().max(500).nullable().optional()
-}).strict().superRefine(refineEndXor);
-var bookingCancelSchema = import_zod13.z.object({
-  reason: import_zod13.z.string().max(500).nullable().optional(),
-  notify_attendees: import_zod13.z.boolean().default(true)
-}).strict();
+  // The generated field is `z.union([...variants]).nullish()`, which nests one
+  // `anyOf` inside another; Pydantic's `BookingLocation | None` flattens to a
+  // single list and the drift snapshot compares structure. Override with the
+  // flattened union.
+  location: z4.optional(bookingLocationNullableSchema),
+  attendees: z4._default(z4.array(bookingAttendeeSchema).check(z4.maxLength(MAX_ATTENDEES)), []),
+  // These reference the un-composed generated schemas; generation can't nest
+  // our compositions into its own output.
+  reminders: z4.nullish(bookingRemindersSchema),
+  metadata: z4.nullish(bookingMetadataSchema)
+}).check((ctx) => refineEndXor(ctx.value, ctx));
+var bookingRescheduleSchema = z4.extend(zBookingRescheduleSchema, { time_zone: ianaTz }).check((ctx) => refineEndXor(ctx.value, ctx));
+var bookingCancelSchema = zBookingCancelSchema;
 
 // ../tracking-core/src/resources/calendar/slots.ts
 function parseHhMm(value) {
@@ -2563,6 +2560,7 @@ var import_client2 = require("@aranova/tracking-next/client");
   createTrackingClientContext,
   createTrackingEventCreatePayload,
   createTrackingSessionUpsertPayload,
+  currencySchema,
   durationMinutes,
   endOfDayInTz,
   fetchServices,