@happyvertical/smrt-affiliates 0.30.0

package/dist/index.js

@@ -0,0 +1,1387 @@
+import { ObjectRegistry, crossPackageRef, foreignKey, smrt, SmrtObject, SmrtCollection } from "@happyvertical/smrt-core";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+var PartnerType = /* @__PURE__ */ ((PartnerType2) => {
+  PartnerType2["PUBLISHER"] = "publisher";
+  PartnerType2["SALESPERSON"] = "salesperson";
+  PartnerType2["REFERRER"] = "referrer";
+  return PartnerType2;
+})(PartnerType || {});
+var PartnerStatus = /* @__PURE__ */ ((PartnerStatus2) => {
+  PartnerStatus2["PENDING"] = "pending";
+  PartnerStatus2["ACTIVE"] = "active";
+  PartnerStatus2["SUSPENDED"] = "suspended";
+  return PartnerStatus2;
+})(PartnerStatus || {});
+var CommissionType = /* @__PURE__ */ ((CommissionType2) => {
+  CommissionType2["DISPLAY"] = "display";
+  CommissionType2["REFERRAL"] = "referral";
+  CommissionType2["SALES"] = "sales";
+  CommissionType2["PARENT"] = "parent";
+  CommissionType2["OVERHEAD"] = "overhead";
+  return CommissionType2;
+})(CommissionType || {});
+var CommissionStatus = /* @__PURE__ */ ((CommissionStatus2) => {
+  CommissionStatus2["PENDING"] = "pending";
+  CommissionStatus2["INCLUDED"] = "included";
+  CommissionStatus2["PAID"] = "paid";
+  return CommissionStatus2;
+})(CommissionStatus || {});
+var PayoutStatus = /* @__PURE__ */ ((PayoutStatus2) => {
+  PayoutStatus2["PENDING"] = "pending";
+  PayoutStatus2["APPROVED"] = "approved";
+  PayoutStatus2["PROCESSING"] = "processing";
+  PayoutStatus2["COMPLETED"] = "completed";
+  PayoutStatus2["FAILED"] = "failed";
+  return PayoutStatus2;
+})(PayoutStatus || {});
+var PayoutMethod = /* @__PURE__ */ ((PayoutMethod2) => {
+  PayoutMethod2["BANK_TRANSFER"] = "bank_transfer";
+  PayoutMethod2["CHECK"] = "check";
+  PayoutMethod2["PAYPAL"] = "paypal";
+  PayoutMethod2["CREDIT"] = "credit";
+  return PayoutMethod2;
+})(PayoutMethod || {});
+var __defProp$2 = Object.defineProperty;
+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 = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+let Commission = class extends SmrtObject {
+  /**
+   * Calculate commission amount from gross revenue and rate
+   *
+   * @param grossRevenue - Gross revenue in cents
+   * @param rate - Commission rate (0-1)
+   * @returns Commission amount in cents (rounded)
+   *
+   * @example
+   * ```typescript
+   * const amount = Commission.calculateAmount(1000, 0.50); // 500 cents
+   * ```
+   */
+  static calculateAmount(grossRevenue, rate) {
+    return Math.round(grossRevenue * rate);
+  }
+  eventId = "";
+  partnerId = "";
+  /**
+   * Commission type (display, referral, sales, parent)
+   */
+  commissionType = CommissionType.DISPLAY;
+  /**
+   * Gross revenue from the event in cents
+   * This is the total ad revenue before commission split
+   */
+  grossRevenue = 0;
+  /**
+   * Commission rate applied (0-1)
+   * Copied from partner at time of event for audit trail
+   */
+  commissionRate = 0;
+  /**
+   * Calculated commission amount in cents
+   * = grossRevenue * commissionRate
+   */
+  commissionAmount = 0;
+  /**
+   * Currency code
+   * Defaults to CAD
+   */
+  currency = "CAD";
+  payoutId = "";
+  /**
+   * Commission status
+   */
+  status = CommissionStatus.PENDING;
+  /**
+   * Event timestamp (copied from AdEvent for reporting)
+   */
+  eventTimestamp = /* @__PURE__ */ new Date();
+  /**
+   * Network ID for aggregate queries (optional context)
+   */
+  networkId = "";
+  /**
+   * Site/Property ID for aggregate queries (optional context)
+   */
+  siteId = "";
+  /**
+   * Campaign ID for aggregate queries (optional context)
+   */
+  campaignId = "";
+  /**
+   * Additional metadata as JSON string
+   */
+  metadata = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.eventId !== void 0) this.eventId = options.eventId;
+    if (options.partnerId !== void 0) this.partnerId = options.partnerId;
+    if (options.commissionType !== void 0)
+      this.commissionType = options.commissionType;
+    if (options.grossRevenue !== void 0)
+      this.grossRevenue = options.grossRevenue;
+    if (options.commissionRate !== void 0)
+      this.commissionRate = options.commissionRate;
+    if (options.commissionAmount !== void 0)
+      this.commissionAmount = options.commissionAmount;
+    if (options.currency !== void 0) this.currency = options.currency;
+    if (options.payoutId !== void 0) this.payoutId = options.payoutId;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.eventTimestamp !== void 0)
+      this.eventTimestamp = options.eventTimestamp;
+    if (options.networkId !== void 0) this.networkId = options.networkId;
+    if (options.siteId !== void 0) this.siteId = options.siteId;
+    if (options.campaignId !== void 0) this.campaignId = options.campaignId;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Check if commission is pending (not yet in a payout)
+   */
+  isPending() {
+    return this.status === CommissionStatus.PENDING;
+  }
+  /**
+   * Check if commission is included in a payout
+   */
+  isIncluded() {
+    return this.status === CommissionStatus.INCLUDED;
+  }
+  /**
+   * Check if commission has been paid
+   */
+  isPaid() {
+    return this.status === CommissionStatus.PAID;
+  }
+  /**
+   * Check if this is a display commission
+   */
+  isDisplay() {
+    return this.commissionType === CommissionType.DISPLAY;
+  }
+  /**
+   * Check if this is a referral commission
+   */
+  isReferral() {
+    return this.commissionType === CommissionType.REFERRAL;
+  }
+  /**
+   * Check if this is a sales commission
+   */
+  isSales() {
+    return this.commissionType === CommissionType.SALES;
+  }
+  /**
+   * Check if this is a parent commission
+   */
+  isParent() {
+    return this.commissionType === CommissionType.PARENT;
+  }
+  /**
+   * Check if this is an overhead commission
+   */
+  isOverhead() {
+    return this.commissionType === CommissionType.OVERHEAD;
+  }
+  /**
+   * Get commission amount in dollars (for display)
+   */
+  getAmountInDollars() {
+    return this.commissionAmount / 100;
+  }
+  /**
+   * Get gross revenue in dollars (for display)
+   */
+  getGrossRevenueInDollars() {
+    return this.grossRevenue / 100;
+  }
+  /**
+   * 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);
+  }
+};
+__decorateClass$2([
+  crossPackageRef("@happyvertical/smrt-ads:AdEvent")
+], Commission.prototype, "eventId", 2);
+__decorateClass$2([
+  foreignKey("Partner")
+], Commission.prototype, "partnerId", 2);
+__decorateClass$2([
+  foreignKey("Payout")
+], Commission.prototype, "payoutId", 2);
+Commission = __decorateClass$2([
+  smrt({
+    api: { include: ["create", "list", "get"] },
+    // No delete (audit trail)
+    mcp: { include: ["create", "list"] },
+    cli: false
+    // High volume, not useful in CLI
+  })
+], Commission);
+class CommissionCollection extends SmrtCollection {
+  static _itemClass = Commission;
+  /**
+   * Find commissions by partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Array of commissions
+   */
+  async findByPartner(partnerId) {
+    return await this.list({
+      where: { partnerId },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find commissions by ad event
+   *
+   * @param eventId - Ad Event ID
+   * @returns Array of commissions
+   */
+  async findByEvent(eventId) {
+    return await this.list({
+      where: { eventId },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find commissions by payout
+   *
+   * @param payoutId - Payout ID
+   * @returns Array of commissions
+   */
+  async findByPayout(payoutId) {
+    return await this.list({
+      where: { payoutId },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find commissions by status
+   *
+   * @param status - Commission status
+   * @returns Array of commissions
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find all pending commissions
+   */
+  async findPending() {
+    return await this.findByStatus(CommissionStatus.PENDING);
+  }
+  /**
+   * Find pending commissions for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Array of pending commissions
+   */
+  async findPendingByPartner(partnerId) {
+    return await this.list({
+      where: { partnerId, status: CommissionStatus.PENDING },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find commissions by type
+   *
+   * @param commissionType - Commission type
+   * @returns Array of commissions
+   */
+  async findByType(commissionType) {
+    return await this.list({
+      where: { commissionType },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find commissions in date range
+   *
+   * @param start - Start date
+   * @param end - End date
+   * @returns Array of commissions
+   */
+  async findByDateRange(start, end) {
+    return await this.list({
+      where: {
+        "event_timestamp >=": start.toISOString(),
+        "event_timestamp <=": end.toISOString()
+      },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find commissions for a partner in date range
+   *
+   * @param partnerId - Partner ID
+   * @param start - Start date
+   * @param end - End date
+   * @returns Array of commissions
+   */
+  async findByPartnerAndDateRange(partnerId, start, end) {
+    return await this.list({
+      where: {
+        partnerId,
+        "event_timestamp >=": start.toISOString(),
+        "event_timestamp <=": end.toISOString()
+      },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  // --- Network-scoped queries ---
+  /**
+   * Find all commissions for a network
+   *
+   * @param networkId - Network ID
+   * @returns Array of commissions
+   */
+  async findByNetwork(networkId) {
+    return await this.list({
+      where: { networkId },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find commissions for a network filtered by type
+   *
+   * @param networkId - Network ID
+   * @param commissionType - Commission type
+   * @returns Array of commissions
+   */
+  async findByNetworkAndType(networkId, commissionType) {
+    return await this.list({
+      where: { networkId, commissionType },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Find pending commissions for a network
+   *
+   * @param networkId - Network ID
+   * @returns Array of pending commissions
+   */
+  async findPendingByNetwork(networkId) {
+    return await this.list({
+      where: { networkId, status: CommissionStatus.PENDING },
+      orderBy: "event_timestamp DESC"
+    });
+  }
+  /**
+   * Get aggregate summary of commissions by type and site for a network.
+   *
+   * @param networkId - Network ID
+   * @param options - Optional filters (siteId, from, to, commissionType)
+   * @returns Summary with byType, bySite, total, and count
+   */
+  async getSummaryByNetwork(networkId, options = {}) {
+    const where = { networkId };
+    if (options.siteId) where.siteId = options.siteId;
+    if (options.commissionType) where.commissionType = options.commissionType;
+    if (options.from) where["event_timestamp >="] = options.from.toISOString();
+    if (options.to) where["event_timestamp <="] = options.to.toISOString();
+    const filtered = await this.list({ where });
+    const byType = {
+      overhead: 0,
+      display: 0,
+      referral: 0,
+      sales: 0,
+      parent: 0
+    };
+    const bySite = {};
+    let total = 0;
+    for (const c of filtered) {
+      byType[c.commissionType] = (byType[c.commissionType] ?? 0) + c.commissionAmount;
+      if (c.siteId) {
+        bySite[c.siteId] = (bySite[c.siteId] ?? 0) + c.commissionAmount;
+      }
+      total += c.commissionAmount;
+    }
+    return { byType, bySite, total, count: filtered.length };
+  }
+  /**
+   * Get pending commissions grouped by partnerId for a network.
+   *
+   * @param networkId - Network ID
+   * @returns Array of payout groups (partnerId, totalPending, currency, entries)
+   */
+  async getPendingPayoutsByNetwork(networkId) {
+    const pending = await this.findPendingByNetwork(networkId);
+    const withPartner = pending.filter(
+      (c) => c.partnerId && c.partnerId !== ""
+    );
+    const grouped = /* @__PURE__ */ new Map();
+    for (const c of withPartner) {
+      const existing = grouped.get(c.partnerId) ?? [];
+      existing.push(c);
+      grouped.set(c.partnerId, existing);
+    }
+    const payouts = [];
+    for (const [partnerId, group] of grouped) {
+      const totalPending = group.reduce(
+        (sum, c) => sum + c.commissionAmount,
+        0
+      );
+      const currency = group[0]?.currency ?? "CAD";
+      payouts.push({
+        partnerId,
+        totalPending,
+        currency,
+        entryCount: group.length,
+        entries: group.map((c) => ({
+          id: c.id ?? "",
+          commissionType: c.commissionType,
+          commissionAmount: c.commissionAmount,
+          campaignId: c.campaignId,
+          siteId: c.siteId
+        }))
+      });
+    }
+    payouts.sort((a, b) => b.totalPending - a.totalPending);
+    return payouts;
+  }
+  // --- Aggregation queries ---
+  /**
+   * Sum pending commissions for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Total pending amount in cents
+   */
+  async sumPendingByPartner(partnerId) {
+    const pending = await this.findPendingByPartner(partnerId);
+    return pending.reduce((sum, c) => sum + c.commissionAmount, 0);
+  }
+  /**
+   * Sum commissions by type for a partner
+   *
+   * @param partnerId - Partner ID
+   * @param commissionType - Commission type
+   * @returns Total amount in cents
+   */
+  async sumByPartnerAndType(partnerId, commissionType) {
+    const commissions = await this.list({
+      where: { partnerId, commissionType }
+    });
+    return commissions.reduce((sum, c) => sum + c.commissionAmount, 0);
+  }
+  /**
+   * Get earnings breakdown for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Breakdown by commission type
+   */
+  async getEarningsBreakdown(partnerId) {
+    const commissions = await this.findByPartner(partnerId);
+    const breakdown = {
+      display: 0,
+      referral: 0,
+      sales: 0,
+      parent: 0,
+      overhead: 0,
+      total: 0
+    };
+    for (const c of commissions) {
+      if (c.isPaid() || c.isIncluded()) {
+        switch (c.commissionType) {
+          case CommissionType.DISPLAY:
+            breakdown.display += c.commissionAmount;
+            break;
+          case CommissionType.REFERRAL:
+            breakdown.referral += c.commissionAmount;
+            break;
+          case CommissionType.SALES:
+            breakdown.sales += c.commissionAmount;
+            break;
+          case CommissionType.PARENT:
+            breakdown.parent += c.commissionAmount;
+            break;
+          case CommissionType.OVERHEAD:
+            breakdown.overhead += c.commissionAmount;
+            break;
+        }
+      }
+    }
+    breakdown.total = breakdown.display + breakdown.referral + breakdown.sales + breakdown.parent + breakdown.overhead;
+    return breakdown;
+  }
+  /**
+   * Get pending earnings breakdown for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Breakdown of pending commissions by type
+   */
+  async getPendingBreakdown(partnerId) {
+    const pending = await this.findPendingByPartner(partnerId);
+    const breakdown = {
+      display: 0,
+      referral: 0,
+      sales: 0,
+      parent: 0,
+      overhead: 0,
+      total: 0
+    };
+    for (const c of pending) {
+      switch (c.commissionType) {
+        case CommissionType.DISPLAY:
+          breakdown.display += c.commissionAmount;
+          break;
+        case CommissionType.REFERRAL:
+          breakdown.referral += c.commissionAmount;
+          break;
+        case CommissionType.SALES:
+          breakdown.sales += c.commissionAmount;
+          break;
+        case CommissionType.PARENT:
+          breakdown.parent += c.commissionAmount;
+          break;
+        case CommissionType.OVERHEAD:
+          breakdown.overhead += c.commissionAmount;
+          break;
+      }
+    }
+    breakdown.total = breakdown.display + breakdown.referral + breakdown.sales + breakdown.parent + breakdown.overhead;
+    return breakdown;
+  }
+}
+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 Partner = class extends SmrtObject {
+  profileId = "";
+  propertyId = "";
+  /**
+   * Partner types as JSON array (publisher, salesperson, referrer)
+   * A partner can have multiple types
+   */
+  partnerTypes = "[]";
+  parentPartnerId = "";
+  referredById = "";
+  /**
+   * Share of commission that goes to parent partner (0-1)
+   * e.g., 0.20 means 20% of this partner's sales commission goes to parent
+   */
+  parentCommissionShare = 0;
+  /**
+   * Commission rate for display (impression) revenue (0-1)
+   * Default 50% - publisher earns half of ad impression revenue
+   */
+  displayCommissionRate = 0.5;
+  /**
+   * Commission rate for referral revenue (0-1)
+   * Default 5% - referrer earns 5% of referred partner's first-year revenue
+   */
+  referralCommissionRate = 0.05;
+  /**
+   * Commission rate for sales revenue (0-1)
+   * Default 10% - salesperson earns 10% of advertiser spend they brought in
+   */
+  salesCommissionRate = 0.1;
+  /**
+   * Minimum payout threshold in cents
+   * Default $50 = 5000 cents
+   */
+  payoutThreshold = 5e3;
+  /**
+   * Preferred payout method
+   */
+  payoutMethod = PayoutMethod.BANK_TRANSFER;
+  /**
+   * Currency code for all monetary values
+   * Defaults to CAD, allows future multi-currency support
+   */
+  currency = "CAD";
+  /**
+   * Partner status
+   */
+  status = PartnerStatus.PENDING;
+  /**
+   * Additional metadata as JSON string
+   * (bank details, tax info, etc.)
+   */
+  metadata = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.profileId !== void 0) this.profileId = options.profileId;
+    if (options.propertyId !== void 0) this.propertyId = options.propertyId;
+    if (options.partnerTypes !== void 0)
+      this.partnerTypes = options.partnerTypes;
+    if (options.parentPartnerId !== void 0)
+      this.parentPartnerId = options.parentPartnerId;
+    if (options.referredById !== void 0)
+      this.referredById = options.referredById;
+    if (options.parentCommissionShare !== void 0)
+      this.parentCommissionShare = options.parentCommissionShare;
+    if (options.displayCommissionRate !== void 0)
+      this.displayCommissionRate = options.displayCommissionRate;
+    if (options.referralCommissionRate !== void 0)
+      this.referralCommissionRate = options.referralCommissionRate;
+    if (options.salesCommissionRate !== void 0)
+      this.salesCommissionRate = options.salesCommissionRate;
+    if (options.payoutThreshold !== void 0)
+      this.payoutThreshold = options.payoutThreshold;
+    if (options.payoutMethod !== void 0)
+      this.payoutMethod = options.payoutMethod;
+    if (options.currency !== void 0) this.currency = options.currency;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Get partner types as array
+   */
+  getPartnerTypes() {
+    if (!this.partnerTypes) return [];
+    try {
+      return JSON.parse(this.partnerTypes);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set partner types from array
+   */
+  setPartnerTypes(types) {
+    this.partnerTypes = JSON.stringify(types);
+  }
+  /**
+   * Check if partner has a specific type
+   */
+  hasType(type) {
+    return this.getPartnerTypes().includes(type);
+  }
+  /**
+   * Check if partner is a publisher
+   */
+  isPublisher() {
+    return this.hasType(PartnerType.PUBLISHER);
+  }
+  /**
+   * Check if partner is a salesperson
+   */
+  isSalesperson() {
+    return this.hasType(PartnerType.SALESPERSON);
+  }
+  /**
+   * Check if partner is a referrer
+   */
+  isReferrer() {
+    return this.hasType(PartnerType.REFERRER);
+  }
+  /**
+   * Check if partner is active
+   */
+  isActive() {
+    return this.status === PartnerStatus.ACTIVE;
+  }
+  /**
+   * Check if partner is pending approval
+   */
+  isPending() {
+    return this.status === PartnerStatus.PENDING;
+  }
+  /**
+   * Check if partner is suspended
+   */
+  isSuspended() {
+    return this.status === PartnerStatus.SUSPENDED;
+  }
+  /**
+   * Check if partner has a parent (site-attached)
+   */
+  hasParent() {
+    return !!this.parentPartnerId;
+  }
+  /**
+   * Check if partner was referred by another partner
+   */
+  wasReferred() {
+    return !!this.referredById;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Calculate effective sales commission rate (after parent share)
+   */
+  getEffectiveSalesRate() {
+    if (this.parentPartnerId && this.parentCommissionShare > 0) {
+      return this.salesCommissionRate * (1 - this.parentCommissionShare);
+    }
+    return this.salesCommissionRate;
+  }
+};
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-profiles:Profile")
+], Partner.prototype, "profileId", 2);
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-properties:Property")
+], Partner.prototype, "propertyId", 2);
+__decorateClass$1([
+  foreignKey("Partner")
+], Partner.prototype, "parentPartnerId", 2);
+__decorateClass$1([
+  foreignKey("Partner")
+], Partner.prototype, "referredById", 2);
+Partner = __decorateClass$1([
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], Partner);
+class PartnerCollection extends SmrtCollection {
+  static _itemClass = Partner;
+  /**
+   * Find partners by profile ID
+   *
+   * @param profileId - Profile ID
+   * @returns Array of partners
+   */
+  async findByProfile(profileId) {
+    return await this.list({
+      where: { profileId },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find partner by property ID (publishers)
+   *
+   * @param propertyId - Property ID
+   * @returns Partner or null
+   */
+  async findByProperty(propertyId) {
+    const results = await this.list({
+      where: { propertyId },
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Find partners by parent partner ID
+   *
+   * @param parentPartnerId - Parent partner ID
+   * @returns Array of child partners
+   */
+  async findByParent(parentPartnerId) {
+    return await this.list({
+      where: { parentPartnerId },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find partners referred by a specific partner
+   *
+   * @param referredById - Referrer partner ID
+   * @returns Array of referred partners
+   */
+  async findByReferrer(referredById) {
+    return await this.list({
+      where: { referredById },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find partners by status
+   *
+   * @param status - Partner status
+   * @returns Array of partners
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "created_at DESC"
+    });
+  }
+  /**
+   * Find all active partners
+   */
+  async findActive() {
+    return await this.findByStatus(PartnerStatus.ACTIVE);
+  }
+  /**
+   * Find all pending partners (awaiting approval)
+   */
+  async findPending() {
+    return await this.findByStatus(PartnerStatus.PENDING);
+  }
+  /**
+   * Find all suspended partners
+   */
+  async findSuspended() {
+    return await this.findByStatus(PartnerStatus.SUSPENDED);
+  }
+  /**
+   * Find partners by type (requires in-memory filtering for JSON field)
+   *
+   * @param type - Partner type to filter by
+   * @returns Array of partners with that type
+   */
+  async findByType(type) {
+    const all = await this.list({});
+    return all.filter((partner) => partner.hasType(type));
+  }
+  /**
+   * Find all publisher partners
+   */
+  async findPublishers() {
+    return await this.findByType(PartnerType.PUBLISHER);
+  }
+  /**
+   * Find all salesperson partners
+   */
+  async findSalespeople() {
+    return await this.findByType(PartnerType.SALESPERSON);
+  }
+  /**
+   * Find all referrer partners
+   */
+  async findReferrers() {
+    return await this.findByType(PartnerType.REFERRER);
+  }
+  /**
+   * Find active publishers (for ad serving)
+   */
+  async findActivePublishers() {
+    const publishers = await this.findPublishers();
+    return publishers.filter((p) => p.isActive());
+  }
+  /**
+   * Find partner for ad serving by property ID
+   * Returns active publisher partner for the property
+   *
+   * @param propertyId - Property ID
+   * @returns Active publisher partner or null
+   */
+  async findActiveByProperty(propertyId) {
+    const partner = await this.findByProperty(propertyId);
+    if (partner?.isActive() && partner.isPublisher()) {
+      return partner;
+    }
+    return null;
+  }
+  /**
+   * Find partners eligible for payout
+   * (active partners with pending commissions above threshold)
+   * Note: Actual threshold check requires joining with commissions
+   */
+  async findEligibleForPayout() {
+    const active = await this.findActive();
+    return active;
+  }
+}
+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 Payout = class extends SmrtObject {
+  partnerId = "";
+  /**
+   * Period start date
+   */
+  periodStart = /* @__PURE__ */ new Date();
+  /**
+   * Period end date
+   */
+  periodEnd = /* @__PURE__ */ new Date();
+  /**
+   * Total display earnings in cents
+   */
+  displayEarnings = 0;
+  /**
+   * Total referral earnings in cents
+   */
+  referralEarnings = 0;
+  /**
+   * Total sales earnings in cents
+   */
+  salesEarnings = 0;
+  /**
+   * Total parent earnings in cents (from site-attached salespeople)
+   */
+  parentEarnings = 0;
+  /**
+   * Total overhead earnings in cents (network overhead commissions)
+   */
+  overheadEarnings = 0;
+  /**
+   * Total payout amount in cents
+   * = displayEarnings + referralEarnings + salesEarnings + parentEarnings + overheadEarnings
+   */
+  totalAmount = 0;
+  /**
+   * Currency code
+   * Defaults to CAD
+   */
+  currency = "CAD";
+  invoiceId = "";
+  /**
+   * Payout status
+   */
+  status = PayoutStatus.PENDING;
+  /**
+   * Payment reference (check number, transfer ID, etc.)
+   */
+  paymentReference = "";
+  /**
+   * Date payment was processed
+   */
+  paidAt = null;
+  /**
+   * Notes from admin (approval notes, issues, etc.)
+   */
+  notes = "";
+  /**
+   * Additional metadata as JSON string
+   */
+  metadata = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.partnerId !== void 0) this.partnerId = options.partnerId;
+    if (options.periodStart !== void 0)
+      this.periodStart = options.periodStart;
+    if (options.periodEnd !== void 0) this.periodEnd = options.periodEnd;
+    if (options.displayEarnings !== void 0)
+      this.displayEarnings = options.displayEarnings;
+    if (options.referralEarnings !== void 0)
+      this.referralEarnings = options.referralEarnings;
+    if (options.salesEarnings !== void 0)
+      this.salesEarnings = options.salesEarnings;
+    if (options.parentEarnings !== void 0)
+      this.parentEarnings = options.parentEarnings;
+    if (options.overheadEarnings !== void 0)
+      this.overheadEarnings = options.overheadEarnings;
+    if (options.totalAmount !== void 0)
+      this.totalAmount = options.totalAmount;
+    if (options.currency !== void 0) this.currency = options.currency;
+    if (options.invoiceId !== void 0) this.invoiceId = options.invoiceId;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.paymentReference !== void 0)
+      this.paymentReference = options.paymentReference;
+    if (options.paidAt !== void 0) this.paidAt = options.paidAt;
+    if (options.notes !== void 0) this.notes = options.notes;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Check if payout is pending approval
+   */
+  isPending() {
+    return this.status === PayoutStatus.PENDING;
+  }
+  /**
+   * Check if payout is approved (waiting for processing)
+   */
+  isApproved() {
+    return this.status === PayoutStatus.APPROVED;
+  }
+  /**
+   * Check if payout is being processed
+   */
+  isProcessing() {
+    return this.status === PayoutStatus.PROCESSING;
+  }
+  /**
+   * Check if payout is completed
+   */
+  isCompleted() {
+    return this.status === PayoutStatus.COMPLETED;
+  }
+  /**
+   * Check if payout failed
+   */
+  isFailed() {
+    return this.status === PayoutStatus.FAILED;
+  }
+  /**
+   * Get total amount in dollars (for display)
+   */
+  getTotalInDollars() {
+    return this.totalAmount / 100;
+  }
+  /**
+   * Get display earnings in dollars
+   */
+  getDisplayEarningsInDollars() {
+    return this.displayEarnings / 100;
+  }
+  /**
+   * Get referral earnings in dollars
+   */
+  getReferralEarningsInDollars() {
+    return this.referralEarnings / 100;
+  }
+  /**
+   * Get sales earnings in dollars
+   */
+  getSalesEarningsInDollars() {
+    return this.salesEarnings / 100;
+  }
+  /**
+   * Get parent earnings in dollars
+   */
+  getParentEarningsInDollars() {
+    return this.parentEarnings / 100;
+  }
+  /**
+   * Get overhead earnings in dollars
+   */
+  getOverheadEarningsInDollars() {
+    return this.overheadEarnings / 100;
+  }
+  /**
+   * Calculate total from component earnings
+   */
+  calculateTotal() {
+    return this.displayEarnings + this.referralEarnings + this.salesEarnings + this.parentEarnings + this.overheadEarnings;
+  }
+  /**
+   * Get period as human-readable string
+   */
+  getPeriodString() {
+    const start = this.periodStart.toISOString().split("T")[0];
+    const end = this.periodEnd.toISOString().split("T")[0];
+    return `${start} to ${end}`;
+  }
+  /**
+   * 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);
+  }
+  // ============================================================================
+  // Status Transitions
+  // ============================================================================
+  /**
+   * Approve the payout for processing
+   *
+   * @throws Error if payout is not in pending status
+   */
+  approve() {
+    if (this.status !== PayoutStatus.PENDING) {
+      throw new Error(
+        `Cannot approve payout with status '${this.status}'. Only pending payouts can be approved.`
+      );
+    }
+    this.status = PayoutStatus.APPROVED;
+  }
+  /**
+   * Mark payout as processing (payment in progress)
+   *
+   * @throws Error if payout is not in approved status
+   */
+  markProcessing() {
+    if (this.status !== PayoutStatus.APPROVED) {
+      throw new Error(
+        `Cannot mark payout as processing with status '${this.status}'. Only approved payouts can be processed.`
+      );
+    }
+    this.status = PayoutStatus.PROCESSING;
+  }
+  /**
+   * Mark payout as completed
+   *
+   * @param paymentReference - Payment reference (check number, transfer ID, etc.)
+   * @throws Error if payout is not in processing status
+   */
+  complete(paymentReference) {
+    if (this.status !== PayoutStatus.PROCESSING) {
+      throw new Error(
+        `Cannot complete payout with status '${this.status}'. Only processing payouts can be completed.`
+      );
+    }
+    this.status = PayoutStatus.COMPLETED;
+    this.paymentReference = paymentReference;
+    this.paidAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Mark payout as failed
+   *
+   * @param reason - Reason for failure (stored in notes)
+   */
+  fail(reason) {
+    if (this.status !== PayoutStatus.APPROVED && this.status !== PayoutStatus.PROCESSING) {
+      throw new Error(
+        `Cannot fail payout with status '${this.status}'. Only approved or processing payouts can fail.`
+      );
+    }
+    this.status = PayoutStatus.FAILED;
+    this.notes = reason;
+  }
+};
+__decorateClass([
+  foreignKey("Partner")
+], Payout.prototype, "partnerId", 2);
+__decorateClass([
+  crossPackageRef("@happyvertical/smrt-commerce:Invoice")
+], Payout.prototype, "invoiceId", 2);
+Payout = __decorateClass([
+  smrt({
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], Payout);
+class PayoutCollection extends SmrtCollection {
+  static _itemClass = Payout;
+  /**
+   * Find payouts by partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Array of payouts
+   */
+  async findByPartner(partnerId) {
+    return await this.list({
+      where: { partnerId },
+      orderBy: "period_end DESC"
+    });
+  }
+  /**
+   * Find payouts by status
+   *
+   * @param status - Payout status
+   * @returns Array of payouts
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "period_end DESC"
+    });
+  }
+  /**
+   * Find all pending payouts (awaiting approval)
+   */
+  async findPending() {
+    return await this.findByStatus(PayoutStatus.PENDING);
+  }
+  /**
+   * Find all approved payouts (ready for processing)
+   */
+  async findApproved() {
+    return await this.findByStatus(PayoutStatus.APPROVED);
+  }
+  /**
+   * Find all processing payouts
+   */
+  async findProcessing() {
+    return await this.findByStatus(PayoutStatus.PROCESSING);
+  }
+  /**
+   * Find all completed payouts
+   */
+  async findCompleted() {
+    return await this.findByStatus(PayoutStatus.COMPLETED);
+  }
+  /**
+   * Find all failed payouts
+   */
+  async findFailed() {
+    return await this.findByStatus(PayoutStatus.FAILED);
+  }
+  /**
+   * Find payouts by invoice
+   *
+   * @param invoiceId - Invoice ID
+   * @returns Array of payouts
+   */
+  async findByInvoice(invoiceId) {
+    return await this.list({
+      where: { invoiceId },
+      orderBy: "period_end DESC"
+    });
+  }
+  /**
+   * Find payouts in period range
+   *
+   * @param start - Period start date
+   * @param end - Period end date
+   * @returns Array of payouts
+   */
+  async findByPeriod(start, end) {
+    return await this.list({
+      where: {
+        "period_start >=": start.toISOString(),
+        "period_end <=": end.toISOString()
+      },
+      orderBy: "period_end DESC"
+    });
+  }
+  /**
+   * Find payouts for a partner by status
+   *
+   * @param partnerId - Partner ID
+   * @param status - Payout status
+   * @returns Array of payouts
+   */
+  async findByPartnerAndStatus(partnerId, status) {
+    return await this.list({
+      where: { partnerId, status },
+      orderBy: "period_end DESC"
+    });
+  }
+  /**
+   * Find pending payouts for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Array of pending payouts
+   */
+  async findPendingByPartner(partnerId) {
+    return await this.findByPartnerAndStatus(partnerId, PayoutStatus.PENDING);
+  }
+  /**
+   * Find completed payouts for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Array of completed payouts
+   */
+  async findCompletedByPartner(partnerId) {
+    return await this.findByPartnerAndStatus(partnerId, PayoutStatus.COMPLETED);
+  }
+  /**
+   * Sum total paid to a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Total paid in cents
+   */
+  async sumPaidByPartner(partnerId) {
+    const completed = await this.findCompletedByPartner(partnerId);
+    return completed.reduce((sum, p) => sum + p.totalAmount, 0);
+  }
+  /**
+   * Sum total pending for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Total pending in cents
+   */
+  async sumPendingByPartner(partnerId) {
+    const pending = await this.findPendingByPartner(partnerId);
+    return pending.reduce((sum, p) => sum + p.totalAmount, 0);
+  }
+  /**
+   * Get most recent payout for a partner
+   *
+   * @param partnerId - Partner ID
+   * @returns Most recent payout or null
+   */
+  async findLatestByPartner(partnerId) {
+    const results = await this.list({
+      where: { partnerId },
+      orderBy: "period_end DESC",
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Get payout statistics
+   *
+   * @returns Stats object
+   */
+  async getStats() {
+    const all = await this.list({});
+    const stats = {
+      pending: 0,
+      approved: 0,
+      processing: 0,
+      completed: 0,
+      failed: 0,
+      totalPaid: 0,
+      totalPending: 0
+    };
+    for (const p of all) {
+      switch (p.status) {
+        case PayoutStatus.PENDING:
+          stats.pending++;
+          stats.totalPending += p.totalAmount;
+          break;
+        case PayoutStatus.APPROVED:
+          stats.approved++;
+          stats.totalPending += p.totalAmount;
+          break;
+        case PayoutStatus.PROCESSING:
+          stats.processing++;
+          break;
+        case PayoutStatus.COMPLETED:
+          stats.completed++;
+          stats.totalPaid += p.totalAmount;
+          break;
+        case PayoutStatus.FAILED:
+          stats.failed++;
+          break;
+      }
+    }
+    return stats;
+  }
+}
+export {
+  Commission,
+  CommissionCollection,
+  CommissionStatus,
+  CommissionType,
+  Partner,
+  PartnerCollection,
+  PartnerStatus,
+  PartnerType,
+  Payout,
+  PayoutCollection,
+  PayoutMethod,
+  PayoutStatus
+};
+//# sourceMappingURL=index.js.map