@happyvertical/smrt-analytics 0.30.0

package/dist/index.js

@@ -0,0 +1,1623 @@
+import { ObjectRegistry, foreignKey, smrt, SmrtObject, SmrtCollection, field } from "@happyvertical/smrt-core";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const smrtAnalyticsAnalyzePerformancePrompt = definePrompt({
+  key: "smrtAnalytics.property.analyzePerformance",
+  template: `Analyze the analytics performance for this property over the last {period}.
+Consider: traffic trends, user engagement, conversion patterns.
+Property: {propertyDisplayName} ({propertyProvider})`,
+  editable: {
+    template: true,
+    profile: true,
+    model: true,
+    params: true
+  }
+});
+const smrtAnalyticsAnalyzeResultsPrompt = definePrompt({
+  key: "smrtAnalytics.report.analyzeResults",
+  template: `Analyze these analytics report results and provide insights:
+
+Report: {reportName}
+Dimensions: {reportDimensions}
+Metrics: {reportMetrics}
+Date Range: {dateRangeStart} to {dateRangeEnd}
+Row Count: {rowCount}
+
+Data: {reportData}
+
+Provide:
+1. Key findings
+2. Trends or patterns
+3. Actionable recommendations`,
+  editable: {
+    template: true,
+    profile: true,
+    model: true,
+    params: true
+  }
+});
+const smrtAnalyticsHasPositiveTrendsPrompt = definePrompt({
+  key: "smrtAnalytics.report.hasPositiveTrends",
+  template: `Based on these report results, are the metrics showing positive trends?
+
+Metrics: {reportMetrics}
+Data: {reportData}
+
+Consider: user growth, engagement, conversions as positive indicators.
+
+Begin your response with the single word "yes" or "no" (lower case), then
+optionally provide a one-sentence explanation. Tooling parses the leading
+word — "yes" or "true" means positive, anything else means negative.`,
+  editable: {
+    template: true,
+    profile: true,
+    model: true,
+    params: true
+  }
+});
+function promptMessageOptions(ai) {
+  return {
+    ...ai.params || {},
+    ...ai.model ? { model: ai.model } : {},
+    ...typeof ai.temperature === "number" ? { temperature: ai.temperature } : {},
+    ...typeof ai.maxTokens === "number" ? { maxTokens: ai.maxTokens } : {}
+  };
+}
+var AnalyticsProvider = /* @__PURE__ */ ((AnalyticsProvider2) => {
+  AnalyticsProvider2["GA4"] = "ga4";
+  AnalyticsProvider2["PLAUSIBLE"] = "plausible";
+  AnalyticsProvider2["MATOMO"] = "matomo";
+  return AnalyticsProvider2;
+})(AnalyticsProvider || {});
+var AnalyticsPropertyStatus = /* @__PURE__ */ ((AnalyticsPropertyStatus2) => {
+  AnalyticsPropertyStatus2["ACTIVE"] = "active";
+  AnalyticsPropertyStatus2["INACTIVE"] = "inactive";
+  AnalyticsPropertyStatus2["PENDING"] = "pending";
+  return AnalyticsPropertyStatus2;
+})(AnalyticsPropertyStatus || {});
+var DataStreamType = /* @__PURE__ */ ((DataStreamType2) => {
+  DataStreamType2["WEB"] = "WEB_DATA_STREAM";
+  DataStreamType2["ANDROID"] = "ANDROID_APP_DATA_STREAM";
+  DataStreamType2["IOS"] = "IOS_APP_DATA_STREAM";
+  return DataStreamType2;
+})(DataStreamType || {});
+var DataStreamStatus = /* @__PURE__ */ ((DataStreamStatus2) => {
+  DataStreamStatus2["ACTIVE"] = "active";
+  DataStreamStatus2["INACTIVE"] = "inactive";
+  return DataStreamStatus2;
+})(DataStreamStatus || {});
+var ReportStatus = /* @__PURE__ */ ((ReportStatus2) => {
+  ReportStatus2["DRAFT"] = "draft";
+  ReportStatus2["SCHEDULED"] = "scheduled";
+  ReportStatus2["RUNNING"] = "running";
+  ReportStatus2["COMPLETED"] = "completed";
+  ReportStatus2["FAILED"] = "failed";
+  return ReportStatus2;
+})(ReportStatus || {});
+var ReportFrequency = /* @__PURE__ */ ((ReportFrequency2) => {
+  ReportFrequency2["ONCE"] = "once";
+  ReportFrequency2["DAILY"] = "daily";
+  ReportFrequency2["WEEKLY"] = "weekly";
+  ReportFrequency2["MONTHLY"] = "monthly";
+  return ReportFrequency2;
+})(ReportFrequency || {});
+var CustomDimensionScope = /* @__PURE__ */ ((CustomDimensionScope2) => {
+  CustomDimensionScope2["EVENT"] = "EVENT";
+  CustomDimensionScope2["USER"] = "USER";
+  CustomDimensionScope2["ITEM"] = "ITEM";
+  return CustomDimensionScope2;
+})(CustomDimensionScope || {});
+var TrackingEventStatus = /* @__PURE__ */ ((TrackingEventStatus2) => {
+  TrackingEventStatus2["PENDING"] = "pending";
+  TrackingEventStatus2["SENT"] = "sent";
+  TrackingEventStatus2["FAILED"] = "failed";
+  return TrackingEventStatus2;
+})(TrackingEventStatus || {});
+var CountingMethod = /* @__PURE__ */ ((CountingMethod2) => {
+  CountingMethod2["ONCE_PER_EVENT"] = "ONCE_PER_EVENT";
+  CountingMethod2["ONCE_PER_SESSION"] = "ONCE_PER_SESSION";
+  return CountingMethod2;
+})(CountingMethod || {});
+var __defProp$3 = 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$3(target, key, result);
+  return result;
+};
+let AnalyticsDataStream = class extends SmrtObject {
+  tenantId = null;
+  propertyId = "";
+  /**
+   * Human-readable display name
+   */
+  displayName = "";
+  /**
+   * Stream type (WEB, ANDROID, IOS)
+   */
+  streamType = DataStreamType.WEB;
+  /**
+   * External stream ID from provider
+   */
+  externalId = "";
+  /**
+   * Measurement ID for web streams (G-XXXXXXX)
+   */
+  measurementId = "";
+  /**
+   * Firebase App ID for app streams
+   */
+  firebaseAppId = "";
+  /**
+   * Default URI for web streams
+   */
+  defaultUri = "";
+  /**
+   * Bundle ID for iOS apps
+   */
+  bundleId = "";
+  /**
+   * Package name for Android apps
+   */
+  packageName = "";
+  /**
+   * Stream status
+   */
+  status = DataStreamStatus.ACTIVE;
+  /**
+   * Enhanced measurement enabled
+   */
+  enhancedMeasurement = true;
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.propertyId !== void 0) this.propertyId = options.propertyId;
+    if (options.displayName !== void 0)
+      this.displayName = options.displayName;
+    if (options.streamType !== void 0) this.streamType = options.streamType;
+    if (options.externalId !== void 0) this.externalId = options.externalId;
+    if (options.measurementId !== void 0)
+      this.measurementId = options.measurementId;
+    if (options.firebaseAppId !== void 0)
+      this.firebaseAppId = options.firebaseAppId;
+    if (options.defaultUri !== void 0) this.defaultUri = options.defaultUri;
+    if (options.bundleId !== void 0) this.bundleId = options.bundleId;
+    if (options.packageName !== void 0)
+      this.packageName = options.packageName;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.enhancedMeasurement !== void 0)
+      this.enhancedMeasurement = options.enhancedMeasurement;
+  }
+  /**
+   * Check if this is a web stream
+   */
+  isWeb() {
+    return this.streamType === DataStreamType.WEB;
+  }
+  /**
+   * Check if this is an iOS app stream
+   */
+  isIOS() {
+    return this.streamType === DataStreamType.IOS;
+  }
+  /**
+   * Check if this is an Android app stream
+   */
+  isAndroid() {
+    return this.streamType === DataStreamType.ANDROID;
+  }
+  /**
+   * Check if this is a mobile app stream (iOS or Android)
+   */
+  isMobileApp() {
+    return this.isIOS() || this.isAndroid();
+  }
+  /**
+   * Get the platform identifier (measurementId for web, firebaseAppId for apps)
+   */
+  getPlatformId() {
+    if (this.isWeb()) {
+      return this.measurementId;
+    }
+    return this.firebaseAppId;
+  }
+};
+__decorateClass$3([
+  tenantId({ nullable: true })
+], AnalyticsDataStream.prototype, "tenantId", 2);
+__decorateClass$3([
+  foreignKey("AnalyticsProperty")
+], AnalyticsDataStream.prototype, "propertyId", 2);
+AnalyticsDataStream = __decorateClass$3([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], AnalyticsDataStream);
+class AnalyticsDataStreamCollection extends SmrtCollection {
+  static _itemClass = AnalyticsDataStream;
+  /**
+   * Find streams by property
+   *
+   * @param propertyId - Parent property ID
+   * @returns Array of data streams
+   */
+  async findByProperty(propertyId) {
+    return await this.list({
+      where: { propertyId },
+      orderBy: "displayName ASC"
+    });
+  }
+  /**
+   * Find stream by external ID
+   *
+   * @param externalId - External stream ID from provider
+   * @returns Matching stream or null
+   */
+  async findByExternalId(externalId) {
+    const results = await this.list({
+      where: { externalId },
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find stream by measurement ID (web streams)
+   *
+   * @param measurementId - GA4 measurement ID (G-XXXXXXX)
+   * @returns Matching stream or null
+   */
+  async findByMeasurementId(measurementId) {
+    const results = await this.list({
+      where: { measurementId },
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find streams by type
+   *
+   * @param streamType - Stream type (WEB, ANDROID, IOS)
+   * @returns Array of matching streams
+   */
+  async findByType(streamType) {
+    return await this.list({
+      where: { streamType },
+      orderBy: "displayName ASC"
+    });
+  }
+  /**
+   * Find all web streams
+   */
+  async findWebStreams() {
+    return await this.findByType(DataStreamType.WEB);
+  }
+  /**
+   * Find all iOS app streams
+   */
+  async findIOSStreams() {
+    return await this.findByType(DataStreamType.IOS);
+  }
+  /**
+   * Find all Android app streams
+   */
+  async findAndroidStreams() {
+    return await this.findByType(DataStreamType.ANDROID);
+  }
+  /**
+   * Find all mobile app streams (iOS + Android)
+   */
+  async findMobileStreams() {
+    const ios = await this.findIOSStreams();
+    const android = await this.findAndroidStreams();
+    return [...ios, ...android].sort(
+      (a, b) => a.displayName.localeCompare(b.displayName)
+    );
+  }
+  /**
+   * Find streams by status
+   *
+   * @param status - Stream status
+   * @returns Array of matching streams
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "displayName ASC"
+    });
+  }
+  /**
+   * Find all active streams
+   */
+  async findActive() {
+    return await this.findByStatus(DataStreamStatus.ACTIVE);
+  }
+  /**
+   * Find active streams for a property
+   *
+   * @param propertyId - Parent property ID
+   * @returns Array of active streams
+   */
+  async findActiveByProperty(propertyId) {
+    return await this.list({
+      where: {
+        propertyId,
+        status: DataStreamStatus.ACTIVE
+      },
+      orderBy: "displayName ASC"
+    });
+  }
+}
+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 AnalyticsEvent = class extends SmrtObject {
+  tenantId = null;
+  propertyId = "";
+  /**
+   * Event name (e.g., 'purchase', 'page_view', 'sign_up')
+   */
+  eventName = "";
+  /**
+   * Client ID for anonymous tracking
+   */
+  clientId = "";
+  /**
+   * User ID for identified tracking
+   */
+  userId = "";
+  /**
+   * Event parameters (JSON)
+   */
+  params = "{}";
+  /**
+   * Event timestamp
+   */
+  eventTimestamp = /* @__PURE__ */ new Date();
+  /**
+   * Tracking status
+   */
+  status = TrackingEventStatus.PENDING;
+  /**
+   * Timestamp when sent to provider
+   */
+  sentAt = null;
+  /**
+   * Error message if sending failed
+   */
+  errorMessage = "";
+  /**
+   * Retry count
+   */
+  retryCount = 0;
+  /**
+   * Disable personalized ads
+   */
+  nonPersonalizedAds = false;
+  /**
+   * Session ID
+   */
+  sessionId = "";
+  /**
+   * Page path (for pageview events)
+   */
+  pagePath = "";
+  /**
+   * Page title (for pageview events)
+   */
+  pageTitle = "";
+  /**
+   * User agent
+   */
+  userAgent = "";
+  /**
+   * IP address (anonymized)
+   */
+  ipAddress = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.propertyId !== void 0) this.propertyId = options.propertyId;
+    if (options.eventName !== void 0) this.eventName = options.eventName;
+    if (options.clientId !== void 0) this.clientId = options.clientId;
+    if (options.userId !== void 0) this.userId = options.userId;
+    if (options.params !== void 0) this.params = options.params;
+    if (options.eventTimestamp !== void 0)
+      this.eventTimestamp = options.eventTimestamp;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.sentAt !== void 0) this.sentAt = options.sentAt;
+    if (options.errorMessage !== void 0)
+      this.errorMessage = options.errorMessage;
+    if (options.retryCount !== void 0) this.retryCount = options.retryCount;
+    if (options.nonPersonalizedAds !== void 0)
+      this.nonPersonalizedAds = options.nonPersonalizedAds;
+    if (options.sessionId !== void 0) this.sessionId = options.sessionId;
+    if (options.pagePath !== void 0) this.pagePath = options.pagePath;
+    if (options.pageTitle !== void 0) this.pageTitle = options.pageTitle;
+    if (options.userAgent !== void 0) this.userAgent = options.userAgent;
+    if (options.ipAddress !== void 0) this.ipAddress = options.ipAddress;
+  }
+  /**
+   * Get parsed event parameters
+   */
+  getParams() {
+    try {
+      return JSON.parse(this.params);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set event parameters
+   */
+  setParams(params) {
+    this.params = JSON.stringify(params);
+  }
+  /**
+   * Add a parameter to the event
+   */
+  addParam(key, value) {
+    const params = this.getParams();
+    params[key] = value;
+    this.setParams(params);
+  }
+  /**
+   * Check if this is a pageview event
+   */
+  isPageview() {
+    return this.eventName === "page_view" || this.eventName === "pageview";
+  }
+  /**
+   * Check if this is a conversion event
+   */
+  isConversion() {
+    const conversionEvents = [
+      "purchase",
+      "sign_up",
+      "generate_lead",
+      "begin_checkout"
+    ];
+    return conversionEvents.includes(this.eventName);
+  }
+  /**
+   * Mark as sent successfully
+   */
+  markSent() {
+    this.status = TrackingEventStatus.SENT;
+    this.sentAt = /* @__PURE__ */ new Date();
+    this.errorMessage = "";
+  }
+  /**
+   * Mark as failed
+   */
+  markFailed(error) {
+    this.status = TrackingEventStatus.FAILED;
+    this.errorMessage = error;
+    this.retryCount++;
+  }
+  /**
+   * Reset for retry
+   */
+  resetForRetry() {
+    this.status = TrackingEventStatus.PENDING;
+    this.sentAt = null;
+  }
+  /**
+   * Check if event should be retried
+   */
+  shouldRetry(maxRetries = 3) {
+    return this.status === TrackingEventStatus.FAILED && this.retryCount < maxRetries;
+  }
+  /**
+   * Build SDK TrackEvent object
+   */
+  toTrackEvent() {
+    return {
+      name: this.eventName,
+      params: this.getParams(),
+      clientId: this.clientId || void 0,
+      userId: this.userId || void 0,
+      timestamp: this.eventTimestamp.getTime() * 1e3,
+      // Convert to microseconds
+      nonPersonalizedAds: this.nonPersonalizedAds
+    };
+  }
+};
+__decorateClass$2([
+  tenantId({ nullable: true })
+], AnalyticsEvent.prototype, "tenantId", 2);
+__decorateClass$2([
+  foreignKey("AnalyticsProperty")
+], AnalyticsEvent.prototype, "propertyId", 2);
+AnalyticsEvent = __decorateClass$2([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create"] },
+    mcp: { include: ["list", "get", "track"] },
+    cli: true
+  })
+], AnalyticsEvent);
+class AnalyticsEventCollection extends SmrtCollection {
+  static _itemClass = AnalyticsEvent;
+  /**
+   * Find events by property
+   *
+   * @param propertyId - Parent property ID
+   * @returns Array of events
+   */
+  async findByProperty(propertyId) {
+    return await this.list({
+      where: { propertyId },
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Find events by event name
+   *
+   * @param eventName - Event name to filter by
+   * @returns Array of matching events
+   */
+  async findByEventName(eventName) {
+    return await this.list({
+      where: { eventName },
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Find events by client ID
+   *
+   * @param clientId - Client ID
+   * @returns Array of events for this client
+   */
+  async findByClientId(clientId) {
+    return await this.list({
+      where: { clientId },
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Find events by user ID
+   *
+   * @param userId - User ID
+   * @returns Array of events for this user
+   */
+  async findByUserId(userId) {
+    return await this.list({
+      where: { userId },
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Find events by status
+   *
+   * @param status - Tracking event status
+   * @returns Array of matching events
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Find all pending events
+   */
+  async findPending() {
+    return await this.findByStatus(TrackingEventStatus.PENDING);
+  }
+  /**
+   * Find all sent events
+   */
+  async findSent() {
+    return await this.findByStatus(TrackingEventStatus.SENT);
+  }
+  /**
+   * Find all failed events
+   */
+  async findFailed() {
+    return await this.findByStatus(TrackingEventStatus.FAILED);
+  }
+  /**
+   * Find events that should be retried
+   *
+   * @param maxRetries - Maximum retry count
+   * @returns Array of events eligible for retry
+   */
+  async findForRetry(maxRetries = 3) {
+    const failed = await this.findFailed();
+    return failed.filter((e) => e.shouldRetry(maxRetries));
+  }
+  /**
+   * Find pending events for a property
+   *
+   * @param propertyId - Parent property ID
+   * @returns Array of pending events
+   */
+  async findPendingByProperty(propertyId) {
+    return await this.list({
+      where: {
+        propertyId,
+        status: TrackingEventStatus.PENDING
+      },
+      orderBy: "eventTimestamp ASC"
+      // Process oldest first
+    });
+  }
+  /**
+   * Find events by date range
+   *
+   * @param startDate - Start date
+   * @param endDate - End date
+   * @returns Array of events in date range
+   */
+  async findByDateRange(startDate, endDate) {
+    return await this.list({
+      where: {
+        "eventTimestamp >=": startDate.toISOString(),
+        "eventTimestamp <=": endDate.toISOString()
+      },
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Find conversion events
+   *
+   * @param propertyId - Optional property ID filter
+   * @returns Array of conversion events
+   */
+  async findConversions(propertyId) {
+    const conversionEvents = [
+      "purchase",
+      "sign_up",
+      "generate_lead",
+      "begin_checkout"
+    ];
+    const all = propertyId ? await this.findByProperty(propertyId) : await this.list({ orderBy: "eventTimestamp DESC" });
+    return all.filter((e) => conversionEvents.includes(e.eventName));
+  }
+  /**
+   * Find pageview events
+   *
+   * @param propertyId - Optional property ID filter
+   * @returns Array of pageview events
+   */
+  async findPageviews(propertyId) {
+    const where = { eventName: "page_view" };
+    if (propertyId) {
+      where.propertyId = propertyId;
+    }
+    return await this.list({
+      where,
+      orderBy: "eventTimestamp DESC"
+    });
+  }
+  /**
+   * Count events by event name for a property
+   *
+   * @param propertyId - Property ID
+   * @returns Map of event name to count
+   */
+  async countByEventName(propertyId) {
+    const events = await this.findByProperty(propertyId);
+    const counts = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const current = counts.get(event.eventName) || 0;
+      counts.set(event.eventName, current + 1);
+    }
+    return counts;
+  }
+  /**
+   * Get event stats for a property
+   *
+   * @param propertyId - Property ID
+   * @returns Event statistics
+   */
+  async getPropertyStats(propertyId) {
+    const events = await this.findByProperty(propertyId);
+    return {
+      total: events.length,
+      pending: events.filter((e) => e.status === TrackingEventStatus.PENDING).length,
+      sent: events.filter((e) => e.status === TrackingEventStatus.SENT).length,
+      failed: events.filter((e) => e.status === TrackingEventStatus.FAILED).length,
+      conversions: events.filter((e) => e.isConversion()).length,
+      pageviews: events.filter((e) => e.isPageview()).length
+    };
+  }
+  /**
+   * Get day-over-day pageview stats with trend for a property.
+   *
+   * Compares today's pageview count against yesterday's to produce a
+   * trend direction and percentage change. A threshold of 5% is used
+   * to classify 'up' vs 'down' vs 'flat'.
+   *
+   * @param propertyId - Property ID
+   * @param now - Optional current date (for testing)
+   * @returns Stats with trend
+   */
+  async getPropertyStatsWithTrend(propertyId, now) {
+    const currentTime = now || /* @__PURE__ */ new Date();
+    const todayStart = new Date(
+      Date.UTC(
+        currentTime.getUTCFullYear(),
+        currentTime.getUTCMonth(),
+        currentTime.getUTCDate()
+      )
+    );
+    const yesterdayStart = new Date(todayStart.getTime() - 864e5);
+    const allPageviewEvents = await this.list({
+      where: {
+        propertyId,
+        eventName: "page_view",
+        "eventTimestamp >=": yesterdayStart.toISOString(),
+        "eventTimestamp <=": currentTime.toISOString()
+      }
+    });
+    const todayPageviewEvents = allPageviewEvents.filter(
+      (e) => new Date(e.eventTimestamp) >= todayStart
+    );
+    const yesterdayPageviewEvents = allPageviewEvents.filter(
+      (e) => new Date(e.eventTimestamp) < todayStart
+    );
+    const todayClients = new Set(todayPageviewEvents.map((e) => e.clientId));
+    const yesterdayClients = new Set(
+      yesterdayPageviewEvents.map((e) => e.clientId)
+    );
+    const todayPageviews = todayPageviewEvents.length;
+    const yesterdayPageviews = yesterdayPageviewEvents.length;
+    let trend = "flat";
+    let trendPercent = 0;
+    if (yesterdayPageviews > 0) {
+      const change = (todayPageviews - yesterdayPageviews) / yesterdayPageviews * 100;
+      trendPercent = Math.round(change);
+      if (change > 5) trend = "up";
+      else if (change < -5) trend = "down";
+    }
+    return {
+      todayPageviews,
+      todayUsers: todayClients.size,
+      yesterdayPageviews,
+      yesterdayUsers: yesterdayClients.size,
+      trend,
+      trendPercent
+    };
+  }
+  /**
+   * Get day-over-day stats for multiple properties in batch.
+   *
+   * @param propertyIds - Array of property IDs
+   * @param now - Optional current date (for testing)
+   * @returns Map of propertyId to stats
+   */
+  async getBatchPropertyStats(propertyIds, now) {
+    const results = /* @__PURE__ */ new Map();
+    const currentTime = now || /* @__PURE__ */ new Date();
+    const todayStart = new Date(
+      Date.UTC(
+        currentTime.getUTCFullYear(),
+        currentTime.getUTCMonth(),
+        currentTime.getUTCDate()
+      )
+    );
+    const yesterdayStart = new Date(todayStart.getTime() - 864e5);
+    const allEvents = await this.list({
+      where: {
+        eventName: "page_view",
+        "eventTimestamp >=": yesterdayStart.toISOString(),
+        "eventTimestamp <=": currentTime.toISOString()
+      }
+    });
+    const todayByProperty = /* @__PURE__ */ new Map();
+    const yesterdayByProperty = /* @__PURE__ */ new Map();
+    for (const e of allEvents) {
+      const isToday = new Date(e.eventTimestamp) >= todayStart;
+      const map = isToday ? todayByProperty : yesterdayByProperty;
+      const list = map.get(e.propertyId);
+      if (list) list.push(e);
+      else map.set(e.propertyId, [e]);
+    }
+    for (const propertyId of propertyIds) {
+      const todayPageviewEvents = todayByProperty.get(propertyId) ?? [];
+      const yesterdayPageviewEvents = yesterdayByProperty.get(propertyId) ?? [];
+      const todayClients = new Set(todayPageviewEvents.map((e) => e.clientId));
+      const yesterdayClients = new Set(
+        yesterdayPageviewEvents.map((e) => e.clientId)
+      );
+      const todayPageviews = todayPageviewEvents.length;
+      const yesterdayPageviews = yesterdayPageviewEvents.length;
+      let trend = "flat";
+      let trendPercent = 0;
+      if (yesterdayPageviews > 0) {
+        const change = (todayPageviews - yesterdayPageviews) / yesterdayPageviews * 100;
+        trendPercent = Math.round(change);
+        if (change > 5) trend = "up";
+        else if (change < -5) trend = "down";
+      }
+      results.set(propertyId, {
+        todayPageviews,
+        todayUsers: todayClients.size,
+        yesterdayPageviews,
+        yesterdayUsers: yesterdayClients.size,
+        trend,
+        trendPercent
+      });
+    }
+    return results;
+  }
+}
+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 AnalyticsProperty = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Internal name/identifier
+   */
+  name = "";
+  /**
+   * Human-readable display name
+   */
+  displayName = "";
+  /**
+   * Analytics provider (ga4, plausible, matomo)
+   */
+  provider = AnalyticsProvider.GA4;
+  /**
+   * External ID from the provider (e.g., "properties/123456789" for GA4,
+   * idSite for Matomo)
+   */
+  externalId = "";
+  /**
+   * Measurement ID for GA4 (G-XXXXXXXXXX)
+   */
+  measurementId = "";
+  apiSecret = "";
+  /**
+   * Site domain for Plausible/Matomo
+   */
+  siteDomain = "";
+  /**
+   * Property timezone
+   */
+  timeZone = "America/Los_Angeles";
+  /**
+   * Currency code (e.g., 'USD', 'EUR')
+   */
+  currencyCode = "USD";
+  /**
+   * Industry category
+   */
+  industryCategory = "";
+  /**
+   * Service level (STANDARD, PREMIUM)
+   */
+  serviceLevel = "STANDARD";
+  /**
+   * Property status
+   */
+  status = AnalyticsPropertyStatus.ACTIVE;
+  /**
+   * Last sync timestamp with provider
+   */
+  lastSyncAt = null;
+  providerMetadata = "{}";
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.displayName !== void 0)
+      this.displayName = options.displayName;
+    if (options.provider !== void 0) this.provider = options.provider;
+    if (options.externalId !== void 0) this.externalId = options.externalId;
+    if (options.measurementId !== void 0)
+      this.measurementId = options.measurementId;
+    if (options.apiSecret !== void 0) this.apiSecret = options.apiSecret;
+    if (options.siteDomain !== void 0) this.siteDomain = options.siteDomain;
+    if (options.timeZone !== void 0) this.timeZone = options.timeZone;
+    if (options.currencyCode !== void 0)
+      this.currencyCode = options.currencyCode;
+    if (options.industryCategory !== void 0)
+      this.industryCategory = options.industryCategory;
+    if (options.serviceLevel !== void 0)
+      this.serviceLevel = options.serviceLevel;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.lastSyncAt !== void 0) this.lastSyncAt = options.lastSyncAt;
+    if (options.providerMetadata !== void 0)
+      this.providerMetadata = options.providerMetadata;
+  }
+  /**
+   * Check if this is a GA4 property
+   */
+  isGA4() {
+    return this.provider === AnalyticsProvider.GA4;
+  }
+  /**
+   * Check if this is a Plausible site
+   */
+  isPlausible() {
+    return this.provider === AnalyticsProvider.PLAUSIBLE;
+  }
+  /**
+   * Check if this is a Matomo site
+   */
+  isMatomo() {
+    return this.provider === AnalyticsProvider.MATOMO;
+  }
+  /**
+   * Get parsed provider metadata
+   */
+  getProviderMetadata() {
+    try {
+      return JSON.parse(this.providerMetadata);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set provider metadata
+   */
+  setProviderMetadata(metadata) {
+    this.providerMetadata = JSON.stringify(metadata);
+  }
+  /**
+   * Mark as synced with provider
+   */
+  markSynced() {
+    this.lastSyncAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * AI-powered: Analyze property performance.
+   *
+   * Uses the `smrtAnalytics.property.analyzePerformance` prompt registered
+   * via `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
+   * overrides of the template, model, and parameters at runtime.
+   *
+   * Only non-PII fields (display name, provider label, requested period)
+   * are sent to the AI provider. Internal identifiers (`id`, `externalId`,
+   * `measurementId`, `apiSecret`, `providerMetadata`) are intentionally
+   * excluded — see `../prompts.ts` for the full exclusion rationale.
+   */
+  async analyzePerformance(options = {}) {
+    const period = options.period || "30 days";
+    const db = this.options.db ?? this.options.persistence;
+    const resolvedPrompt = await resolvePrompt(
+      smrtAnalyticsAnalyzePerformancePrompt.key,
+      {
+        db,
+        variables: {
+          period,
+          propertyDisplayName: this.displayName || "",
+          propertyProvider: this.provider || ""
+        }
+      }
+    );
+    const ai = await this.getAiClient();
+    const analysis = await ai.message(
+      resolvedPrompt.text,
+      promptMessageOptions(resolvedPrompt.ai)
+    );
+    return {
+      action: "analyzePerformance",
+      period,
+      analysis: analysis.trim()
+    };
+  }
+  /**
+   * AI-powered: Check if property is performing well
+   */
+  async isPerformingWell() {
+    return await this.is(
+      `
+      Based on the property configuration and metadata:
+      - Property: ${this.displayName}
+      - Provider: ${this.provider}
+      - Status: ${this.status}
+      - Last sync: ${this.lastSyncAt}
+
+      Is this property properly configured and likely performing well?
+    `,
+      // Property fields hand-rolled above; skip is()'s object-data injection.
+      { includeData: false }
+    );
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], AnalyticsProperty.prototype, "tenantId", 2);
+__decorateClass$1([
+  field({ sensitive: true })
+], AnalyticsProperty.prototype, "apiSecret", 2);
+__decorateClass$1([
+  field({ sensitive: true })
+], AnalyticsProperty.prototype, "providerMetadata", 2);
+AnalyticsProperty = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update"] },
+    mcp: { include: ["list", "get", "sync", "runReport"] },
+    cli: true
+  })
+], AnalyticsProperty);
+class AnalyticsPropertyCollection extends SmrtCollection {
+  static _itemClass = AnalyticsProperty;
+  /**
+   * Find property by external ID
+   *
+   * @param externalId - External ID from provider
+   * @returns Matching property or null
+   */
+  async findByExternalId(externalId) {
+    const results = await this.list({
+      where: { externalId },
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find property by measurement ID (GA4)
+   *
+   * @param measurementId - GA4 measurement ID (G-XXXXXXXXXX)
+   * @returns Matching property or null
+   */
+  async findByMeasurementId(measurementId) {
+    const results = await this.list({
+      where: { measurementId },
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find property by site domain and optional provider.
+   *
+   * @param siteDomain - Provider site domain
+   * @param provider - Optional provider discriminator for migration/coexistence
+   * @returns Matching property or null
+   */
+  async findBySiteDomain(siteDomain, provider) {
+    const results = await this.list({
+      where: provider ? { siteDomain, provider } : { siteDomain },
+      limit: 1
+    });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Find properties by provider
+   *
+   * @param provider - Analytics provider
+   * @returns Array of matching properties
+   */
+  async findByProvider(provider) {
+    return await this.list({
+      where: { provider },
+      orderBy: "displayName ASC"
+    });
+  }
+  /**
+   * Find all GA4 properties
+   */
+  async findGA4Properties() {
+    return await this.findByProvider(AnalyticsProvider.GA4);
+  }
+  /**
+   * Find all Plausible sites
+   */
+  async findPlausibleSites() {
+    return await this.findByProvider(AnalyticsProvider.PLAUSIBLE);
+  }
+  /**
+   * Find all Matomo sites
+   */
+  async findMatomoSites() {
+    return await this.findByProvider(AnalyticsProvider.MATOMO);
+  }
+  /**
+   * Find properties by status
+   *
+   * @param status - Property status
+   * @returns Array of matching properties
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "displayName ASC"
+    });
+  }
+  /**
+   * Find all active properties
+   */
+  async findActive() {
+    return await this.findByStatus(AnalyticsPropertyStatus.ACTIVE);
+  }
+  /**
+   * Find properties that need syncing (not synced in last N hours)
+   *
+   * @param hoursAgo - Hours since last sync
+   * @returns Array of properties needing sync
+   */
+  async findNeedingSync(hoursAgo = 24) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setTime(cutoff.getTime() - hoursAgo * 60 * 60 * 1e3);
+    const all = await this.findActive();
+    return all.filter((p) => !p.lastSyncAt || p.lastSyncAt < cutoff);
+  }
+}
+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 AnalyticsReport = class extends SmrtObject {
+  tenantId = null;
+  propertyId = "";
+  /**
+   * Report name
+   */
+  name = "";
+  /**
+   * Report description
+   */
+  description = "";
+  /**
+   * Dimensions to group by (JSON array)
+   */
+  dimensions = "[]";
+  /**
+   * Metrics to retrieve (JSON array)
+   */
+  metrics = "[]";
+  /**
+   * Date range start (relative or absolute)
+   */
+  dateRangeStart = "7daysAgo";
+  /**
+   * Date range end (relative or absolute)
+   */
+  dateRangeEnd = "today";
+  /**
+   * Dimension filter expression (JSON)
+   */
+  dimensionFilter = "";
+  /**
+   * Metric filter expression (JSON)
+   */
+  metricFilter = "";
+  /**
+   * Sort order (JSON array)
+   */
+  orderBy = "[]";
+  /**
+   * Maximum results to return
+   */
+  maxResults = 0;
+  /**
+   * Report status
+   */
+  status = ReportStatus.DRAFT;
+  /**
+   * Scheduling frequency
+   */
+  frequency = ReportFrequency.ONCE;
+  /**
+   * Last run timestamp
+   */
+  lastRunAt = null;
+  /**
+   * Next scheduled run
+   */
+  nextRunAt = null;
+  /**
+   * Cached result data (JSON)
+   */
+  resultData = "";
+  /**
+   * Row count from last run
+   */
+  rowCount = 0;
+  /**
+   * Error message from last failed run
+   */
+  lastError = "";
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.propertyId !== void 0) this.propertyId = options.propertyId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.dimensions !== void 0) this.dimensions = options.dimensions;
+    if (options.metrics !== void 0) this.metrics = options.metrics;
+    if (options.dateRangeStart !== void 0)
+      this.dateRangeStart = options.dateRangeStart;
+    if (options.dateRangeEnd !== void 0)
+      this.dateRangeEnd = options.dateRangeEnd;
+    if (options.dimensionFilter !== void 0)
+      this.dimensionFilter = options.dimensionFilter;
+    if (options.metricFilter !== void 0)
+      this.metricFilter = options.metricFilter;
+    if (options.orderBy !== void 0) this.orderBy = options.orderBy;
+    if (options.maxResults !== void 0) this.maxResults = options.maxResults;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.frequency !== void 0) this.frequency = options.frequency;
+    if (options.lastRunAt !== void 0) this.lastRunAt = options.lastRunAt;
+    if (options.nextRunAt !== void 0) this.nextRunAt = options.nextRunAt;
+    if (options.resultData !== void 0) this.resultData = options.resultData;
+    if (options.rowCount !== void 0) this.rowCount = options.rowCount;
+    if (options.lastError !== void 0) this.lastError = options.lastError;
+  }
+  /**
+   * Get parsed dimensions
+   */
+  getDimensions() {
+    try {
+      return JSON.parse(this.dimensions);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set dimensions
+   */
+  setDimensions(dimensions) {
+    this.dimensions = JSON.stringify(dimensions);
+  }
+  /**
+   * Get parsed metrics
+   */
+  getMetrics() {
+    try {
+      return JSON.parse(this.metrics);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set metrics
+   */
+  setMetrics(metrics) {
+    this.metrics = JSON.stringify(metrics);
+  }
+  /**
+   * Get parsed result data
+   */
+  getResultData() {
+    if (!this.resultData) return null;
+    try {
+      return JSON.parse(this.resultData);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set result data
+   */
+  setResultData(data) {
+    this.resultData = JSON.stringify(data);
+  }
+  /**
+   * Mark report as running
+   */
+  markRunning() {
+    this.status = ReportStatus.RUNNING;
+    this.lastError = "";
+  }
+  /**
+   * Mark report as completed with results
+   */
+  markCompleted(rowCount) {
+    this.status = ReportStatus.COMPLETED;
+    this.lastRunAt = /* @__PURE__ */ new Date();
+    this.rowCount = rowCount;
+    this.lastError = "";
+    this.calculateNextRun();
+  }
+  /**
+   * Mark report as failed
+   */
+  markFailed(error) {
+    this.status = ReportStatus.FAILED;
+    this.lastRunAt = /* @__PURE__ */ new Date();
+    this.lastError = error;
+    this.calculateNextRun();
+  }
+  /**
+   * Calculate next scheduled run based on frequency
+   */
+  calculateNextRun() {
+    if (this.frequency === ReportFrequency.ONCE) {
+      this.nextRunAt = null;
+      return;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const next = new Date(now);
+    switch (this.frequency) {
+      case ReportFrequency.DAILY:
+        next.setDate(next.getDate() + 1);
+        break;
+      case ReportFrequency.WEEKLY:
+        next.setDate(next.getDate() + 7);
+        break;
+      case ReportFrequency.MONTHLY:
+        next.setMonth(next.getMonth() + 1);
+        break;
+    }
+    this.nextRunAt = next;
+  }
+  /**
+   * Check if report is due to run
+   */
+  isDue() {
+    if (this.frequency === ReportFrequency.ONCE) {
+      return this.status === ReportStatus.SCHEDULED && !this.lastRunAt;
+    }
+    if (!this.nextRunAt) return false;
+    return /* @__PURE__ */ new Date() >= this.nextRunAt;
+  }
+  /**
+   * AI-powered: Analyze report results.
+   *
+   * Uses the `smrtAnalytics.report.analyzeResults` prompt registered via
+   * `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
+   * overrides of the template, model, and parameters at runtime.
+   *
+   * Internal identifiers (`id`, `propertyId`, `tenantId`, `lastError`, raw
+   * `dimensionFilter` / `metricFilter` JSON) are excluded from the prompt
+   * variables — see `../prompts.ts` for the exclusion rationale.
+   *
+   * **`resultData` is FORWARDED VERBATIM.** The persisted result rows are
+   * JSON-stringified into the `reportData` variable; this package cannot
+   * strip PII because the row schema is determined by which dimensions /
+   * metrics the caller asked the analytics provider to return. If the
+   * persisted rows contain `userPseudoId`, `clientId`, IP-derived
+   * geolocation, or any other identifier, those fields WILL reach the AI
+   * provider. Callers are responsible for excluding PII-bearing dimensions
+   * before persisting, applying a column allowlist at the call site, or
+   * overriding the prompt template via `PromptOverride`. The forwarding is
+   * pinned by a regression test in
+   * `__tests__/analytics-report-prompt.test.ts`.
+   *
+   * The previous implementation issued a second freeform `this.do()` call
+   * to re-summarize "top 3 insights"; that behaviour is now folded into
+   * the single registered template (which already asks for findings,
+   * trends, and recommendations) — `insights` mirrors `analysis` so the
+   * return shape is preserved without a redundant AI round-trip.
+   */
+  async analyzeResults(_options = {}) {
+    const resultData = this.getResultData();
+    const db = this.options.db ?? this.options.persistence;
+    const resolvedPrompt = await resolvePrompt(
+      smrtAnalyticsAnalyzeResultsPrompt.key,
+      {
+        db,
+        variables: {
+          reportName: this.name || "",
+          reportDimensions: this.dimensions || "[]",
+          reportMetrics: this.metrics || "[]",
+          dateRangeStart: this.dateRangeStart || "",
+          dateRangeEnd: this.dateRangeEnd || "",
+          rowCount: String(this.rowCount),
+          reportData: JSON.stringify(resultData, null, 2)
+        }
+      }
+    );
+    const ai = await this.getAiClient();
+    const analysis = (await ai.message(
+      resolvedPrompt.text,
+      promptMessageOptions(resolvedPrompt.ai)
+    )).trim();
+    return {
+      action: "analyzeResults",
+      analysis,
+      insights: analysis
+    };
+  }
+  /**
+   * AI-powered: Check if results show positive trends.
+   *
+   * Uses the `smrtAnalytics.report.hasPositiveTrends` prompt registered
+   * via `@happyvertical/smrt-prompts`. Only the metric labels and the
+   * aggregate `resultData` JSON are sent to the AI provider — though as
+   * with `analyzeResults`, `resultData` is forwarded verbatim and may
+   * carry PII the caller persisted; see `analyzeResults` docstring and
+   * `../prompts.ts`.
+   *
+   * Boolean coercion uses `/^\s*(yes|true)\b/i` against the trimmed
+   * response. The registered prompt template explicitly instructs the
+   * model to begin its answer with the literal word "yes" or "no" so
+   * this regex is reliable; tenant overrides MUST preserve that leading-
+   * word convention or the boolean will silently fall to `false`.
+   */
+  async hasPositiveTrends() {
+    const resultData = this.getResultData();
+    const db = this.options.db ?? this.options.persistence;
+    const resolvedPrompt = await resolvePrompt(
+      smrtAnalyticsHasPositiveTrendsPrompt.key,
+      {
+        db,
+        variables: {
+          reportMetrics: this.metrics || "[]",
+          reportData: JSON.stringify(resultData)
+        }
+      }
+    );
+    const ai = await this.getAiClient();
+    const response = (await ai.message(
+      resolvedPrompt.text,
+      promptMessageOptions(resolvedPrompt.ai)
+    )).trim();
+    return /^\s*(yes|true)\b/i.test(response);
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], AnalyticsReport.prototype, "tenantId", 2);
+__decorateClass([
+  foreignKey("AnalyticsProperty")
+], AnalyticsReport.prototype, "propertyId", 2);
+AnalyticsReport = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "run"] },
+    mcp: { include: ["list", "get", "run", "analyze"] },
+    cli: true
+  })
+], AnalyticsReport);
+class AnalyticsReportCollection extends SmrtCollection {
+  static _itemClass = AnalyticsReport;
+  /**
+   * Find reports by property
+   *
+   * @param propertyId - Parent property ID
+   * @returns Array of reports
+   */
+  async findByProperty(propertyId) {
+    return await this.list({
+      where: { propertyId },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find reports by status
+   *
+   * @param status - Report status
+   * @returns Array of matching reports
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find all draft reports
+   */
+  async findDrafts() {
+    return await this.findByStatus(ReportStatus.DRAFT);
+  }
+  /**
+   * Find all scheduled reports
+   */
+  async findScheduled() {
+    return await this.findByStatus(ReportStatus.SCHEDULED);
+  }
+  /**
+   * Find all completed reports
+   */
+  async findCompleted() {
+    return await this.findByStatus(ReportStatus.COMPLETED);
+  }
+  /**
+   * Find all failed reports
+   */
+  async findFailed() {
+    return await this.findByStatus(ReportStatus.FAILED);
+  }
+  /**
+   * Find reports by frequency
+   *
+   * @param frequency - Report frequency
+   * @returns Array of matching reports
+   */
+  async findByFrequency(frequency) {
+    return await this.list({
+      where: { frequency },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find all recurring reports (not one-time)
+   */
+  async findRecurring() {
+    const all = await this.list({ orderBy: "name ASC" });
+    return all.filter((r) => r.frequency !== ReportFrequency.ONCE);
+  }
+  /**
+   * Find reports due to run
+   *
+   * @returns Array of reports that are due
+   */
+  async findDue() {
+    const all = await this.list({
+      where: { status: ReportStatus.SCHEDULED }
+    });
+    return all.filter((r) => r.isDue());
+  }
+  /**
+   * Find reports for a property by status
+   *
+   * @param propertyId - Parent property ID
+   * @param status - Report status
+   * @returns Array of matching reports
+   */
+  async findByPropertyAndStatus(propertyId, status) {
+    return await this.list({
+      where: { propertyId, status },
+      orderBy: "name ASC"
+    });
+  }
+  /**
+   * Find recently run reports
+   *
+   * @param hoursAgo - Hours since last run
+   * @returns Array of recently run reports
+   */
+  async findRecentlyRun(hoursAgo = 24) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setTime(cutoff.getTime() - hoursAgo * 60 * 60 * 1e3);
+    const all = await this.list({ orderBy: "lastRunAt DESC" });
+    return all.filter((r) => r.lastRunAt && r.lastRunAt >= cutoff);
+  }
+}
+export {
+  AnalyticsDataStream,
+  AnalyticsDataStreamCollection,
+  AnalyticsEvent,
+  AnalyticsEventCollection,
+  AnalyticsProperty,
+  AnalyticsPropertyCollection,
+  AnalyticsPropertyStatus,
+  AnalyticsProvider,
+  AnalyticsReport,
+  AnalyticsReportCollection,
+  CountingMethod,
+  CustomDimensionScope,
+  DataStreamStatus,
+  DataStreamType,
+  ReportFrequency,
+  ReportStatus,
+  TrackingEventStatus,
+  promptMessageOptions,
+  smrtAnalyticsAnalyzePerformancePrompt,
+  smrtAnalyticsAnalyzeResultsPrompt,
+  smrtAnalyticsHasPositiveTrendsPrompt
+};
+//# sourceMappingURL=index.js.map