@happyvertical/smrt-ads 0.30.0

package/dist/index.js

@@ -0,0 +1,1121 @@
+import { ObjectRegistry, smrt, SmrtObject, SmrtCollection, foreignKey, crossPackageRef } from "@happyvertical/smrt-core";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+var AdFormatType = /* @__PURE__ */ ((AdFormatType2) => {
+  AdFormatType2["BANNER"] = "banner";
+  AdFormatType2["NATIVE"] = "native";
+  AdFormatType2["VIDEO"] = "video";
+  return AdFormatType2;
+})(AdFormatType || {});
+var PricingModel = /* @__PURE__ */ ((PricingModel2) => {
+  PricingModel2["FIXED"] = "fixed";
+  PricingModel2["CPM"] = "cpm";
+  PricingModel2["CPC"] = "cpc";
+  PricingModel2["CPA"] = "cpa";
+  return PricingModel2;
+})(PricingModel || {});
+var AdGroupStatus = /* @__PURE__ */ ((AdGroupStatus2) => {
+  AdGroupStatus2["DRAFT"] = "draft";
+  AdGroupStatus2["ACTIVE"] = "active";
+  AdGroupStatus2["PAUSED"] = "paused";
+  AdGroupStatus2["COMPLETED"] = "completed";
+  return AdGroupStatus2;
+})(AdGroupStatus || {});
+var AdVariationStatus = /* @__PURE__ */ ((AdVariationStatus2) => {
+  AdVariationStatus2["DRAFT"] = "draft";
+  AdVariationStatus2["ACTIVE"] = "active";
+  AdVariationStatus2["PAUSED"] = "paused";
+  return AdVariationStatus2;
+})(AdVariationStatus || {});
+var AdEventType = /* @__PURE__ */ ((AdEventType2) => {
+  AdEventType2["IMPRESSION"] = "impression";
+  AdEventType2["CLICK"] = "click";
+  AdEventType2["CONVERSION"] = "conversion";
+  return AdEventType2;
+})(AdEventType || {});
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let AdDeliveryTier = class extends SmrtObject {
+  /**
+   * Display name (e.g., "Sponsorship", "Standard", "House")
+   */
+  name = "";
+  /**
+   * Priority level (lower = higher priority: 1, 2, 3...)
+   */
+  priority = 0;
+  /**
+   * Pricing model for this tier
+   */
+  pricingModel = PricingModel.CPM;
+  /**
+   * Optional description
+   */
+  description = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.priority !== void 0) this.priority = options.priority;
+    if (options.pricingModel !== void 0)
+      this.pricingModel = options.pricingModel;
+    if (options.description !== void 0)
+      this.description = options.description;
+  }
+  /**
+   * Check if this tier is higher priority than another
+   */
+  isHigherPriorityThan(other) {
+    return this.priority < other.priority;
+  }
+  /**
+   * Check if this is a fixed pricing tier
+   */
+  isFixedPricing() {
+    return this.pricingModel === PricingModel.FIXED;
+  }
+  /**
+   * Check if this is a performance-based tier (CPC, CPA)
+   */
+  isPerformanceBased() {
+    return this.pricingModel === PricingModel.CPC || this.pricingModel === PricingModel.CPA;
+  }
+};
+AdDeliveryTier = __decorateClass$4([
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], AdDeliveryTier);
+class AdDeliveryTierCollection extends SmrtCollection {
+  static _itemClass = AdDeliveryTier;
+  /**
+   * Find tiers ordered by priority (ascending, lower = higher priority)
+   *
+   * @returns Array of tiers ordered by priority
+   */
+  async findByPriority() {
+    return await this.list({
+      orderBy: "priority ASC"
+    });
+  }
+  /**
+   * Find tiers by pricing model
+   *
+   * @param pricingModel - Pricing model to filter by
+   * @returns Array of matching tiers
+   */
+  async findByPricingModel(pricingModel) {
+    return await this.list({
+      where: { pricingModel },
+      orderBy: "priority ASC"
+    });
+  }
+  /**
+   * Get the highest priority tier
+   *
+   * @returns Highest priority tier or null
+   */
+  async getHighestPriority() {
+    const results = await this.list({
+      orderBy: "priority ASC",
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find fixed pricing tiers
+   */
+  async findFixedPricing() {
+    return await this.findByPricingModel(PricingModel.FIXED);
+  }
+  /**
+   * Find CPM-based tiers
+   */
+  async findCPM() {
+    return await this.findByPricingModel(PricingModel.CPM);
+  }
+  /**
+   * Find performance-based tiers (CPC, CPA)
+   */
+  async findPerformanceBased() {
+    const cpc = await this.findByPricingModel(PricingModel.CPC);
+    const cpa = await this.findByPricingModel(PricingModel.CPA);
+    return [...cpc, ...cpa].sort((a, b) => a.priority - b.priority);
+  }
+}
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+let AdEvent = class extends SmrtObject {
+  tenantId = null;
+  variationId = "";
+  zoneId = "";
+  /**
+   * Site ID (denormalized from Zone for query efficiency)
+   */
+  siteId = "";
+  /**
+   * Event type (impression, click, conversion)
+   */
+  eventType = AdEventType.IMPRESSION;
+  /**
+   * Event timestamp
+   */
+  timestamp = /* @__PURE__ */ new Date();
+  /**
+   * Analytics metadata as JSON string
+   * (IP, user agent, referrer, etc.)
+   */
+  metadata = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.variationId !== void 0)
+      this.variationId = options.variationId;
+    if (options.zoneId !== void 0) this.zoneId = options.zoneId;
+    if (options.siteId !== void 0) this.siteId = options.siteId;
+    if (options.eventType !== void 0) this.eventType = options.eventType;
+    if (options.timestamp !== void 0) this.timestamp = options.timestamp;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Get metadata as object
+   */
+  getMetadata() {
+    if (!this.metadata) return {};
+    try {
+      return JSON.parse(this.metadata);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set metadata from object
+   */
+  setMetadata(data) {
+    this.metadata = JSON.stringify(data);
+  }
+  /**
+   * Check if this is an impression event
+   */
+  isImpression() {
+    return this.eventType === AdEventType.IMPRESSION;
+  }
+  /**
+   * Check if this is a click event
+   */
+  isClick() {
+    return this.eventType === AdEventType.CLICK;
+  }
+  /**
+   * Check if this is a conversion event
+   */
+  isConversion() {
+    return this.eventType === AdEventType.CONVERSION;
+  }
+};
+__decorateClass$3([
+  tenantId({ nullable: true })
+], AdEvent.prototype, "tenantId", 2);
+__decorateClass$3([
+  foreignKey("AdVariation")
+], AdEvent.prototype, "variationId", 2);
+__decorateClass$3([
+  crossPackageRef("@happyvertical/smrt-properties:Zone")
+], AdEvent.prototype, "zoneId", 2);
+AdEvent = __decorateClass$3([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["create", "list"] },
+    // No update/delete (immutable)
+    mcp: { include: ["create"] },
+    cli: false
+    // High volume, not useful in CLI
+  })
+], AdEvent);
+class AdEventCollection extends SmrtCollection {
+  static _itemClass = AdEvent;
+  /**
+   * Find events by variation
+   *
+   * @param variationId - Variation ID
+   * @returns Array of events
+   */
+  async findByVariation(variationId) {
+    return await this.list({
+      where: { variationId },
+      orderBy: "timestamp DESC"
+    });
+  }
+  /**
+   * Find events by zone
+   *
+   * @param zoneId - Zone ID
+   * @returns Array of events
+   */
+  async findByZone(zoneId) {
+    return await this.list({
+      where: { zoneId },
+      orderBy: "timestamp DESC"
+    });
+  }
+  /**
+   * Find events by site
+   *
+   * @param siteId - Site ID
+   * @returns Array of events
+   */
+  async findBySite(siteId) {
+    return await this.list({
+      where: { siteId },
+      orderBy: "timestamp DESC"
+    });
+  }
+  /**
+   * Find events in date range
+   *
+   * @param start - Start date
+   * @param end - End date
+   * @returns Array of events
+   */
+  async findByDateRange(start, end) {
+    return await this.list({
+      where: {
+        "timestamp >=": start.toISOString(),
+        "timestamp <=": end.toISOString()
+      },
+      orderBy: "timestamp DESC"
+    });
+  }
+  /**
+   * Find events by type
+   *
+   * @param eventType - Event type
+   * @returns Array of events
+   */
+  async findByType(eventType) {
+    return await this.list({
+      where: { eventType },
+      orderBy: "timestamp DESC"
+    });
+  }
+  /**
+   * Count events by type for a variation
+   *
+   * @param variationId - Variation ID
+   * @param eventType - Event type
+   * @returns Count of events
+   */
+  async countByType(variationId, eventType) {
+    const events = await this.list({
+      where: { variationId, eventType }
+    });
+    return events.length;
+  }
+  /**
+   * Count impressions for a variation
+   */
+  async countImpressions(variationId) {
+    return await this.countByType(variationId, AdEventType.IMPRESSION);
+  }
+  /**
+   * Count clicks for a variation
+   */
+  async countClicks(variationId) {
+    return await this.countByType(variationId, AdEventType.CLICK);
+  }
+  /**
+   * Count conversions for a variation
+   */
+  async countConversions(variationId) {
+    return await this.countByType(variationId, AdEventType.CONVERSION);
+  }
+  /**
+   * Find all impressions
+   */
+  async findImpressions() {
+    return await this.findByType(AdEventType.IMPRESSION);
+  }
+  /**
+   * Find all clicks
+   */
+  async findClicks() {
+    return await this.findByType(AdEventType.CLICK);
+  }
+  /**
+   * Find all conversions
+   */
+  async findConversions() {
+    return await this.findByType(AdEventType.CONVERSION);
+  }
+  /**
+   * Get aggregate stats for a variation
+   *
+   * @param variationId - Variation ID
+   * @returns Stats object with impressions, clicks, conversions, CTR
+   */
+  async getVariationStats(variationId) {
+    const impressions = await this.countImpressions(variationId);
+    const clicks = await this.countClicks(variationId);
+    const conversions = await this.countConversions(variationId);
+    return {
+      impressions,
+      clicks,
+      conversions,
+      ctr: impressions > 0 ? clicks / impressions : 0,
+      conversionRate: clicks > 0 ? conversions / clicks : 0
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenancy Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Find ad events belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of ad events for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global ad events (no tenant association)
+   *
+   * @returns Array of global ad events
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find ad events for a tenant including global (shared) events
+   *
+   * @param tenantId - Tenant ID to include
+   * @returns Array of tenant-specific and global ad events
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ad_events WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let AdFormat = class extends SmrtObject {
+  /**
+   * Display name (e.g., "Leaderboard", "Medium Rectangle")
+   */
+  name = "";
+  /**
+   * Width in pixels
+   */
+  width = 0;
+  /**
+   * Height in pixels
+   */
+  height = 0;
+  /**
+   * Format type (banner, native, video)
+   */
+  formatType = AdFormatType.BANNER;
+  /**
+   * Optional description
+   */
+  description = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.width !== void 0) this.width = options.width;
+    if (options.height !== void 0) this.height = options.height;
+    if (options.formatType !== void 0) this.formatType = options.formatType;
+    if (options.description !== void 0)
+      this.description = options.description;
+  }
+  /**
+   * Get dimensions as string (e.g., "728x90")
+   */
+  getDimensions() {
+    return `${this.width}x${this.height}`;
+  }
+  /**
+   * Check if format matches specific dimensions
+   */
+  matchesDimensions(width, height) {
+    return this.width === width && this.height === height;
+  }
+};
+AdFormat = __decorateClass$2([
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], AdFormat);
+class AdFormatCollection extends SmrtCollection {
+  static _itemClass = AdFormat;
+  /**
+   * Find format by dimensions
+   *
+   * @param width - Width in pixels
+   * @param height - Height in pixels
+   * @returns Matching format or null
+   */
+  async findByDimensions(width, height) {
+    const results = await this.list({
+      where: { width, height },
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find formats by type
+   *
+   * @param formatType - Format type (banner, native, video)
+   * @returns Array of matching formats
+   */
+  async findByType(formatType) {
+    return await this.list({
+      where: { formatType },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find all banner formats
+   */
+  async findBanners() {
+    return await this.findByType(AdFormatType.BANNER);
+  }
+  /**
+   * Find all native formats
+   */
+  async findNative() {
+    return await this.findByType(AdFormatType.NATIVE);
+  }
+  /**
+   * Find all video formats
+   */
+  async findVideo() {
+    return await this.findByType(AdFormatType.VIDEO);
+  }
+}
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+let AdGroup = class extends SmrtObject {
+  tenantId = null;
+  contractId = "";
+  tierId = "";
+  /**
+   * Display name (e.g., "Summer Sale - Desktop")
+   */
+  name = "";
+  /**
+   * Vertical/category tag slug from smrt-tags (context="advertising")
+   */
+  verticalSlug = "";
+  /**
+   * Targeting rules as JSON string
+   */
+  targeting = "";
+  /**
+   * Allowed Zone IDs as JSON array string (FK to smrt-properties Zone)
+   */
+  zoneIds = "";
+  /**
+   * Campaign start date
+   */
+  startDate = null;
+  /**
+   * Campaign end date
+   */
+  endDate = null;
+  /**
+   * Daily budget limit
+   */
+  dailyBudget = 0;
+  /**
+   * Total campaign budget
+   */
+  totalBudget = 0;
+  /**
+   * Current status
+   */
+  status = AdGroupStatus.DRAFT;
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.contractId !== void 0) this.contractId = options.contractId;
+    if (options.tierId !== void 0) this.tierId = options.tierId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.verticalSlug !== void 0)
+      this.verticalSlug = options.verticalSlug;
+    if (options.targeting !== void 0) this.targeting = options.targeting;
+    if (options.zoneIds !== void 0) this.zoneIds = options.zoneIds;
+    if (options.startDate !== void 0) this.startDate = options.startDate;
+    if (options.endDate !== void 0) this.endDate = options.endDate;
+    if (options.dailyBudget !== void 0)
+      this.dailyBudget = options.dailyBudget;
+    if (options.totalBudget !== void 0)
+      this.totalBudget = options.totalBudget;
+    if (options.status !== void 0) this.status = options.status;
+  }
+  /**
+   * Get zone IDs as array
+   */
+  getZoneIds() {
+    if (!this.zoneIds) return [];
+    try {
+      return JSON.parse(this.zoneIds);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set zone IDs from array
+   */
+  setZoneIds(ids) {
+    this.zoneIds = JSON.stringify(ids);
+  }
+  /**
+   * Add a zone ID
+   */
+  addZoneId(zoneId) {
+    const ids = this.getZoneIds();
+    if (!ids.includes(zoneId)) {
+      ids.push(zoneId);
+      this.setZoneIds(ids);
+    }
+  }
+  /**
+   * Remove a zone ID
+   */
+  removeZoneId(zoneId) {
+    const ids = this.getZoneIds().filter((id) => id !== zoneId);
+    this.setZoneIds(ids);
+  }
+  /**
+   * Check if zone ID is allowed
+   */
+  hasZoneId(zoneId) {
+    return this.getZoneIds().includes(zoneId);
+  }
+  /**
+   * Get targeting rules as object
+   */
+  getTargeting() {
+    if (!this.targeting) return {};
+    try {
+      return JSON.parse(this.targeting);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set targeting rules from object
+   */
+  setTargeting(rules) {
+    this.targeting = JSON.stringify(rules);
+  }
+  /**
+   * Check if ad group is currently active
+   */
+  isActive() {
+    if (this.status !== AdGroupStatus.ACTIVE) return false;
+    const now = /* @__PURE__ */ new Date();
+    if (this.startDate && now < this.startDate) return false;
+    if (this.endDate && now > this.endDate) return false;
+    return true;
+  }
+  /**
+   * Check if ad group is in draft state
+   */
+  isDraft() {
+    return this.status === AdGroupStatus.DRAFT;
+  }
+  /**
+   * Check if ad group is paused
+   */
+  isPaused() {
+    return this.status === AdGroupStatus.PAUSED;
+  }
+  /**
+   * Check if ad group is completed
+   */
+  isCompleted() {
+    return this.status === AdGroupStatus.COMPLETED;
+  }
+  /**
+   * Check if ad group has ended (past end date)
+   */
+  hasEnded() {
+    if (!this.endDate) return false;
+    return /* @__PURE__ */ new Date() > this.endDate;
+  }
+  /**
+   * Check if ad group has started
+   */
+  hasStarted() {
+    if (!this.startDate) return true;
+    return /* @__PURE__ */ new Date() >= this.startDate;
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], AdGroup.prototype, "tenantId", 2);
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-commerce:Contract")
+], AdGroup.prototype, "contractId", 2);
+__decorateClass$1([
+  foreignKey("AdDeliveryTier")
+], AdGroup.prototype, "tierId", 2);
+AdGroup = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], AdGroup);
+class AdGroupCollection extends SmrtCollection {
+  static _itemClass = AdGroup;
+  /**
+   * Find ad groups by contract
+   *
+   * @param contractId - Contract ID
+   * @returns Array of ad groups
+   */
+  async findByContract(contractId) {
+    return await this.list({
+      where: { contractId },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find ad groups by tier
+   *
+   * @param tierId - Delivery tier ID
+   * @returns Array of ad groups
+   */
+  async findByTier(tierId) {
+    return await this.list({
+      where: { tierId },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find ad groups by status
+   *
+   * @param status - Ad group status
+   * @returns Array of ad groups
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find currently active ad groups
+   * (status=active, started, not ended)
+   *
+   * @returns Array of active ad groups
+   */
+  async findActive() {
+    const results = await this.list({
+      where: {
+        status: AdGroupStatus.ACTIVE
+      },
+      orderBy: "created_at DESC"
+    });
+    return results.filter((group) => group.isActive());
+  }
+  /**
+   * Find ad groups by vertical slug
+   *
+   * @param verticalSlug - Tag slug from smrt-tags
+   * @returns Array of ad groups
+   */
+  async findByVertical(verticalSlug) {
+    return await this.list({
+      where: { verticalSlug },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find ad groups that can serve to a specific zone
+   *
+   * @param zoneId - Zone ID to check
+   * @returns Array of ad groups containing zone
+   */
+  async findByZone(zoneId) {
+    const all = await this.list({
+      where: { status: AdGroupStatus.ACTIVE }
+    });
+    return all.filter((group) => group.hasZoneId(zoneId));
+  }
+  /**
+   * Find ad groups eligible to serve for a zone
+   * (active, has zone, within date range)
+   *
+   * @param zoneId - Zone ID to check
+   * @returns Array of eligible ad groups
+   */
+  async findEligibleForZone(zoneId) {
+    const groups = await this.findByZone(zoneId);
+    return groups.filter((group) => group.isActive());
+  }
+  /**
+   * Find all draft ad groups
+   */
+  async findDrafts() {
+    return await this.findByStatus(AdGroupStatus.DRAFT);
+  }
+  /**
+   * Find all paused ad groups
+   */
+  async findPaused() {
+    return await this.findByStatus(AdGroupStatus.PAUSED);
+  }
+  /**
+   * Find all completed ad groups
+   */
+  async findCompleted() {
+    return await this.findByStatus(AdGroupStatus.COMPLETED);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenancy Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Find ad groups belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of ad groups for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global ad groups (no tenant association)
+   *
+   * @returns Array of global ad groups
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find ad groups for a tenant including global (shared) ad groups
+   *
+   * @param tenantId - Tenant ID to include
+   * @returns Array of tenant-specific and global ad groups
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ad_groups WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let AdVariation = class extends SmrtObject {
+  tenantId = null;
+  groupId = "";
+  formatId = "";
+  assetId = "";
+  /**
+   * Display name (e.g., "Version A - Blue CTA")
+   */
+  name = "";
+  /**
+   * Click destination URL
+   */
+  clickUrl = "";
+  /**
+   * Accessibility alt text
+   */
+  altText = "";
+  /**
+   * A/B testing weight (higher = more likely to be selected)
+   */
+  weight = 1;
+  /**
+   * Current status
+   */
+  status = AdVariationStatus.DRAFT;
+  /**
+   * Denormalized impression count (updated async)
+   */
+  impressions = 0;
+  /**
+   * Denormalized click count (updated async)
+   */
+  clicks = 0;
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.groupId !== void 0) this.groupId = options.groupId;
+    if (options.formatId !== void 0) this.formatId = options.formatId;
+    if (options.assetId !== void 0) this.assetId = options.assetId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.clickUrl !== void 0) this.clickUrl = options.clickUrl;
+    if (options.altText !== void 0) this.altText = options.altText;
+    if (options.weight !== void 0) this.weight = options.weight;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.impressions !== void 0)
+      this.impressions = options.impressions;
+    if (options.clicks !== void 0) this.clicks = options.clicks;
+  }
+  /**
+   * Check if variation is active
+   */
+  isActive() {
+    return this.status === AdVariationStatus.ACTIVE;
+  }
+  /**
+   * Check if variation is in draft state
+   */
+  isDraft() {
+    return this.status === AdVariationStatus.DRAFT;
+  }
+  /**
+   * Check if variation is paused
+   */
+  isPaused() {
+    return this.status === AdVariationStatus.PAUSED;
+  }
+  /**
+   * Calculate click-through rate (CTR)
+   */
+  getCTR() {
+    if (this.impressions === 0) return 0;
+    return this.clicks / this.impressions;
+  }
+  /**
+   * Increment impression count
+   */
+  recordImpression() {
+    this.impressions += 1;
+  }
+  /**
+   * Increment click count
+   */
+  recordClick() {
+    this.clicks += 1;
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], AdVariation.prototype, "tenantId", 2);
+__decorateClass([
+  foreignKey("AdGroup")
+], AdVariation.prototype, "groupId", 2);
+__decorateClass([
+  foreignKey("AdFormat")
+], AdVariation.prototype, "formatId", 2);
+__decorateClass([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], AdVariation.prototype, "assetId", 2);
+AdVariation = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], AdVariation);
+class AdVariationCollection extends SmrtCollection {
+  static _itemClass = AdVariation;
+  /**
+   * Find variations by ad group
+   *
+   * @param groupId - Ad group ID
+   * @returns Array of variations
+   */
+  async findByGroup(groupId) {
+    return await this.list({
+      where: { groupId },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find variations by format
+   *
+   * @param formatId - Ad format ID
+   * @returns Array of variations
+   */
+  async findByFormat(formatId) {
+    return await this.list({
+      where: { formatId },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find active variations for a group
+   *
+   * @param groupId - Ad group ID
+   * @returns Array of active variations
+   */
+  async findActiveByGroup(groupId) {
+    return await this.list({
+      where: {
+        groupId,
+        status: AdVariationStatus.ACTIVE
+      },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Select a variation using weighted random selection
+   * Higher weight = more likely to be selected
+   *
+   * @param groupId - Ad group ID
+   * @returns Selected variation or null if none available
+   */
+  async selectByWeight(groupId) {
+    const active = await this.findActiveByGroup(groupId);
+    if (active.length === 0) return null;
+    if (active.length === 1) return active[0];
+    const totalWeight = active.reduce((sum, v) => sum + v.weight, 0);
+    if (totalWeight <= 0) return active[0];
+    let random = Math.random() * totalWeight;
+    for (const variation of active) {
+      random -= variation.weight;
+      if (random <= 0) {
+        return variation;
+      }
+    }
+    return active[active.length - 1];
+  }
+  /**
+   * Find variations by status
+   *
+   * @param status - Variation status
+   * @returns Array of variations
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find all active variations
+   */
+  async findActive() {
+    return await this.findByStatus(AdVariationStatus.ACTIVE);
+  }
+  /**
+   * Find all draft variations
+   */
+  async findDrafts() {
+    return await this.findByStatus(AdVariationStatus.DRAFT);
+  }
+  /**
+   * Find all paused variations
+   */
+  async findPaused() {
+    return await this.findByStatus(AdVariationStatus.PAUSED);
+  }
+  /**
+   * Find top performing variations by CTR
+   *
+   * @param limit - Maximum number to return
+   * @returns Array of variations sorted by CTR descending
+   */
+  async findTopPerformers(limit = 10) {
+    const all = await this.list({
+      where: { status: AdVariationStatus.ACTIVE }
+    });
+    return all.filter((v) => v.impressions > 0).sort((a, b) => b.getCTR() - a.getCTR()).slice(0, limit);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenancy Helper Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Find ad variations belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of ad variations for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global ad variations (no tenant association)
+   *
+   * @returns Array of global ad variations
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find ad variations for a tenant including global (shared) variations
+   *
+   * @param tenantId - Tenant ID to include
+   * @returns Array of tenant-specific and global ad variations
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ad_variations WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+export {
+  AdDeliveryTier,
+  AdDeliveryTierCollection,
+  AdEvent,
+  AdEventCollection,
+  AdEventType,
+  AdFormat,
+  AdFormatCollection,
+  AdFormatType,
+  AdGroup,
+  AdGroupCollection,
+  AdGroupStatus,
+  AdVariation,
+  AdVariationCollection,
+  AdVariationStatus,
+  PricingModel
+};
+//# sourceMappingURL=index.js.map