@blackcode_sa/metaestetics-api 1.12.68 → 1.13.0

package/dist/admin/index.mjs

@@ -427,6 +427,7 @@ var NotificationType = /* @__PURE__ */ ((NotificationType2) => {
   NotificationType2["FORM_REMINDER"] = "formReminder";
   NotificationType2["FORM_SUBMISSION_CONFIRMATION"] = "formSubmissionConfirmation";
   NotificationType2["REVIEW_REQUEST"] = "reviewRequest";
+  NotificationType2["PROCEDURE_RECOMMENDATION"] = "procedureRecommendation";
   NotificationType2["PAYMENT_DUE"] = "paymentDue";
   NotificationType2["PAYMENT_CONFIRMATION"] = "paymentConfirmation";
   NotificationType2["PAYMENT_FAILED"] = "paymentFailed";
@@ -480,6 +481,14 @@ var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
   AppointmentStatus2["RESCHEDULED_BY_CLINIC"] = "rescheduled_by_clinic";
   return AppointmentStatus2;
 })(AppointmentStatus || {});
+var PaymentStatus = /* @__PURE__ */ ((PaymentStatus2) => {
+  PaymentStatus2["UNPAID"] = "unpaid";
+  PaymentStatus2["PAID"] = "paid";
+  PaymentStatus2["PARTIALLY_PAID"] = "partially_paid";
+  PaymentStatus2["REFUNDED"] = "refunded";
+  PaymentStatus2["NOT_APPLICABLE"] = "not_applicable";
+  return PaymentStatus2;
+})(PaymentStatus || {});
 var APPOINTMENTS_COLLECTION = "appointments";
 
 // src/types/patient/patient-requirements.ts
@@ -524,6 +533,17 @@ var DOCTOR_FORMS_SUBCOLLECTION = "doctor-forms";
 // src/types/reviews/index.ts
 var REVIEWS_COLLECTION = "reviews";
 
+// src/types/analytics/stored-analytics.types.ts
+var ANALYTICS_COLLECTION = "analytics";
+var PRACTITIONER_ANALYTICS_SUBCOLLECTION = "practitioners";
+var PROCEDURE_ANALYTICS_SUBCOLLECTION = "procedures";
+var CLINIC_ANALYTICS_SUBCOLLECTION = "clinic";
+var DASHBOARD_ANALYTICS_SUBCOLLECTION = "dashboard";
+var TIME_EFFICIENCY_ANALYTICS_SUBCOLLECTION = "time_efficiency";
+var CANCELLATION_ANALYTICS_SUBCOLLECTION = "cancellations";
+var NO_SHOW_ANALYTICS_SUBCOLLECTION = "no_shows";
+var REVENUE_ANALYTICS_SUBCOLLECTION = "revenue";
+
 // src/admin/notifications/notifications.admin.ts
 import * as admin2 from "firebase-admin";
 import { Expo } from "expo-server-sdk";
@@ -588,16 +608,16 @@ var Logger = class {
 
 // src/admin/notifications/notifications.admin.ts
 var NotificationsAdmin = class {
-  constructor(firestore18) {
+  constructor(firestore19) {
     this.expo = new Expo();
-    this.db = firestore18 || admin2.firestore();
+    this.db = firestore19 || admin2.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
    */
   async getNotification(id) {
-    const doc = await this.db.collection("notifications").doc(id).get();
-    return doc.exists ? { id: doc.id, ...doc.data() } : null;
+    const doc2 = await this.db.collection("notifications").doc(id).get();
+    return doc2.exists ? { id: doc2.id, ...doc2.data() } : null;
   }
   /**
    * Kreira novu notifikaciju
@@ -784,10 +804,10 @@ var NotificationsAdmin = class {
       return;
     }
     const results = await Promise.allSettled(
-      pendingNotifications.docs.map(async (doc) => {
+      pendingNotifications.docs.map(async (doc2) => {
         const notification = {
-          id: doc.id,
-          ...doc.data()
+          id: doc2.id,
+          ...doc2.data()
         };
         Logger.info(
           `[NotificationsAdmin] Processing notification ${notification.id} of type ${notification.notificationType}`
@@ -828,8 +848,8 @@ var NotificationsAdmin = class {
         break;
       }
       const batch = this.db.batch();
-      oldNotifications.docs.forEach((doc) => {
-        batch.delete(doc.ref);
+      oldNotifications.docs.forEach((doc2) => {
+        batch.delete(doc2.ref);
       });
       await batch.commit();
       totalDeleted += oldNotifications.size;
@@ -1099,8 +1119,8 @@ var NotificationsAdmin = class {
 
 // src/admin/requirements/patient-requirements.admin.service.ts
 var PatientRequirementsAdminService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin3.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin3.firestore();
     this.notificationsAdmin = new NotificationsAdmin(this.db);
   }
   /**
@@ -1428,8 +1448,8 @@ var PatientRequirementsAdminService = class {
 // src/admin/calendar/calendar.admin.service.ts
 import * as admin4 from "firebase-admin";
 var CalendarAdminService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin4.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin4.firestore();
     Logger.info("[CalendarAdminService] Initialized.");
   }
   /**
@@ -1715,9 +1735,9 @@ var BaseMailingService = class {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore18, mailgunClient) {
+  constructor(firestore19, mailgunClient) {
     var _a;
-    this.db = firestore18;
+    this.db = firestore19;
     this.mailgunClient = mailgunClient;
     if (!this.db) {
       Logger.error("[BaseMailingService] No Firestore instance provided");
@@ -2259,8 +2279,8 @@ var clinicAppointmentRequestedTemplate = `
 </html>
 `;
 var AppointmentMailingService = class extends BaseMailingService {
-  constructor(firestore18, mailgunClient) {
-    super(firestore18, mailgunClient);
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
     Logger.info("[AppointmentMailingService] Initialized.");
   }
@@ -2489,8 +2509,8 @@ var AppointmentAggregationService = class {
    * @param mailgunClient - An initialized Mailgun client instance.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(mailgunClient, firestore18) {
-    this.db = firestore18 || admin6.firestore();
+  constructor(mailgunClient, firestore19) {
+    this.db = firestore19 || admin6.firestore();
     this.appointmentMailingService = new AppointmentMailingService(
       this.db,
       mailgunClient
@@ -2866,6 +2886,11 @@ var AppointmentAggregationService = class {
         Logger.info(`[AggService] Zone photos changed for appointment ${after.id}`);
         await this.handleZonePhotosUpdate(before, after);
       }
+      const recommendationsChanged = this.hasRecommendationsChanged(before, after);
+      if (recommendationsChanged) {
+        Logger.info(`[AggService] Recommended procedures changed for appointment ${after.id}`);
+        await this.handleRecommendedProceduresUpdate(before, after, patientProfile);
+      }
       Logger.info(`[AggService] Successfully processed UPDATE for appointment: ${after.id}`);
     } catch (error) {
       Logger.error(
@@ -3512,10 +3537,10 @@ var AppointmentAggregationService = class {
       }
       const batch = this.db.batch();
       let instancesUpdatedCount = 0;
-      instancesSnapshot.docs.forEach((doc) => {
-        const instance = doc.data();
+      instancesSnapshot.docs.forEach((doc2) => {
+        const instance = doc2.data();
         if (instance.overallStatus !== newOverallStatus && instance.overallStatus !== "failedToProcess" /* FAILED_TO_PROCESS */) {
-          batch.update(doc.ref, {
+          batch.update(doc2.ref, {
             overallStatus: newOverallStatus,
             updatedAt: admin6.firestore.FieldValue.serverTimestamp()
             // Cast for now
@@ -3524,7 +3549,7 @@ var AppointmentAggregationService = class {
           });
           instancesUpdatedCount++;
           Logger.debug(
-            `[AggService] Added update for PatientRequirementInstance ${doc.id} to batch. New status: ${newOverallStatus}`
+            `[AggService] Added update for PatientRequirementInstance ${doc2.id} to batch. New status: ${newOverallStatus}`
           );
         }
       });
@@ -3699,8 +3724,8 @@ var AppointmentAggregationService = class {
   // --- Data Fetching Helpers (Consider moving to a data access layer or using existing services if available) ---
   async fetchPatientProfile(patientId) {
     try {
-      const doc = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).get();
-      return doc.exists ? doc.data() : null;
+      const doc2 = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).get();
+      return doc2.exists ? doc2.data() : null;
     } catch (error) {
       Logger.error(`[AggService] Error fetching patient profile ${patientId}:`, error);
       return null;
@@ -3713,12 +3738,12 @@ var AppointmentAggregationService = class {
    */
   async fetchPatientSensitiveInfo(patientId) {
     try {
-      const doc = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(patientId).get();
-      if (!doc.exists) {
+      const doc2 = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(patientId).get();
+      if (!doc2.exists) {
         Logger.warn(`[AggService] No sensitive info found for patient ${patientId}`);
         return null;
       }
-      return doc.data();
+      return doc2.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching patient sensitive info ${patientId}:`, error);
       return null;
@@ -3735,12 +3760,12 @@ var AppointmentAggregationService = class {
       return null;
     }
     try {
-      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      if (!doc.exists) {
+      const doc2 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+      if (!doc2.exists) {
         Logger.warn(`[AggService] No practitioner profile found for ID ${practitionerId}`);
         return null;
       }
-      return doc.data();
+      return doc2.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching practitioner profile ${practitionerId}:`, error);
       return null;
@@ -3757,12 +3782,12 @@ var AppointmentAggregationService = class {
       return null;
     }
     try {
-      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      if (!doc.exists) {
+      const doc2 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+      if (!doc2.exists) {
         Logger.warn(`[AggService] No clinic info found for ID ${clinicId}`);
         return null;
       }
-      return doc.data();
+      return doc2.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching clinic info ${clinicId}:`, error);
       return null;
@@ -3898,6 +3923,104 @@ var AppointmentAggregationService = class {
       );
     }
   }
+  /**
+   * Checks if recommended procedures have changed between two appointment states
+   * @param before - The appointment state before update
+   * @param after - The appointment state after update
+   * @returns True if recommendations have changed, false otherwise
+   */
+  hasRecommendationsChanged(before, after) {
+    var _a, _b;
+    const beforeRecommendations = ((_a = before.metadata) == null ? void 0 : _a.recommendedProcedures) || [];
+    const afterRecommendations = ((_b = after.metadata) == null ? void 0 : _b.recommendedProcedures) || [];
+    if (beforeRecommendations.length !== afterRecommendations.length) {
+      return true;
+    }
+    for (let i = 0; i < afterRecommendations.length; i++) {
+      const beforeRec = beforeRecommendations[i];
+      const afterRec = afterRecommendations[i];
+      if (!beforeRec || !afterRec) {
+        return true;
+      }
+      if (beforeRec.procedure.procedureId !== afterRec.procedure.procedureId || beforeRec.note !== afterRec.note || beforeRec.timeframe.value !== afterRec.timeframe.value || beforeRec.timeframe.unit !== afterRec.timeframe.unit) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Handles recommended procedures update - creates notifications for newly added recommendations
+   * @param before - The appointment state before update
+   * @param after - The appointment state after update
+   * @param patientProfile - The patient profile (for expo tokens)
+   */
+  async handleRecommendedProceduresUpdate(before, after, patientProfile) {
+    var _a, _b, _c, _d, _e;
+    try {
+      const beforeRecommendations = ((_a = before.metadata) == null ? void 0 : _a.recommendedProcedures) || [];
+      const afterRecommendations = ((_b = after.metadata) == null ? void 0 : _b.recommendedProcedures) || [];
+      const newRecommendations = afterRecommendations.slice(beforeRecommendations.length);
+      if (newRecommendations.length === 0) {
+        Logger.info(
+          `[AggService] No new recommendations detected for appointment ${after.id}`
+        );
+        return;
+      }
+      Logger.info(
+        `[AggService] Found ${newRecommendations.length} new recommendation(s) for appointment ${after.id}`
+      );
+      for (let i = 0; i < newRecommendations.length; i++) {
+        const recommendation = newRecommendations[i];
+        const recommendationIndex = beforeRecommendations.length + i;
+        const recommendationId = `${after.id}:${recommendationIndex}`;
+        const timeframeText = `${recommendation.timeframe.value} ${recommendation.timeframe.unit}${recommendation.timeframe.value > 1 ? "s" : ""}`;
+        const notificationPayload = {
+          userId: after.patientId,
+          userRole: "patient" /* PATIENT */,
+          notificationType: "procedureRecommendation" /* PROCEDURE_RECOMMENDATION */,
+          notificationTime: admin6.firestore.Timestamp.now(),
+          notificationTokens: (patientProfile == null ? void 0 : patientProfile.expoTokens) || [],
+          title: "New Procedure Recommendation",
+          body: `${((_c = after.practitionerInfo) == null ? void 0 : _c.name) || "Your doctor"} recommended "${recommendation.procedure.procedureName}" for you. Suggested timeframe: in ${timeframeText}`,
+          appointmentId: after.id,
+          recommendationId,
+          procedureId: recommendation.procedure.procedureId,
+          procedureName: recommendation.procedure.procedureName,
+          practitionerName: ((_d = after.practitionerInfo) == null ? void 0 : _d.name) || "Unknown Practitioner",
+          clinicName: ((_e = after.clinicInfo) == null ? void 0 : _e.name) || "Unknown Clinic",
+          note: recommendation.note,
+          timeframe: recommendation.timeframe
+        };
+        try {
+          const notificationId = await this.notificationsAdmin.createNotification(
+            notificationPayload
+          );
+          Logger.info(
+            `[AggService] Created notification ${notificationId} for recommendation ${recommendationId}`
+          );
+          if ((patientProfile == null ? void 0 : patientProfile.expoTokens) && patientProfile.expoTokens.length > 0) {
+            const notification = await this.notificationsAdmin.getNotification(notificationId);
+            if (notification) {
+              await this.notificationsAdmin.sendPushNotification(notification);
+              Logger.info(
+                `[AggService] Sent push notification for recommendation ${recommendationId}`
+              );
+            }
+          }
+        } catch (error) {
+          Logger.error(
+            `[AggService] Error creating notification for recommendation ${recommendationId}:`,
+            error
+          );
+        }
+      }
+    } catch (error) {
+      Logger.error(
+        `[AggService] Error handling recommended procedures update for appointment ${after.id}:`,
+        error
+      );
+    }
+  }
 };
 
 // src/admin/aggregation/clinic/clinic.aggregation.service.ts
@@ -3908,8 +4031,8 @@ var ClinicAggregationService = class {
    * Constructor for ClinicAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin7.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin7.firestore();
   }
   /**
    * Adds clinic information to a clinic group when a new clinic is created
@@ -4131,11 +4254,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[ClinicAggregationService] Updating location for calendar event ${doc.ref.path}`
+          `[ClinicAggregationService] Updating location for calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           eventLocation: newLocation,
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
         });
@@ -4178,11 +4301,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[ClinicAggregationService] Updating clinic info for calendar event ${doc.ref.path}`
+          `[ClinicAggregationService] Updating clinic info for calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           clinicInfo,
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
         });
@@ -4393,11 +4516,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[ClinicAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[ClinicAggregationService] Canceling calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           status: "CANCELED",
           cancelReason: "Clinic deleted",
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
@@ -4424,8 +4547,8 @@ var FilledFormsAggregationService = class {
    * Constructor for FilledFormsAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin8.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin8.firestore();
     Logger.info("[FilledFormsAggregationService] Initialized");
   }
   /**
@@ -4632,8 +4755,8 @@ var FilledFormsAggregationService = class {
 import * as admin9 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID2 = "calendar";
 var PatientAggregationService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin9.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin9.firestore();
   }
   // --- Methods for Patient Creation --- >
   // No specific aggregations defined for patient creation in the plan.
@@ -4665,11 +4788,11 @@ var PatientAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[PatientAggregationService] Updating patient info for calendar event ${doc.ref.path}`
+          `[PatientAggregationService] Updating patient info for calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           patientInfo,
           updatedAt: admin9.firestore.FieldValue.serverTimestamp()
         });
@@ -4713,11 +4836,11 @@ var PatientAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[PatientAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[PatientAggregationService] Canceling calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           status: "CANCELED",
           cancelReason: "Patient deleted",
           updatedAt: admin9.firestore.FieldValue.serverTimestamp()
@@ -4741,8 +4864,8 @@ var PatientAggregationService = class {
 import * as admin10 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID3 = "calendar";
 var PractitionerAggregationService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin10.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin10.firestore();
   }
   /**
    * Adds practitioner information to a clinic when a new practitioner is created
@@ -4888,11 +5011,11 @@ var PractitionerAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc.ref.path}`
+          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           practitionerInfo,
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
         });
@@ -4976,11 +5099,11 @@ var PractitionerAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[PractitionerAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[PractitionerAggregationService] Canceling calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           status: "CANCELED",
           cancelReason: "Practitioner deleted",
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
@@ -5081,8 +5204,8 @@ var PractitionerInviteAggregationService = class {
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    * @param mailingService Optional mailing service for sending emails
    */
-  constructor(firestore18, mailingService) {
-    this.db = firestore18 || admin11.firestore();
+  constructor(firestore19, mailingService) {
+    this.db = firestore19 || admin11.firestore();
     this.mailingService = mailingService;
     Logger.info("[PractitionerInviteAggregationService] Initialized.");
   }
@@ -5532,8 +5655,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchClinicAdminById(adminId) {
     try {
-      const doc = await this.db.collection(CLINIC_ADMINS_COLLECTION).doc(adminId).get();
-      return doc.exists ? doc.data() : null;
+      const doc2 = await this.db.collection(CLINIC_ADMINS_COLLECTION).doc(adminId).get();
+      return doc2.exists ? doc2.data() : null;
     } catch (error) {
       Logger.error(
         `[PractitionerInviteAggService] Error fetching clinic admin ${adminId}:`,
@@ -5549,8 +5672,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchPractitionerById(practitionerId) {
     try {
-      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      return doc.exists ? doc.data() : null;
+      const doc2 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+      return doc2.exists ? doc2.data() : null;
     } catch (error) {
       Logger.error(
         `[PractitionerInviteAggService] Error fetching practitioner ${practitionerId}:`,
@@ -5566,8 +5689,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchClinicById(clinicId) {
     try {
-      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      return doc.exists ? doc.data() : null;
+      const doc2 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+      return doc2.exists ? doc2.data() : null;
     } catch (error) {
       Logger.error(
         `[PractitionerInviteAggService] Error fetching clinic ${clinicId}:`,
@@ -5588,8 +5711,8 @@ var PractitionerInviteAggregationService = class {
     var _a, _b, _c, _d, _e, _f;
     if (!this.mailingService) return;
     try {
-      const admin18 = await this.fetchClinicAdminById(invite.invitedBy);
-      if (!admin18) {
+      const admin19 = await this.fetchClinicAdminById(invite.invitedBy);
+      if (!admin19) {
         Logger.warn(
           `[PractitionerInviteAggService] Admin ${invite.invitedBy} not found, using clinic contact email as fallback`
         );
@@ -5627,7 +5750,7 @@ var PractitionerInviteAggregationService = class {
         );
         return;
       }
-      const adminName = `${admin18.contactInfo.firstName} ${admin18.contactInfo.lastName}`;
+      const adminName = `${admin19.contactInfo.firstName} ${admin19.contactInfo.lastName}`;
       const notificationData = {
         invite,
         practitioner: {
@@ -5643,7 +5766,7 @@ var PractitionerInviteAggregationService = class {
         clinic: {
           name: clinic.name,
           adminName,
-          adminEmail: admin18.contactInfo.email
+          adminEmail: admin19.contactInfo.email
           // Use the specific admin's email
         },
         context: {
@@ -5679,8 +5802,8 @@ var PractitionerInviteAggregationService = class {
     var _a, _b, _c, _d, _e, _f;
     if (!this.mailingService) return;
     try {
-      const admin18 = await this.fetchClinicAdminById(invite.invitedBy);
-      if (!admin18) {
+      const admin19 = await this.fetchClinicAdminById(invite.invitedBy);
+      if (!admin19) {
         Logger.warn(
           `[PractitionerInviteAggService] Admin ${invite.invitedBy} not found, using clinic contact email as fallback`
         );
@@ -5718,7 +5841,7 @@ var PractitionerInviteAggregationService = class {
         );
         return;
       }
-      const adminName = `${admin18.contactInfo.firstName} ${admin18.contactInfo.lastName}`;
+      const adminName = `${admin19.contactInfo.firstName} ${admin19.contactInfo.lastName}`;
       const notificationData = {
         invite,
         practitioner: {
@@ -5732,7 +5855,7 @@ var PractitionerInviteAggregationService = class {
         clinic: {
           name: clinic.name,
           adminName,
-          adminEmail: admin18.contactInfo.email
+          adminEmail: admin19.contactInfo.email
           // Use the specific admin's email
         },
         context: {
@@ -5764,8 +5887,8 @@ var PractitionerInviteAggregationService = class {
 import * as admin12 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID4 = "calendar";
 var ProcedureAggregationService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin12.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin12.firestore();
   }
   /**
    * Adds procedure information to a practitioner when a new procedure is created
@@ -6002,11 +6125,11 @@ var ProcedureAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc.ref.path}`
+          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           procedureInfo,
           updatedAt: admin12.firestore.FieldValue.serverTimestamp()
         });
@@ -6049,11 +6172,11 @@ var ProcedureAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc2) => {
         console.log(
-          `[ProcedureAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[ProcedureAggregationService] Canceling calendar event ${doc2.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc2.ref, {
           status: "CANCELED",
           cancelReason: "Procedure deleted or inactivated",
           updatedAt: admin12.firestore.FieldValue.serverTimestamp()
@@ -6283,8 +6406,8 @@ var ReviewsAggregationService = class {
    * Constructor for ReviewsAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin13.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin13.firestore();
   }
   /**
    * Process a newly created review and update all related entities
@@ -6434,7 +6557,7 @@ var ReviewsAggregationService = class {
       );
       return updatedReviewInfo2;
     }
-    const reviews = reviewsQuery.docs.map((doc) => doc.data());
+    const reviews = reviewsQuery.docs.map((doc2) => doc2.data());
     const clinicReviews = reviews.map((review) => review.clinicReview).filter((review) => review !== void 0);
     let totalRating = 0;
     let totalCleanliness = 0;
@@ -6524,7 +6647,7 @@ var ReviewsAggregationService = class {
       );
       return updatedReviewInfo2;
     }
-    const reviews = reviewsQuery.docs.map((doc) => doc.data());
+    const reviews = reviewsQuery.docs.map((doc2) => doc2.data());
     const practitionerReviews = reviews.map((review) => review.practitionerReview).filter((review) => review !== void 0);
     let totalRating = 0;
     let totalKnowledgeAndExpertise = 0;
@@ -6597,7 +6720,7 @@ var ReviewsAggregationService = class {
       recommendationPercentage: 0
     };
     const allReviewsQuery = await this.db.collection(REVIEWS_COLLECTION).get();
-    const reviews = allReviewsQuery.docs.map((doc) => doc.data());
+    const reviews = allReviewsQuery.docs.map((doc2) => doc2.data());
     const procedureReviews = [];
     reviews.forEach((review) => {
       if (review.procedureReview && review.procedureReview.procedureId === procedureId) {
@@ -6763,8 +6886,2042 @@ var ReviewsAggregationService = class {
   }
 };
 
+// src/admin/analytics/analytics.admin.service.ts
+import * as admin14 from "firebase-admin";
+
+// src/services/analytics/analytics.service.ts
+import { where, Timestamp as Timestamp2 } from "firebase/firestore";
+
+// src/services/base.service.ts
+import { getStorage } from "firebase/storage";
+var BaseService = class {
+  constructor(db, auth, app, storage) {
+    this.db = db;
+    this.auth = auth;
+    this.app = app;
+    if (app) {
+      this.storage = storage || getStorage(app);
+    }
+  }
+  /**
+   * Generiše jedinstveni ID za dokumente
+   * Format: xxxxxxxxxxxx-timestamp
+   * Gde je x random karakter (broj ili slovo)
+   */
+  generateId() {
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const timestamp = Date.now().toString(36);
+    const randomPart = Array.from(
+      { length: 12 },
+      () => chars.charAt(Math.floor(Math.random() * chars.length))
+    ).join("");
+    return `${randomPart}-${timestamp}`;
+  }
+};
+
+// src/services/analytics/utils/cost-calculation.utils.ts
+function calculateAppointmentCost(appointment) {
+  const metadata = appointment.metadata;
+  const currency = appointment.currency || "CHF";
+  if (metadata == null ? void 0 : metadata.finalbilling) {
+    const finalbilling = metadata.finalbilling;
+    return {
+      cost: finalbilling.finalPrice,
+      currency: finalbilling.currency || currency,
+      source: "finalbilling",
+      subtotal: finalbilling.subtotalAll,
+      tax: finalbilling.taxPrice
+    };
+  }
+  if (metadata == null ? void 0 : metadata.zonesData) {
+    const zonesData = metadata.zonesData;
+    let subtotal = 0;
+    let foundCurrency = currency;
+    Object.values(zonesData).forEach((items) => {
+      items.forEach((item) => {
+        if (item.type === "item" && item.subtotal) {
+          subtotal += item.subtotal;
+          if (item.currency && !foundCurrency) {
+            foundCurrency = item.currency;
+          }
+        }
+      });
+    });
+    if (subtotal > 0) {
+      return {
+        cost: subtotal,
+        // Note: This doesn't include tax, but zonesData might not have tax info
+        currency: foundCurrency,
+        source: "zonesData",
+        subtotal
+      };
+    }
+  }
+  return {
+    cost: appointment.cost || 0,
+    currency,
+    source: "baseCost"
+  };
+}
+function calculateTotalRevenue(appointments) {
+  if (appointments.length === 0) {
+    return { totalRevenue: 0, currency: "CHF" };
+  }
+  let totalRevenue = 0;
+  const currencies = /* @__PURE__ */ new Set();
+  appointments.forEach((appointment) => {
+    const costData = calculateAppointmentCost(appointment);
+    totalRevenue += costData.cost;
+    currencies.add(costData.currency);
+  });
+  const currency = currencies.size > 0 ? Array.from(currencies)[0] : "CHF";
+  return { totalRevenue, currency };
+}
+function extractProductUsage(appointment) {
+  const products = [];
+  const metadata = appointment.metadata;
+  if (!(metadata == null ? void 0 : metadata.zonesData)) {
+    return products;
+  }
+  const zonesData = metadata.zonesData;
+  const currency = appointment.currency || "CHF";
+  Object.values(zonesData).forEach((items) => {
+    items.forEach((item) => {
+      if (item.type === "item" && item.productId) {
+        const price = item.priceOverrideAmount || item.price || 0;
+        const quantity = item.quantity || 1;
+        const subtotal = item.subtotal || price * quantity;
+        products.push({
+          productId: item.productId,
+          productName: item.productName || "Unknown Product",
+          brandId: item.productBrandId || "",
+          brandName: item.productBrandName || "",
+          quantity,
+          price,
+          subtotal,
+          currency: item.currency || currency
+        });
+      }
+    });
+  });
+  return products;
+}
+
+// src/services/analytics/utils/time-calculation.utils.ts
+function calculateTimeEfficiency(appointment) {
+  const startTime = appointment.appointmentStartTime;
+  const endTime = appointment.appointmentEndTime;
+  if (!startTime || !endTime) {
+    return null;
+  }
+  const bookedDurationMs = endTime.toMillis() - startTime.toMillis();
+  const bookedDuration = Math.round(bookedDurationMs / (1e3 * 60));
+  const actualDuration = appointment.actualDurationMinutes || bookedDuration;
+  const efficiency = bookedDuration > 0 ? actualDuration / bookedDuration * 100 : 100;
+  const overrun = actualDuration > bookedDuration ? actualDuration - bookedDuration : 0;
+  const underutilization = bookedDuration > actualDuration ? bookedDuration - actualDuration : 0;
+  return {
+    bookedDuration,
+    actualDuration,
+    efficiency,
+    overrun,
+    underutilization
+  };
+}
+function calculateAverageTimeMetrics(appointments) {
+  if (appointments.length === 0) {
+    return {
+      averageBookedDuration: 0,
+      averageActualDuration: 0,
+      averageEfficiency: 0,
+      totalOverrun: 0,
+      totalUnderutilization: 0,
+      averageOverrun: 0,
+      averageUnderutilization: 0,
+      appointmentsWithActualTime: 0
+    };
+  }
+  let totalBookedDuration = 0;
+  let totalActualDuration = 0;
+  let totalOverrun = 0;
+  let totalUnderutilization = 0;
+  let appointmentsWithActualTime = 0;
+  appointments.forEach((appointment) => {
+    const timeData = calculateTimeEfficiency(appointment);
+    if (timeData) {
+      totalBookedDuration += timeData.bookedDuration;
+      totalActualDuration += timeData.actualDuration;
+      totalOverrun += timeData.overrun;
+      totalUnderutilization += timeData.underutilization;
+      if (appointment.actualDurationMinutes !== void 0) {
+        appointmentsWithActualTime++;
+      }
+    }
+  });
+  const count = appointments.length;
+  const averageBookedDuration = count > 0 ? totalBookedDuration / count : 0;
+  const averageActualDuration = count > 0 ? totalActualDuration / count : 0;
+  const averageEfficiency = averageBookedDuration > 0 ? averageActualDuration / averageBookedDuration * 100 : 0;
+  const averageOverrun = count > 0 ? totalOverrun / count : 0;
+  const averageUnderutilization = count > 0 ? totalUnderutilization / count : 0;
+  return {
+    averageBookedDuration: Math.round(averageBookedDuration),
+    averageActualDuration: Math.round(averageActualDuration),
+    averageEfficiency: Math.round(averageEfficiency * 100) / 100,
+    totalOverrun,
+    totalUnderutilization,
+    averageOverrun: Math.round(averageOverrun),
+    averageUnderutilization: Math.round(averageUnderutilization),
+    appointmentsWithActualTime
+  };
+}
+function calculateEfficiencyDistribution(appointments) {
+  const ranges = [
+    { label: "0-50%", min: 0, max: 50 },
+    { label: "50-75%", min: 50, max: 75 },
+    { label: "75-100%", min: 75, max: 100 },
+    { label: "100%+", min: 100, max: Infinity }
+  ];
+  const distribution = ranges.map((range) => ({
+    range: range.label,
+    count: 0,
+    percentage: 0
+  }));
+  let validCount = 0;
+  appointments.forEach((appointment) => {
+    const timeData = calculateTimeEfficiency(appointment);
+    if (timeData) {
+      validCount++;
+      const efficiency = timeData.efficiency;
+      for (let i = 0; i < ranges.length; i++) {
+        if (efficiency >= ranges[i].min && efficiency < ranges[i].max) {
+          distribution[i].count++;
+          break;
+        }
+      }
+    }
+  });
+  if (validCount > 0) {
+    distribution.forEach((item) => {
+      item.percentage = Math.round(item.count / validCount * 100 * 100) / 100;
+    });
+  }
+  return distribution;
+}
+function calculateCancellationLeadTime(appointment) {
+  if (!appointment.cancellationTime || !appointment.appointmentStartTime) {
+    return null;
+  }
+  const cancellationTime = appointment.cancellationTime.toMillis();
+  const appointmentTime = appointment.appointmentStartTime.toMillis();
+  const diffMs = appointmentTime - cancellationTime;
+  return Math.max(0, diffMs / (1e3 * 60 * 60));
+}
+
+// src/services/analytics/utils/appointment-filtering.utils.ts
+function filterAppointments(appointments, filters) {
+  if (!filters) {
+    return appointments;
+  }
+  return appointments.filter((appointment) => {
+    if (filters.clinicBranchId && appointment.clinicBranchId !== filters.clinicBranchId) {
+      return false;
+    }
+    if (filters.practitionerId && appointment.practitionerId !== filters.practitionerId) {
+      return false;
+    }
+    if (filters.procedureId && appointment.procedureId !== filters.procedureId) {
+      return false;
+    }
+    if (filters.patientId && appointment.patientId !== filters.patientId) {
+      return false;
+    }
+    return true;
+  });
+}
+function filterByStatus(appointments, statuses) {
+  return appointments.filter((appointment) => statuses.includes(appointment.status));
+}
+function getCompletedAppointments(appointments) {
+  return filterByStatus(appointments, ["completed" /* COMPLETED */]);
+}
+function getCanceledAppointments(appointments) {
+  return filterByStatus(appointments, [
+    "canceled_patient" /* CANCELED_PATIENT */,
+    "canceled_clinic" /* CANCELED_CLINIC */,
+    "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */
+  ]);
+}
+function getNoShowAppointments(appointments) {
+  return filterByStatus(appointments, ["no_show" /* NO_SHOW */]);
+}
+function calculatePercentage(part, total) {
+  if (total === 0) {
+    return 0;
+  }
+  return Math.round(part / total * 100 * 100) / 100;
+}
+
+// src/services/analytics/utils/stored-analytics.utils.ts
+import { Timestamp, doc, getDoc } from "firebase/firestore";
+function isAnalyticsDataFresh(computedAt, maxAgeHours) {
+  const now = Timestamp.now();
+  const ageMs = now.toMillis() - computedAt.toMillis();
+  const ageHours = ageMs / (1e3 * 60 * 60);
+  return ageHours <= maxAgeHours;
+}
+async function readStoredAnalytics(db, clinicBranchId, subcollection, documentId, period) {
+  try {
+    const docRef = doc(
+      db,
+      CLINICS_COLLECTION,
+      clinicBranchId,
+      ANALYTICS_COLLECTION,
+      subcollection,
+      period,
+      documentId
+    );
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) {
+      return null;
+    }
+    return docSnap.data();
+  } catch (error) {
+    console.error(`[StoredAnalytics] Error reading ${subcollection}/${period}/${documentId}:`, error);
+    return null;
+  }
+}
+async function readStoredPractitionerAnalytics(db, clinicBranchId, practitionerId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    PRACTITIONER_ANALYTICS_SUBCOLLECTION,
+    practitionerId,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredProcedureAnalytics(db, clinicBranchId, procedureId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    PROCEDURE_ANALYTICS_SUBCOLLECTION,
+    procedureId,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredDashboardAnalytics(db, clinicBranchId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    DASHBOARD_ANALYTICS_SUBCOLLECTION,
+    "current",
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredTimeEfficiencyMetrics(db, clinicBranchId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    TIME_EFFICIENCY_ANALYTICS_SUBCOLLECTION,
+    "current",
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredRevenueMetrics(db, clinicBranchId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    REVENUE_ANALYTICS_SUBCOLLECTION,
+    "current",
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredCancellationMetrics(db, clinicBranchId, entityType, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    CANCELLATION_ANALYTICS_SUBCOLLECTION,
+    entityType,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredNoShowMetrics(db, clinicBranchId, entityType, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    NO_SHOW_ANALYTICS_SUBCOLLECTION,
+    entityType,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+
+// src/services/analytics/utils/grouping.utils.ts
+function getTechnologyId(appointment) {
+  var _a;
+  return ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+}
+function getTechnologyName(appointment) {
+  var _a, _b;
+  return ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyName) || ((_b = appointment.procedureInfo) == null ? void 0 : _b.technologyName) || "Unknown";
+}
+function getEntityName(appointment, entityType) {
+  var _a, _b, _c, _d, _e, _f;
+  switch (entityType) {
+    case "clinic":
+      return ((_a = appointment.clinicInfo) == null ? void 0 : _a.name) || "Unknown";
+    case "practitioner":
+      return ((_b = appointment.practitionerInfo) == null ? void 0 : _b.name) || "Unknown";
+    case "patient":
+      return ((_c = appointment.patientInfo) == null ? void 0 : _c.fullName) || "Unknown";
+    case "procedure":
+      return ((_d = appointment.procedureInfo) == null ? void 0 : _d.name) || "Unknown";
+    case "technology":
+      return ((_e = appointment.procedureExtendedInfo) == null ? void 0 : _e.procedureTechnologyName) || ((_f = appointment.procedureInfo) == null ? void 0 : _f.technologyName) || "Unknown";
+  }
+}
+function getEntityId(appointment, entityType) {
+  var _a;
+  switch (entityType) {
+    case "clinic":
+      return appointment.clinicBranchId;
+    case "practitioner":
+      return appointment.practitionerId;
+    case "patient":
+      return appointment.patientId;
+    case "procedure":
+      return appointment.procedureId;
+    case "technology":
+      return ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+  }
+}
+function groupAppointmentsByEntity(appointments, entityType) {
+  const entityMap = /* @__PURE__ */ new Map();
+  appointments.forEach((appointment) => {
+    let entityId;
+    let entityName;
+    if (entityType === "technology") {
+      entityId = getTechnologyId(appointment);
+      entityName = getTechnologyName(appointment);
+    } else {
+      entityId = getEntityId(appointment, entityType);
+      entityName = getEntityName(appointment, entityType);
+    }
+    if (!entityMap.has(entityId)) {
+      entityMap.set(entityId, { name: entityName, appointments: [] });
+    }
+    entityMap.get(entityId).appointments.push(appointment);
+  });
+  return entityMap;
+}
+function calculateGroupedRevenueMetrics(appointments, entityType) {
+  const entityMap = groupAppointmentsByEntity(appointments, entityType);
+  const completed = getCompletedAppointments(appointments);
+  return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    const entityAppointments = data.appointments;
+    const entityCompleted = entityAppointments.filter(
+      (a) => completed.some((c) => c.id === a.id)
+    );
+    const { totalRevenue, currency } = calculateTotalRevenue(entityCompleted);
+    let totalTax = 0;
+    let totalSubtotal = 0;
+    let unpaidRevenue = 0;
+    let refundedRevenue = 0;
+    entityCompleted.forEach((appointment) => {
+      const costData = calculateAppointmentCost(appointment);
+      if (costData.source === "finalbilling") {
+        totalTax += costData.tax || 0;
+        totalSubtotal += costData.subtotal || 0;
+      } else {
+        totalSubtotal += costData.cost;
+      }
+      if (appointment.paymentStatus === "unpaid") {
+        unpaidRevenue += costData.cost;
+      } else if (appointment.paymentStatus === "refunded") {
+        refundedRevenue += costData.cost;
+      }
+    });
+    return {
+      entityId,
+      entityName: data.name,
+      entityType,
+      totalRevenue,
+      averageRevenuePerAppointment: entityCompleted.length > 0 ? totalRevenue / entityCompleted.length : 0,
+      totalAppointments: entityAppointments.length,
+      completedAppointments: entityCompleted.length,
+      currency,
+      unpaidRevenue,
+      refundedRevenue,
+      totalTax,
+      totalSubtotal
+    };
+  });
+}
+function calculateGroupedProductUsageMetrics(appointments, entityType) {
+  const entityMap = groupAppointmentsByEntity(appointments, entityType);
+  const completed = getCompletedAppointments(appointments);
+  return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    const entityAppointments = data.appointments;
+    const entityCompleted = entityAppointments.filter(
+      (a) => completed.some((c) => c.id === a.id)
+    );
+    const productMap = /* @__PURE__ */ new Map();
+    entityCompleted.forEach((appointment) => {
+      const products = extractProductUsage(appointment);
+      products.forEach((product) => {
+        if (productMap.has(product.productId)) {
+          const existing = productMap.get(product.productId);
+          existing.quantity += product.quantity;
+          existing.revenue += product.subtotal;
+          existing.usageCount++;
+        } else {
+          productMap.set(product.productId, {
+            name: product.productName,
+            brandName: product.brandName,
+            quantity: product.quantity,
+            revenue: product.subtotal,
+            usageCount: 1
+          });
+        }
+      });
+    });
+    const topProducts = Array.from(productMap.entries()).map(([productId, productData]) => ({
+      productId,
+      productName: productData.name,
+      brandName: productData.brandName,
+      totalQuantity: productData.quantity,
+      totalRevenue: productData.revenue,
+      usageCount: productData.usageCount
+    })).sort((a, b) => b.totalRevenue - a.totalRevenue).slice(0, 10);
+    const totalProductRevenue = topProducts.reduce((sum, p) => sum + p.totalRevenue, 0);
+    const totalProductQuantity = topProducts.reduce((sum, p) => sum + p.totalQuantity, 0);
+    return {
+      entityId,
+      entityName: data.name,
+      entityType,
+      totalProductsUsed: productMap.size,
+      uniqueProducts: productMap.size,
+      totalProductRevenue,
+      totalProductQuantity,
+      averageProductsPerAppointment: entityCompleted.length > 0 ? productMap.size / entityCompleted.length : 0,
+      topProducts
+    };
+  });
+}
+function calculateGroupedTimeEfficiencyMetrics(appointments, entityType) {
+  const entityMap = groupAppointmentsByEntity(appointments, entityType);
+  const completed = getCompletedAppointments(appointments);
+  return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    const entityAppointments = data.appointments;
+    const entityCompleted = entityAppointments.filter(
+      (a) => completed.some((c) => c.id === a.id)
+    );
+    const timeMetrics = calculateAverageTimeMetrics(entityCompleted);
+    return {
+      entityId,
+      entityName: data.name,
+      entityType,
+      totalAppointments: entityCompleted.length,
+      appointmentsWithActualTime: timeMetrics.appointmentsWithActualTime,
+      averageBookedDuration: timeMetrics.averageBookedDuration,
+      averageActualDuration: timeMetrics.averageActualDuration,
+      averageEfficiency: timeMetrics.averageEfficiency,
+      totalOverrun: timeMetrics.totalOverrun,
+      totalUnderutilization: timeMetrics.totalUnderutilization,
+      averageOverrun: timeMetrics.averageOverrun,
+      averageUnderutilization: timeMetrics.averageUnderutilization
+    };
+  });
+}
+function calculateGroupedPatientBehaviorMetrics(appointments, entityType) {
+  const entityMap = groupAppointmentsByEntity(appointments, entityType);
+  const canceled = getCanceledAppointments(appointments);
+  const noShow = getNoShowAppointments(appointments);
+  return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    const entityAppointments = data.appointments;
+    const patientMap = /* @__PURE__ */ new Map();
+    entityAppointments.forEach((appointment) => {
+      var _a;
+      const patientId = appointment.patientId;
+      const patientName = ((_a = appointment.patientInfo) == null ? void 0 : _a.fullName) || "Unknown";
+      if (!patientMap.has(patientId)) {
+        patientMap.set(patientId, {
+          name: patientName,
+          appointments: [],
+          noShows: [],
+          cancellations: []
+        });
+      }
+      const patientData = patientMap.get(patientId);
+      patientData.appointments.push(appointment);
+      if (noShow.some((ns) => ns.id === appointment.id)) {
+        patientData.noShows.push(appointment);
+      }
+      if (canceled.some((c) => c.id === appointment.id)) {
+        patientData.cancellations.push(appointment);
+      }
+    });
+    const patientMetrics = Array.from(patientMap.entries()).map(([patientId, patientData]) => ({
+      patientId,
+      patientName: patientData.name,
+      noShowCount: patientData.noShows.length,
+      cancellationCount: patientData.cancellations.length,
+      totalAppointments: patientData.appointments.length,
+      noShowRate: calculatePercentage(
+        patientData.noShows.length,
+        patientData.appointments.length
+      ),
+      cancellationRate: calculatePercentage(
+        patientData.cancellations.length,
+        patientData.appointments.length
+      )
+    }));
+    const patientsWithNoShows = patientMetrics.filter((p) => p.noShowCount > 0).length;
+    const patientsWithCancellations = patientMetrics.filter((p) => p.cancellationCount > 0).length;
+    const averageNoShowRate = patientMetrics.length > 0 ? patientMetrics.reduce((sum, p) => sum + p.noShowRate, 0) / patientMetrics.length : 0;
+    const averageCancellationRate = patientMetrics.length > 0 ? patientMetrics.reduce((sum, p) => sum + p.cancellationRate, 0) / patientMetrics.length : 0;
+    const topNoShowPatients = patientMetrics.filter((p) => p.noShowCount > 0).sort((a, b) => b.noShowRate - a.noShowRate).slice(0, 10).map((p) => ({
+      patientId: p.patientId,
+      patientName: p.patientName,
+      noShowCount: p.noShowCount,
+      totalAppointments: p.totalAppointments,
+      noShowRate: p.noShowRate
+    }));
+    const topCancellationPatients = patientMetrics.filter((p) => p.cancellationCount > 0).sort((a, b) => b.cancellationRate - a.cancellationRate).slice(0, 10).map((p) => ({
+      patientId: p.patientId,
+      patientName: p.patientName,
+      cancellationCount: p.cancellationCount,
+      totalAppointments: p.totalAppointments,
+      cancellationRate: p.cancellationRate
+    }));
+    const newPatients = patientMetrics.filter((p) => p.totalAppointments === 1).length;
+    const returningPatients = patientMetrics.filter((p) => p.totalAppointments > 1).length;
+    return {
+      entityId,
+      entityName: data.name,
+      entityType,
+      totalPatients: patientMap.size,
+      patientsWithNoShows,
+      patientsWithCancellations,
+      averageNoShowRate: Math.round(averageNoShowRate * 100) / 100,
+      averageCancellationRate: Math.round(averageCancellationRate * 100) / 100,
+      topNoShowPatients,
+      topCancellationPatients
+    };
+  });
+}
+
+// src/services/analytics/analytics.service.ts
+var AnalyticsService = class extends BaseService {
+  /**
+   * Creates a new AnalyticsService instance.
+   *
+   * @param db Firestore instance
+   * @param auth Firebase Auth instance
+   * @param app Firebase App instance
+   * @param appointmentService Appointment service instance for querying appointments
+   */
+  constructor(db, auth, app, appointmentService) {
+    super(db, auth, app);
+    this.appointmentService = appointmentService;
+  }
+  /**
+   * Fetches appointments with optional filters
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range
+   * @returns Array of appointments
+   */
+  async fetchAppointments(filters, dateRange) {
+    try {
+      const constraints = [];
+      if (filters == null ? void 0 : filters.clinicBranchId) {
+        constraints.push(where("clinicBranchId", "==", filters.clinicBranchId));
+      }
+      if (filters == null ? void 0 : filters.practitionerId) {
+        constraints.push(where("practitionerId", "==", filters.practitionerId));
+      }
+      if (filters == null ? void 0 : filters.procedureId) {
+        constraints.push(where("procedureId", "==", filters.procedureId));
+      }
+      if (filters == null ? void 0 : filters.patientId) {
+        constraints.push(where("patientId", "==", filters.patientId));
+      }
+      if (dateRange) {
+        constraints.push(where("appointmentStartTime", ">=", Timestamp2.fromDate(dateRange.start)));
+        constraints.push(where("appointmentStartTime", "<=", Timestamp2.fromDate(dateRange.end)));
+      }
+      const searchParams = {};
+      if (filters == null ? void 0 : filters.clinicBranchId) searchParams.clinicBranchId = filters.clinicBranchId;
+      if (filters == null ? void 0 : filters.practitionerId) searchParams.practitionerId = filters.practitionerId;
+      if (filters == null ? void 0 : filters.procedureId) searchParams.procedureId = filters.procedureId;
+      if (filters == null ? void 0 : filters.patientId) searchParams.patientId = filters.patientId;
+      if (dateRange) {
+        searchParams.startDate = dateRange.start;
+        searchParams.endDate = dateRange.end;
+      }
+      const result = await this.appointmentService.searchAppointments(searchParams);
+      return result.appointments;
+    } catch (error) {
+      console.error("[AnalyticsService] Error fetching appointments:", error);
+      throw error;
+    }
+  }
+  // ==========================================
+  // Practitioner Analytics
+  // ==========================================
+  /**
+   * Get practitioner performance metrics
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param practitionerId - ID of the practitioner
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Practitioner analytics object
+   */
+  async getPractitionerAnalytics(practitionerId, dateRange, options) {
+    var _a;
+    if (dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const clinicBranchId = options == null ? void 0 : options.clinicBranchId;
+      if (clinicBranchId) {
+        const stored = await readStoredPractitionerAnalytics(
+          this.db,
+          clinicBranchId,
+          practitionerId,
+          { ...options, period }
+        );
+        if (stored) {
+          const { metadata, ...analytics } = stored;
+          return analytics;
+        }
+      }
+    }
+    const appointments = await this.fetchAppointments({ practitionerId }, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const pending = filterAppointments(appointments, { practitionerId }).filter(
+      (a) => a.status === "pending" /* PENDING */
+    );
+    const confirmed = filterAppointments(appointments, { practitionerId }).filter(
+      (a) => a.status === "confirmed" /* CONFIRMED */
+    );
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const timeMetrics = calculateAverageTimeMetrics(completed);
+    const uniquePatients = new Set(appointments.map((a) => a.patientId));
+    const returningPatients = new Set(
+      appointments.filter((a) => {
+        const patientAppointments = appointments.filter((ap) => ap.patientId === a.patientId);
+        return patientAppointments.length > 1;
+      }).map((a) => a.patientId)
+    );
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      var _a2;
+      const procId = appointment.procedureId;
+      const procName = ((_a2 = appointment.procedureInfo) == null ? void 0 : _a2.name) || "Unknown";
+      const cost = calculateAppointmentCost(appointment).cost;
+      if (procedureMap.has(procId)) {
+        const existing = procedureMap.get(procId);
+        existing.count++;
+        existing.revenue += cost;
+      } else {
+        procedureMap.set(procId, { name: procName, count: 1, revenue: cost });
+      }
+    });
+    const topProcedures = Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      count: data.count,
+      revenue: data.revenue
+    })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const practitionerName = appointments.length > 0 ? ((_a = appointments[0].practitionerInfo) == null ? void 0 : _a.name) || "Unknown" : "Unknown";
+    return {
+      total: appointments.length,
+      dateRange,
+      practitionerId,
+      practitionerName,
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      canceledAppointments: canceled.length,
+      noShowAppointments: noShow.length,
+      pendingAppointments: pending.length,
+      confirmedAppointments: confirmed.length,
+      cancellationRate: calculatePercentage(canceled.length, appointments.length),
+      noShowRate: calculatePercentage(noShow.length, appointments.length),
+      averageBookedTime: timeMetrics.averageBookedDuration,
+      averageActualTime: timeMetrics.averageActualDuration,
+      timeEfficiency: timeMetrics.averageEfficiency,
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      currency,
+      topProcedures,
+      patientRetentionRate: calculatePercentage(returningPatients.size, uniquePatients.size),
+      uniquePatients: uniquePatients.size
+    };
+  }
+  // ==========================================
+  // Procedure Analytics
+  // ==========================================
+  /**
+   * Get procedure performance metrics
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param procedureId - ID of the procedure (optional, if not provided returns all)
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Procedure analytics object or array
+   */
+  async getProcedureAnalytics(procedureId, dateRange, options) {
+    if (procedureId && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const clinicBranchId = options == null ? void 0 : options.clinicBranchId;
+      if (clinicBranchId) {
+        const stored = await readStoredProcedureAnalytics(
+          this.db,
+          clinicBranchId,
+          procedureId,
+          { ...options, period }
+        );
+        if (stored) {
+          const { metadata, ...analytics } = stored;
+          return analytics;
+        }
+      }
+    }
+    const appointments = await this.fetchAppointments(procedureId ? { procedureId } : void 0, dateRange);
+    if (procedureId) {
+      return this.calculateProcedureAnalytics(appointments, procedureId);
+    }
+    const procedureMap = /* @__PURE__ */ new Map();
+    appointments.forEach((appointment) => {
+      const procId = appointment.procedureId;
+      if (!procedureMap.has(procId)) {
+        procedureMap.set(procId, []);
+      }
+      procedureMap.get(procId).push(appointment);
+    });
+    return Array.from(procedureMap.entries()).map(
+      ([procId, procAppointments]) => this.calculateProcedureAnalytics(procAppointments, procId)
+    );
+  }
+  /**
+   * Calculate analytics for a specific procedure
+   *
+   * @param appointments - Appointments for the procedure
+   * @param procedureId - Procedure ID
+   * @returns Procedure analytics
+   */
+  calculateProcedureAnalytics(appointments, procedureId) {
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const timeMetrics = calculateAverageTimeMetrics(completed);
+    const firstAppointment = appointments[0];
+    const procedureInfo = (firstAppointment == null ? void 0 : firstAppointment.procedureExtendedInfo) || (firstAppointment == null ? void 0 : firstAppointment.procedureInfo);
+    const productMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const products = extractProductUsage(appointment);
+      products.forEach((product) => {
+        if (productMap.has(product.productId)) {
+          const existing = productMap.get(product.productId);
+          existing.quantity += product.quantity;
+          existing.revenue += product.subtotal;
+          existing.usageCount++;
+        } else {
+          productMap.set(product.productId, {
+            name: product.productName,
+            brandName: product.brandName,
+            quantity: product.quantity,
+            revenue: product.subtotal,
+            usageCount: 1
+          });
+        }
+      });
+    });
+    const productUsage = Array.from(productMap.entries()).map(([productId, data]) => ({
+      productId,
+      productName: data.name,
+      brandName: data.brandName,
+      totalQuantity: data.quantity,
+      totalRevenue: data.revenue,
+      usageCount: data.usageCount
+    }));
+    return {
+      total: appointments.length,
+      procedureId,
+      procedureName: (procedureInfo == null ? void 0 : procedureInfo.name) || "Unknown",
+      procedureFamily: (procedureInfo == null ? void 0 : procedureInfo.procedureFamily) || "",
+      categoryName: (procedureInfo == null ? void 0 : procedureInfo.procedureCategoryName) || "",
+      subcategoryName: (procedureInfo == null ? void 0 : procedureInfo.procedureSubCategoryName) || "",
+      technologyName: (procedureInfo == null ? void 0 : procedureInfo.procedureTechnologyName) || "",
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      canceledAppointments: canceled.length,
+      noShowAppointments: noShow.length,
+      cancellationRate: calculatePercentage(canceled.length, appointments.length),
+      noShowRate: calculatePercentage(noShow.length, appointments.length),
+      averageCost: completed.length > 0 ? totalRevenue / completed.length : 0,
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      currency,
+      averageBookedDuration: timeMetrics.averageBookedDuration,
+      averageActualDuration: timeMetrics.averageActualDuration,
+      productUsage
+    };
+  }
+  /**
+   * Get procedure popularity metrics
+   *
+   * @param dateRange - Optional date range filter
+   * @param limit - Number of top procedures to return
+   * @returns Array of procedure popularity metrics
+   */
+  async getProcedurePopularity(dateRange, limit = 10) {
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const procId = appointment.procedureId;
+      const procInfo = appointment.procedureExtendedInfo || appointment.procedureInfo;
+      if (procedureMap.has(procId)) {
+        procedureMap.get(procId).count++;
+      } else {
+        procedureMap.set(procId, {
+          name: (procInfo == null ? void 0 : procInfo.name) || "Unknown",
+          category: (procInfo == null ? void 0 : procInfo.procedureCategoryName) || "",
+          subcategory: (procInfo == null ? void 0 : procInfo.procedureSubCategoryName) || "",
+          technology: (procInfo == null ? void 0 : procInfo.procedureTechnologyName) || "",
+          count: 1
+        });
+      }
+    });
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      categoryName: data.category,
+      subcategoryName: data.subcategory,
+      technologyName: data.technology,
+      appointmentCount: data.count,
+      completedCount: data.count,
+      rank: 0
+      // Will be set after sorting
+    })).sort((a, b) => b.appointmentCount - a.appointmentCount).slice(0, limit).map((item, index) => ({ ...item, rank: index + 1 }));
+  }
+  /**
+   * Get procedure profitability metrics
+   *
+   * @param dateRange - Optional date range filter
+   * @param limit - Number of top procedures to return
+   * @returns Array of procedure profitability metrics
+   */
+  async getProcedureProfitability(dateRange, limit = 10) {
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const procId = appointment.procedureId;
+      const procInfo = appointment.procedureExtendedInfo || appointment.procedureInfo;
+      const cost = calculateAppointmentCost(appointment).cost;
+      if (procedureMap.has(procId)) {
+        const existing = procedureMap.get(procId);
+        existing.revenue += cost;
+        existing.count++;
+      } else {
+        procedureMap.set(procId, {
+          name: (procInfo == null ? void 0 : procInfo.name) || "Unknown",
+          category: (procInfo == null ? void 0 : procInfo.procedureCategoryName) || "",
+          subcategory: (procInfo == null ? void 0 : procInfo.procedureSubCategoryName) || "",
+          technology: (procInfo == null ? void 0 : procInfo.procedureTechnologyName) || "",
+          revenue: cost,
+          count: 1
+        });
+      }
+    });
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      categoryName: data.category,
+      subcategoryName: data.subcategory,
+      technologyName: data.technology,
+      totalRevenue: data.revenue,
+      averageRevenue: data.count > 0 ? data.revenue / data.count : 0,
+      appointmentCount: data.count,
+      rank: 0
+      // Will be set after sorting
+    })).sort((a, b) => b.totalRevenue - a.totalRevenue).slice(0, limit).map((item, index) => ({ ...item, rank: index + 1 }));
+  }
+  // ==========================================
+  // Time Efficiency Analytics
+  // ==========================================
+  /**
+   * Get time efficiency metrics grouped by clinic, practitioner, procedure, patient, or technology
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'patient' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped time efficiency metrics
+   */
+  async getTimeEfficiencyMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedTimeEfficiencyMetrics(appointments, groupBy);
+  }
+  /**
+   * Get time efficiency metrics for appointments
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Time efficiency metrics
+   */
+  async getTimeEfficiencyMetrics(filters, dateRange, options) {
+    if ((filters == null ? void 0 : filters.clinicBranchId) && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredTimeEfficiencyMetrics(
+        this.db,
+        filters.clinicBranchId,
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const timeMetrics = calculateAverageTimeMetrics(completed);
+    const efficiencyDistribution = calculateEfficiencyDistribution(completed);
+    return {
+      totalAppointments: completed.length,
+      appointmentsWithActualTime: timeMetrics.appointmentsWithActualTime,
+      averageBookedDuration: timeMetrics.averageBookedDuration,
+      averageActualDuration: timeMetrics.averageActualDuration,
+      averageEfficiency: timeMetrics.averageEfficiency,
+      totalOverrun: timeMetrics.totalOverrun,
+      totalUnderutilization: timeMetrics.totalUnderutilization,
+      averageOverrun: timeMetrics.averageOverrun,
+      averageUnderutilization: timeMetrics.averageUnderutilization,
+      efficiencyDistribution
+    };
+  }
+  // ==========================================
+  // Cancellation & No-Show Analytics
+  // ==========================================
+  /**
+   * Get cancellation metrics
+   * First checks for stored analytics when grouping by clinic, then calculates if not available or stale
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'patient' | 'procedure' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics (requires clinicBranchId for cache)
+   * @returns Cancellation metrics grouped by specified entity
+   */
+  async getCancellationMetrics(groupBy, dateRange, options) {
+    if (groupBy === "clinic" && dateRange && (options == null ? void 0 : options.useCache) !== false && (options == null ? void 0 : options.clinicBranchId)) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredCancellationMetrics(
+        this.db,
+        options.clinicBranchId,
+        "clinic",
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const canceled = getCanceledAppointments(appointments);
+    if (groupBy === "clinic") {
+      return this.groupCancellationsByClinic(canceled, appointments);
+    } else if (groupBy === "practitioner") {
+      return this.groupCancellationsByPractitioner(canceled, appointments);
+    } else if (groupBy === "patient") {
+      return this.groupCancellationsByPatient(canceled, appointments);
+    } else if (groupBy === "technology") {
+      return this.groupCancellationsByTechnology(canceled, appointments);
+    } else {
+      return this.groupCancellationsByProcedure(canceled, appointments);
+    }
+  }
+  /**
+   * Group cancellations by clinic
+   */
+  groupCancellationsByClinic(canceled, allAppointments) {
+    const clinicMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const clinicId = appointment.clinicBranchId;
+      const clinicName = ((_a = appointment.clinicInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!clinicMap.has(clinicId)) {
+        clinicMap.set(clinicId, { name: clinicName, canceled: [], all: [] });
+      }
+      clinicMap.get(clinicId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const clinicId = appointment.clinicBranchId;
+      if (clinicMap.has(clinicId)) {
+        clinicMap.get(clinicId).canceled.push(appointment);
+      }
+    });
+    return Array.from(clinicMap.entries()).map(
+      ([clinicId, data]) => this.calculateCancellationMetrics(clinicId, data.name, "clinic", data.canceled, data.all)
+    );
+  }
+  /**
+   * Group cancellations by practitioner
+   */
+  groupCancellationsByPractitioner(canceled, allAppointments) {
+    const practitionerMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const practitionerId = appointment.practitionerId;
+      const practitionerName = ((_a = appointment.practitionerInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!practitionerMap.has(practitionerId)) {
+        practitionerMap.set(practitionerId, { name: practitionerName, canceled: [], all: [] });
+      }
+      practitionerMap.get(practitionerId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const practitionerId = appointment.practitionerId;
+      if (practitionerMap.has(practitionerId)) {
+        practitionerMap.get(practitionerId).canceled.push(appointment);
+      }
+    });
+    return Array.from(practitionerMap.entries()).map(
+      ([practitionerId, data]) => this.calculateCancellationMetrics(
+        practitionerId,
+        data.name,
+        "practitioner",
+        data.canceled,
+        data.all
+      )
+    );
+  }
+  /**
+   * Group cancellations by patient
+   */
+  groupCancellationsByPatient(canceled, allAppointments) {
+    const patientMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const patientId = appointment.patientId;
+      const patientName = ((_a = appointment.patientInfo) == null ? void 0 : _a.fullName) || "Unknown";
+      if (!patientMap.has(patientId)) {
+        patientMap.set(patientId, { name: patientName, canceled: [], all: [] });
+      }
+      patientMap.get(patientId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const patientId = appointment.patientId;
+      if (patientMap.has(patientId)) {
+        patientMap.get(patientId).canceled.push(appointment);
+      }
+    });
+    return Array.from(patientMap.entries()).map(
+      ([patientId, data]) => this.calculateCancellationMetrics(patientId, data.name, "patient", data.canceled, data.all)
+    );
+  }
+  /**
+   * Group cancellations by procedure
+   */
+  groupCancellationsByProcedure(canceled, allAppointments) {
+    const procedureMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const procedureId = appointment.procedureId;
+      const procedureName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!procedureMap.has(procedureId)) {
+        procedureMap.set(procedureId, { name: procedureName, canceled: [], all: [] });
+      }
+      procedureMap.get(procedureId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const procedureId = appointment.procedureId;
+      if (procedureMap.has(procedureId)) {
+        procedureMap.get(procedureId).canceled.push(appointment);
+      }
+    });
+    return Array.from(procedureMap.entries()).map(
+      ([procedureId, data]) => this.calculateCancellationMetrics(
+        procedureId,
+        data.name,
+        "procedure",
+        data.canceled,
+        data.all
+      )
+    );
+  }
+  /**
+   * Group cancellations by technology
+   * Aggregates all procedures using the same technology across all doctors
+   */
+  groupCancellationsByTechnology(canceled, allAppointments) {
+    const technologyMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a, _b, _c;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      const technologyName = ((_b = appointment.procedureExtendedInfo) == null ? void 0 : _b.procedureTechnologyName) || ((_c = appointment.procedureInfo) == null ? void 0 : _c.technologyName) || "Unknown";
+      if (!technologyMap.has(technologyId)) {
+        technologyMap.set(technologyId, { name: technologyName, canceled: [], all: [] });
+      }
+      technologyMap.get(technologyId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      var _a;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      if (technologyMap.has(technologyId)) {
+        technologyMap.get(technologyId).canceled.push(appointment);
+      }
+    });
+    return Array.from(technologyMap.entries()).map(
+      ([technologyId, data]) => this.calculateCancellationMetrics(
+        technologyId,
+        data.name,
+        "technology",
+        data.canceled,
+        data.all
+      )
+    );
+  }
+  /**
+   * Calculate cancellation metrics for a specific entity
+   */
+  calculateCancellationMetrics(entityId, entityName, entityType, canceled, all) {
+    const canceledByPatient = canceled.filter(
+      (a) => a.status === "canceled_patient" /* CANCELED_PATIENT */
+    ).length;
+    const canceledByClinic = canceled.filter(
+      (a) => a.status === "canceled_clinic" /* CANCELED_CLINIC */
+    ).length;
+    const canceledRescheduled = canceled.filter(
+      (a) => a.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */
+    ).length;
+    const leadTimes = canceled.map((a) => calculateCancellationLeadTime(a)).filter((lt) => lt !== null);
+    const averageLeadTime = leadTimes.length > 0 ? leadTimes.reduce((a, b) => a + b, 0) / leadTimes.length : 0;
+    const reasonMap = /* @__PURE__ */ new Map();
+    canceled.forEach((appointment) => {
+      const reason = appointment.cancellationReason || "No reason provided";
+      reasonMap.set(reason, (reasonMap.get(reason) || 0) + 1);
+    });
+    const cancellationReasons = Array.from(reasonMap.entries()).map(([reason, count]) => ({
+      reason,
+      count,
+      percentage: calculatePercentage(count, canceled.length)
+    }));
+    return {
+      entityId,
+      entityName,
+      entityType,
+      totalAppointments: all.length,
+      canceledAppointments: canceled.length,
+      cancellationRate: calculatePercentage(canceled.length, all.length),
+      canceledByPatient,
+      canceledByClinic,
+      canceledByPractitioner: 0,
+      // Not tracked in current status enum
+      canceledRescheduled,
+      averageCancellationLeadTime: Math.round(averageLeadTime * 100) / 100,
+      cancellationReasons
+    };
+  }
+  /**
+   * Get no-show metrics
+   * First checks for stored analytics when grouping by clinic, then calculates if not available or stale
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'patient' | 'procedure' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics (requires clinicBranchId for cache)
+   * @returns No-show metrics grouped by specified entity
+   */
+  async getNoShowMetrics(groupBy, dateRange, options) {
+    if (groupBy === "clinic" && dateRange && (options == null ? void 0 : options.useCache) !== false && (options == null ? void 0 : options.clinicBranchId)) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredNoShowMetrics(
+        this.db,
+        options.clinicBranchId,
+        "clinic",
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const noShow = getNoShowAppointments(appointments);
+    if (groupBy === "clinic") {
+      return this.groupNoShowsByClinic(noShow, appointments);
+    } else if (groupBy === "practitioner") {
+      return this.groupNoShowsByPractitioner(noShow, appointments);
+    } else if (groupBy === "patient") {
+      return this.groupNoShowsByPatient(noShow, appointments);
+    } else if (groupBy === "technology") {
+      return this.groupNoShowsByTechnology(noShow, appointments);
+    } else {
+      return this.groupNoShowsByProcedure(noShow, appointments);
+    }
+  }
+  /**
+   * Group no-shows by clinic
+   */
+  groupNoShowsByClinic(noShow, allAppointments) {
+    const clinicMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const clinicId = appointment.clinicBranchId;
+      const clinicName = ((_a = appointment.clinicInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!clinicMap.has(clinicId)) {
+        clinicMap.set(clinicId, { name: clinicName, noShow: [], all: [] });
+      }
+      clinicMap.get(clinicId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const clinicId = appointment.clinicBranchId;
+      if (clinicMap.has(clinicId)) {
+        clinicMap.get(clinicId).noShow.push(appointment);
+      }
+    });
+    return Array.from(clinicMap.entries()).map(([clinicId, data]) => ({
+      entityId: clinicId,
+      entityName: data.name,
+      entityType: "clinic",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by practitioner
+   */
+  groupNoShowsByPractitioner(noShow, allAppointments) {
+    const practitionerMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const practitionerId = appointment.practitionerId;
+      const practitionerName = ((_a = appointment.practitionerInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!practitionerMap.has(practitionerId)) {
+        practitionerMap.set(practitionerId, { name: practitionerName, noShow: [], all: [] });
+      }
+      practitionerMap.get(practitionerId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const practitionerId = appointment.practitionerId;
+      if (practitionerMap.has(practitionerId)) {
+        practitionerMap.get(practitionerId).noShow.push(appointment);
+      }
+    });
+    return Array.from(practitionerMap.entries()).map(([practitionerId, data]) => ({
+      entityId: practitionerId,
+      entityName: data.name,
+      entityType: "practitioner",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by patient
+   */
+  groupNoShowsByPatient(noShow, allAppointments) {
+    const patientMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const patientId = appointment.patientId;
+      const patientName = ((_a = appointment.patientInfo) == null ? void 0 : _a.fullName) || "Unknown";
+      if (!patientMap.has(patientId)) {
+        patientMap.set(patientId, { name: patientName, noShow: [], all: [] });
+      }
+      patientMap.get(patientId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const patientId = appointment.patientId;
+      if (patientMap.has(patientId)) {
+        patientMap.get(patientId).noShow.push(appointment);
+      }
+    });
+    return Array.from(patientMap.entries()).map(([patientId, data]) => ({
+      entityId: patientId,
+      entityName: data.name,
+      entityType: "patient",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by procedure
+   */
+  groupNoShowsByProcedure(noShow, allAppointments) {
+    const procedureMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const procedureId = appointment.procedureId;
+      const procedureName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!procedureMap.has(procedureId)) {
+        procedureMap.set(procedureId, { name: procedureName, noShow: [], all: [] });
+      }
+      procedureMap.get(procedureId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const procedureId = appointment.procedureId;
+      if (procedureMap.has(procedureId)) {
+        procedureMap.get(procedureId).noShow.push(appointment);
+      }
+    });
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      entityId: procedureId,
+      entityName: data.name,
+      entityType: "procedure",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by technology
+   * Aggregates all procedures using the same technology across all doctors
+   */
+  groupNoShowsByTechnology(noShow, allAppointments) {
+    const technologyMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a, _b, _c;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      const technologyName = ((_b = appointment.procedureExtendedInfo) == null ? void 0 : _b.procedureTechnologyName) || ((_c = appointment.procedureInfo) == null ? void 0 : _c.technologyName) || "Unknown";
+      if (!technologyMap.has(technologyId)) {
+        technologyMap.set(technologyId, { name: technologyName, noShow: [], all: [] });
+      }
+      technologyMap.get(technologyId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      var _a;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      if (technologyMap.has(technologyId)) {
+        technologyMap.get(technologyId).noShow.push(appointment);
+      }
+    });
+    return Array.from(technologyMap.entries()).map(([technologyId, data]) => ({
+      entityId: technologyId,
+      entityName: data.name,
+      entityType: "technology",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  // ==========================================
+  // Financial Analytics
+  // ==========================================
+  /**
+   * Get revenue metrics grouped by clinic, practitioner, procedure, patient, or technology
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'patient' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped revenue metrics
+   */
+  async getRevenueMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedRevenueMetrics(appointments, groupBy);
+  }
+  /**
+   * Get revenue metrics
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Revenue metrics
+   */
+  async getRevenueMetrics(filters, dateRange, options) {
+    if ((filters == null ? void 0 : filters.clinicBranchId) && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredRevenueMetrics(
+        this.db,
+        filters.clinicBranchId,
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const revenueByStatus = {};
+    Object.values(AppointmentStatus).forEach((status) => {
+      const statusAppointments = appointments.filter((a) => a.status === status);
+      const { totalRevenue: statusRevenue } = calculateTotalRevenue(statusAppointments);
+      revenueByStatus[status] = statusRevenue;
+    });
+    const revenueByPaymentStatus = {};
+    Object.values(PaymentStatus).forEach((paymentStatus) => {
+      const paymentAppointments = completed.filter((a) => a.paymentStatus === paymentStatus);
+      const { totalRevenue: paymentRevenue } = calculateTotalRevenue(paymentAppointments);
+      revenueByPaymentStatus[paymentStatus] = paymentRevenue;
+    });
+    const unpaid = completed.filter((a) => a.paymentStatus === "unpaid" /* UNPAID */);
+    const refunded = completed.filter((a) => a.paymentStatus === "refunded" /* REFUNDED */);
+    const { totalRevenue: unpaidRevenue } = calculateTotalRevenue(unpaid);
+    const { totalRevenue: refundedRevenue } = calculateTotalRevenue(refunded);
+    let totalTax = 0;
+    let totalSubtotal = 0;
+    completed.forEach((appointment) => {
+      const costData = calculateAppointmentCost(appointment);
+      if (costData.source === "finalbilling") {
+        totalTax += costData.tax || 0;
+        totalSubtotal += costData.subtotal || 0;
+      } else {
+        totalSubtotal += costData.cost;
+      }
+    });
+    return {
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      currency,
+      revenueByStatus,
+      revenueByPaymentStatus,
+      unpaidRevenue,
+      refundedRevenue,
+      totalTax,
+      totalSubtotal
+    };
+  }
+  // ==========================================
+  // Product Usage Analytics
+  // ==========================================
+  /**
+   * Get product usage metrics grouped by clinic, practitioner, procedure, or patient
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'patient'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped product usage metrics
+   */
+  async getProductUsageMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedProductUsageMetrics(appointments, groupBy);
+  }
+  /**
+   * Get product usage metrics
+   *
+   * @param productId - Optional product ID (if not provided, returns all products)
+   * @param dateRange - Optional date range filter
+   * @returns Product usage metrics
+   */
+  async getProductUsageMetrics(productId, dateRange) {
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const productMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const products = extractProductUsage(appointment);
+      products.forEach((product) => {
+        var _a;
+        if (productId && product.productId !== productId) {
+          return;
+        }
+        if (!productMap.has(product.productId)) {
+          productMap.set(product.productId, {
+            name: product.productName,
+            brandId: product.brandId,
+            brandName: product.brandName,
+            quantity: 0,
+            revenue: 0,
+            usageCount: 0,
+            procedureMap: /* @__PURE__ */ new Map()
+          });
+        }
+        const productData = productMap.get(product.productId);
+        productData.quantity += product.quantity;
+        productData.revenue += product.subtotal;
+        productData.usageCount++;
+        const procId = appointment.procedureId;
+        const procName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
+        if (productData.procedureMap.has(procId)) {
+          const procData = productData.procedureMap.get(procId);
+          procData.count++;
+          procData.quantity += product.quantity;
+        } else {
+          productData.procedureMap.set(procId, {
+            name: procName,
+            count: 1,
+            quantity: product.quantity
+          });
+        }
+      });
+    });
+    const results = Array.from(productMap.entries()).map(([productId2, data]) => ({
+      productId: productId2,
+      productName: data.name,
+      brandId: data.brandId,
+      brandName: data.brandName,
+      totalQuantity: data.quantity,
+      totalRevenue: data.revenue,
+      averagePrice: data.usageCount > 0 ? data.revenue / data.quantity : 0,
+      currency: "CHF",
+      // Could be extracted from products
+      usageCount: data.usageCount,
+      averageQuantityPerAppointment: data.usageCount > 0 ? data.quantity / data.usageCount : 0,
+      usageByProcedure: Array.from(data.procedureMap.entries()).map(([procId, procData]) => ({
+        procedureId: procId,
+        procedureName: procData.name,
+        count: procData.count,
+        totalQuantity: procData.quantity
+      }))
+    }));
+    return productId ? results[0] : results;
+  }
+  // ==========================================
+  // Patient Analytics
+  // ==========================================
+  /**
+   * Get patient behavior metrics grouped by clinic, practitioner, procedure, or technology
+   * Shows patient no-show and cancellation patterns per entity
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped patient behavior metrics
+   */
+  async getPatientBehaviorMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedPatientBehaviorMetrics(appointments, groupBy);
+  }
+  /**
+   * Get patient analytics
+   *
+   * @param patientId - Optional patient ID (if not provided, returns aggregate)
+   * @param dateRange - Optional date range filter
+   * @returns Patient analytics
+   */
+  async getPatientAnalytics(patientId, dateRange) {
+    const appointments = await this.fetchAppointments(patientId ? { patientId } : void 0, dateRange);
+    if (patientId) {
+      return this.calculatePatientAnalytics(appointments, patientId);
+    }
+    const patientMap = /* @__PURE__ */ new Map();
+    appointments.forEach((appointment) => {
+      const patId = appointment.patientId;
+      if (!patientMap.has(patId)) {
+        patientMap.set(patId, []);
+      }
+      patientMap.get(patId).push(appointment);
+    });
+    return Array.from(patientMap.entries()).map(
+      ([patId, patAppointments]) => this.calculatePatientAnalytics(patAppointments, patId)
+    );
+  }
+  /**
+   * Calculate analytics for a specific patient
+   */
+  calculatePatientAnalytics(appointments, patientId) {
+    var _a;
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const appointmentDates = appointments.map((a) => a.appointmentStartTime.toDate()).sort((a, b) => a.getTime() - b.getTime());
+    const firstAppointmentDate = appointmentDates.length > 0 ? appointmentDates[0] : null;
+    const lastAppointmentDate = appointmentDates.length > 0 ? appointmentDates[appointmentDates.length - 1] : null;
+    let averageDaysBetween = null;
+    if (appointmentDates.length > 1) {
+      const intervals = [];
+      for (let i = 1; i < appointmentDates.length; i++) {
+        const diffMs = appointmentDates[i].getTime() - appointmentDates[i - 1].getTime();
+        intervals.push(diffMs / (1e3 * 60 * 60 * 24));
+      }
+      averageDaysBetween = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+    }
+    const uniquePractitioners = new Set(appointments.map((a) => a.practitionerId));
+    const uniqueClinics = new Set(appointments.map((a) => a.clinicBranchId));
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      var _a2, _b;
+      const procId = appointment.procedureId;
+      const procName = ((_a2 = appointment.procedureInfo) == null ? void 0 : _a2.name) || "Unknown";
+      procedureMap.set(procId, {
+        name: procName,
+        count: (((_b = procedureMap.get(procId)) == null ? void 0 : _b.count) || 0) + 1
+      });
+    });
+    const favoriteProcedures = Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      count: data.count
+    })).sort((a, b) => b.count - a.count).slice(0, 5);
+    const patientName = appointments.length > 0 ? ((_a = appointments[0].patientInfo) == null ? void 0 : _a.fullName) || "Unknown" : "Unknown";
+    return {
+      patientId,
+      patientName,
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      canceledAppointments: canceled.length,
+      noShowAppointments: noShow.length,
+      cancellationRate: calculatePercentage(canceled.length, appointments.length),
+      noShowRate: calculatePercentage(noShow.length, appointments.length),
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      currency,
+      lifetimeValue: totalRevenue,
+      firstAppointmentDate,
+      lastAppointmentDate,
+      averageDaysBetweenAppointments: averageDaysBetween ? Math.round(averageDaysBetween) : null,
+      uniquePractitioners: uniquePractitioners.size,
+      uniqueClinics: uniqueClinics.size,
+      favoriteProcedures
+    };
+  }
+  // ==========================================
+  // Dashboard Analytics
+  // ==========================================
+  /**
+   * Determines analytics period from date range
+   */
+  determinePeriodFromDateRange(dateRange) {
+    const diffMs = dateRange.end.getTime() - dateRange.start.getTime();
+    const diffDays = diffMs / (1e3 * 60 * 60 * 24);
+    if (diffDays <= 1) return "daily";
+    if (diffDays <= 7) return "weekly";
+    if (diffDays <= 31) return "monthly";
+    if (diffDays <= 365) return "yearly";
+    return "all_time";
+  }
+  /**
+   * Get comprehensive dashboard data
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Complete dashboard analytics
+   */
+  async getDashboardData(filters, dateRange, options) {
+    if ((filters == null ? void 0 : filters.clinicBranchId) && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredDashboardAnalytics(
+        this.db,
+        filters.clinicBranchId,
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...analytics } = stored;
+        return analytics;
+      }
+    }
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const pending = appointments.filter((a) => a.status === "pending" /* PENDING */);
+    const confirmed = appointments.filter((a) => a.status === "confirmed" /* CONFIRMED */);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const uniquePatients = new Set(appointments.map((a) => a.patientId));
+    const uniquePractitioners = new Set(appointments.map((a) => a.practitionerId));
+    const uniqueProcedures = new Set(appointments.map((a) => a.procedureId));
+    const practitionerMetrics = await Promise.all(
+      Array.from(uniquePractitioners).slice(0, 5).map((practitionerId) => this.getPractitionerAnalytics(practitionerId, dateRange))
+    );
+    const procedureMetricsResults = await Promise.all(
+      Array.from(uniqueProcedures).slice(0, 5).map((procedureId) => this.getProcedureAnalytics(procedureId, dateRange))
+    );
+    const procedureMetrics = procedureMetricsResults.filter(
+      (result) => !Array.isArray(result)
+    );
+    const cancellationMetrics = await this.getCancellationMetrics("clinic", dateRange);
+    const noShowMetrics = await this.getNoShowMetrics("clinic", dateRange);
+    const timeEfficiency = await this.getTimeEfficiencyMetrics(filters, dateRange);
+    const productMetrics = await this.getProductUsageMetrics(void 0, dateRange);
+    const topProducts = Array.isArray(productMetrics) ? productMetrics.sort((a, b) => b.totalRevenue - a.totalRevenue).slice(0, 5) : [];
+    const recentActivity = appointments.sort((a, b) => b.appointmentStartTime.toMillis() - a.appointmentStartTime.toMillis()).slice(0, 10).map((appointment) => {
+      var _a, _b, _c, _d, _e;
+      let type = "appointment";
+      let description = "";
+      if (appointment.status === "completed" /* COMPLETED */) {
+        type = "completion";
+        description = `Appointment completed: ${((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown procedure"}`;
+      } else if (appointment.status === "canceled_patient" /* CANCELED_PATIENT */ || appointment.status === "canceled_clinic" /* CANCELED_CLINIC */ || appointment.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */) {
+        type = "cancellation";
+        description = `Appointment canceled: ${((_b = appointment.procedureInfo) == null ? void 0 : _b.name) || "Unknown procedure"}`;
+      } else if (appointment.status === "no_show" /* NO_SHOW */) {
+        type = "no_show";
+        description = `No-show: ${((_c = appointment.procedureInfo) == null ? void 0 : _c.name) || "Unknown procedure"}`;
+      } else {
+        description = `Appointment ${appointment.status}: ${((_d = appointment.procedureInfo) == null ? void 0 : _d.name) || "Unknown procedure"}`;
+      }
+      return {
+        type,
+        date: appointment.appointmentStartTime.toDate(),
+        description,
+        entityId: appointment.practitionerId,
+        entityName: ((_e = appointment.practitionerInfo) == null ? void 0 : _e.name) || "Unknown"
+      };
+    });
+    return {
+      overview: {
+        totalAppointments: appointments.length,
+        completedAppointments: completed.length,
+        canceledAppointments: canceled.length,
+        noShowAppointments: noShow.length,
+        pendingAppointments: pending.length,
+        confirmedAppointments: confirmed.length,
+        totalRevenue,
+        averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+        currency,
+        uniquePatients: uniquePatients.size,
+        uniquePractitioners: uniquePractitioners.size,
+        uniqueProcedures: uniqueProcedures.size,
+        cancellationRate: calculatePercentage(canceled.length, appointments.length),
+        noShowRate: calculatePercentage(noShow.length, appointments.length)
+      },
+      practitionerMetrics: Array.isArray(practitionerMetrics) ? practitionerMetrics : [],
+      procedureMetrics: Array.isArray(procedureMetrics) ? procedureMetrics : [],
+      cancellationMetrics: Array.isArray(cancellationMetrics) ? cancellationMetrics[0] : cancellationMetrics,
+      noShowMetrics: Array.isArray(noShowMetrics) ? noShowMetrics[0] : noShowMetrics,
+      revenueTrends: [],
+      // TODO: Implement revenue trends
+      timeEfficiency,
+      topProducts,
+      recentActivity
+    };
+  }
+};
+
+// src/admin/analytics/analytics.admin.service.ts
+var AnalyticsAdminService = class {
+  /**
+   * Creates a new AnalyticsAdminService instance
+   *
+   * @param firestore - Admin Firestore instance (optional, defaults to admin.firestore())
+   */
+  constructor(firestore19) {
+    this.db = firestore19 || admin14.firestore();
+    const mockApp = {
+      name: "[DEFAULT]",
+      options: {},
+      automaticDataCollectionEnabled: false
+    };
+    const mockAuth = {};
+    const appointmentService = this.createAppointmentServiceAdapter();
+    this.analyticsService = new AnalyticsService(
+      this.db,
+      // Cast admin Firestore to client Firestore type
+      mockAuth,
+      mockApp,
+      appointmentService
+    );
+  }
+  /**
+   * Creates an adapter for AppointmentService to work with admin SDK
+   */
+  createAppointmentServiceAdapter() {
+    return {
+      searchAppointments: async (params) => {
+        let query2 = this.db.collection(APPOINTMENTS_COLLECTION);
+        if (params.clinicBranchId) {
+          query2 = query2.where("clinicBranchId", "==", params.clinicBranchId);
+        }
+        if (params.practitionerId) {
+          query2 = query2.where("practitionerId", "==", params.practitionerId);
+        }
+        if (params.procedureId) {
+          query2 = query2.where("procedureId", "==", params.procedureId);
+        }
+        if (params.patientId) {
+          query2 = query2.where("patientId", "==", params.patientId);
+        }
+        if (params.startDate) {
+          const startDate = params.startDate instanceof Date ? params.startDate : params.startDate.toDate();
+          const startTimestamp = admin14.firestore.Timestamp.fromDate(startDate);
+          query2 = query2.where("appointmentStartTime", ">=", startTimestamp);
+        }
+        if (params.endDate) {
+          const endDate = params.endDate instanceof Date ? params.endDate : params.endDate.toDate();
+          const endTimestamp = admin14.firestore.Timestamp.fromDate(endDate);
+          query2 = query2.where("appointmentStartTime", "<=", endTimestamp);
+        }
+        const snapshot = await query2.get();
+        const appointments = snapshot.docs.map((doc2) => ({
+          id: doc2.id,
+          ...doc2.data()
+        }));
+        return {
+          appointments,
+          total: appointments.length
+        };
+      }
+    };
+  }
+  // Delegate all methods to the underlying AnalyticsService
+  // We expose them here so they can be called with admin SDK context
+  async getPractitionerAnalytics(practitionerId, dateRange, options) {
+    return this.analyticsService.getPractitionerAnalytics(practitionerId, dateRange, options);
+  }
+  async getProcedureAnalytics(procedureId, dateRange, options) {
+    return this.analyticsService.getProcedureAnalytics(procedureId, dateRange, options);
+  }
+  async getTimeEfficiencyMetrics(filters, dateRange, options) {
+    return this.analyticsService.getTimeEfficiencyMetrics(filters, dateRange, options);
+  }
+  async getTimeEfficiencyMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getTimeEfficiencyMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getCancellationMetrics(groupBy, dateRange, options) {
+    return this.analyticsService.getCancellationMetrics(groupBy, dateRange, options);
+  }
+  async getNoShowMetrics(groupBy, dateRange, options) {
+    return this.analyticsService.getNoShowMetrics(groupBy, dateRange, options);
+  }
+  async getRevenueMetrics(filters, dateRange, options) {
+    return this.analyticsService.getRevenueMetrics(filters, dateRange, options);
+  }
+  async getRevenueMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getRevenueMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getProductUsageMetrics(productId, dateRange) {
+    return this.analyticsService.getProductUsageMetrics(productId, dateRange);
+  }
+  async getProductUsageMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getProductUsageMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getPatientAnalytics(patientId, dateRange) {
+    return this.analyticsService.getPatientAnalytics(patientId, dateRange);
+  }
+  async getPatientBehaviorMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getPatientBehaviorMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getClinicAnalytics(clinicBranchId, dateRange) {
+    const dashboard = await this.analyticsService.getDashboardData(
+      { clinicBranchId },
+      dateRange
+    );
+    const clinicDoc = await this.db.collection("clinics").doc(clinicBranchId).get();
+    const clinicData = clinicDoc.data();
+    const clinicName = (clinicData == null ? void 0 : clinicData.name) || "Unknown";
+    return {
+      clinicBranchId,
+      clinicName,
+      totalAppointments: dashboard.overview.totalAppointments,
+      completedAppointments: dashboard.overview.completedAppointments,
+      canceledAppointments: dashboard.overview.canceledAppointments,
+      noShowAppointments: dashboard.overview.noShowAppointments,
+      cancellationRate: dashboard.overview.cancellationRate,
+      noShowRate: dashboard.overview.noShowRate,
+      totalRevenue: dashboard.overview.totalRevenue,
+      averageRevenuePerAppointment: dashboard.overview.averageRevenuePerAppointment,
+      currency: dashboard.overview.currency,
+      practitionerCount: dashboard.overview.uniquePractitioners,
+      patientCount: dashboard.overview.uniquePatients,
+      procedureCount: dashboard.overview.uniqueProcedures,
+      topPractitioners: dashboard.practitionerMetrics.slice(0, 5).map((p) => ({
+        practitionerId: p.practitionerId,
+        practitionerName: p.practitionerName,
+        appointmentCount: p.totalAppointments,
+        revenue: p.totalRevenue
+      })),
+      topProcedures: dashboard.procedureMetrics.slice(0, 5).map((p) => ({
+        procedureId: p.procedureId,
+        procedureName: p.procedureName,
+        appointmentCount: p.totalAppointments,
+        revenue: p.totalRevenue
+      }))
+    };
+  }
+  async getDashboardData(filters, dateRange, options) {
+    return this.analyticsService.getDashboardData(filters, dateRange, options);
+  }
+  /**
+   * Expose fetchAppointments for direct access if needed
+   * This method is used internally by AnalyticsService
+   */
+  async fetchAppointments(filters, dateRange) {
+    return this.analyticsService.fetchAppointments(filters, dateRange);
+  }
+};
+
 // src/admin/booking/booking.calculator.ts
-import { Timestamp } from "firebase/firestore";
+import { Timestamp as Timestamp3 } from "firebase/firestore";
 import { DateTime as DateTime2 } from "luxon";
 var BookingAvailabilityCalculator = class {
   /**
@@ -6890,8 +9047,8 @@ var BookingAvailabilityCalculator = class {
             const intervalStart = workStart < DateTime2.fromMillis(startDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(startDate.getTime(), { zone: tz }) : workStart;
             const intervalEnd = workEnd > DateTime2.fromMillis(endDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(endDate.getTime(), { zone: tz }) : workEnd;
             workingIntervals.push({
-              start: Timestamp.fromMillis(intervalStart.toMillis()),
-              end: Timestamp.fromMillis(intervalEnd.toMillis())
+              start: Timestamp3.fromMillis(intervalStart.toMillis()),
+              end: Timestamp3.fromMillis(intervalEnd.toMillis())
             });
             if (daySchedule.breaks && daySchedule.breaks.length > 0) {
               for (const breakTime of daySchedule.breaks) {
@@ -6911,8 +9068,8 @@ var BookingAvailabilityCalculator = class {
                   ...this.subtractInterval(
                     workingIntervals[workingIntervals.length - 1],
                     {
-                      start: Timestamp.fromMillis(breakStart.toMillis()),
-                      end: Timestamp.fromMillis(breakEnd.toMillis())
+                      start: Timestamp3.fromMillis(breakStart.toMillis()),
+                      end: Timestamp3.fromMillis(breakEnd.toMillis())
                     }
                   )
                 );
@@ -7022,8 +9179,8 @@ var BookingAvailabilityCalculator = class {
             const intervalStart = workStart < DateTime2.fromMillis(startDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(startDate.getTime(), { zone: tz }) : workStart;
             const intervalEnd = workEnd > DateTime2.fromMillis(endDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(endDate.getTime(), { zone: tz }) : workEnd;
             workingIntervals.push({
-              start: Timestamp.fromMillis(intervalStart.toMillis()),
-              end: Timestamp.fromMillis(intervalEnd.toMillis())
+              start: Timestamp3.fromMillis(intervalStart.toMillis()),
+              end: Timestamp3.fromMillis(intervalEnd.toMillis())
             });
           }
         }
@@ -7103,7 +9260,7 @@ var BookingAvailabilityCalculator = class {
         const isInFuture = slotStart >= earliestBookableTime;
         if (isInFuture && this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
-            start: Timestamp.fromMillis(slotStart.toMillis())
+            start: Timestamp3.fromMillis(slotStart.toMillis())
           });
         }
         slotStart = slotStart.plus({ minutes: intervalMinutes });
@@ -7222,13 +9379,13 @@ var BookingAvailabilityCalculator = class {
 BookingAvailabilityCalculator.DEFAULT_INTERVAL_MINUTES = 15;
 
 // src/admin/booking/booking.admin.ts
-import * as admin15 from "firebase-admin";
+import * as admin16 from "firebase-admin";
 
 // src/admin/documentation-templates/document-manager.admin.ts
-import * as admin14 from "firebase-admin";
+import * as admin15 from "firebase-admin";
 var DocumentManagerAdminService = class {
-  constructor(firestore18) {
-    this.db = firestore18;
+  constructor(firestore19) {
+    this.db = firestore19;
   }
   /**
    * Adds operations to a Firestore batch to initialize all linked forms for a new appointment
@@ -7331,10 +9488,10 @@ var DocumentManagerAdminService = class {
       };
     }
     const templateIds = technologyTemplates.map((t) => t.templateId);
-    const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin14.firestore.FieldPath.documentId(), "in", templateIds).get();
+    const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin15.firestore.FieldPath.documentId(), "in", templateIds).get();
     const templatesMap = /* @__PURE__ */ new Map();
-    templatesSnapshot.forEach((doc) => {
-      templatesMap.set(doc.id, doc.data());
+    templatesSnapshot.forEach((doc2) => {
+      templatesMap.set(doc2.id, doc2.data());
     });
     for (const templateRef of technologyTemplates) {
       const template = templatesMap.get(templateRef.templateId);
@@ -7397,8 +9554,8 @@ var BookingAdmin = class {
    * Creates a new BookingAdmin instance
    * @param firestore - Firestore instance provided by the caller
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin15.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin16.firestore();
     this.documentManagerAdmin = new DocumentManagerAdminService(this.db);
   }
   /**
@@ -7420,8 +9577,8 @@ var BookingAdmin = class {
         timeframeStart: timeframe.start instanceof Date ? timeframe.start.toISOString() : timeframe.start.toDate().toISOString(),
         timeframeEnd: timeframe.end instanceof Date ? timeframe.end.toISOString() : timeframe.end.toDate().toISOString()
       });
-      const start = timeframe.start instanceof Date ? admin15.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
-      const end = timeframe.end instanceof Date ? admin15.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
+      const start = timeframe.start instanceof Date ? admin16.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
+      const end = timeframe.end instanceof Date ? admin16.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
       Logger.debug("[BookingAdmin] Fetching clinic data", { clinicId });
       const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
       if (!clinicDoc.exists) {
@@ -7507,7 +9664,7 @@ var BookingAdmin = class {
       const result = BookingAvailabilityCalculator.calculateSlots(request);
       const availableSlotsResult = {
         availableSlots: result.availableSlots.map((slot) => ({
-          start: admin15.firestore.Timestamp.fromMillis(slot.start.toMillis())
+          start: admin16.firestore.Timestamp.fromMillis(slot.start.toMillis())
         }))
       };
       Logger.info(
@@ -7570,14 +9727,14 @@ var BookingAdmin = class {
         endTime: end.toDate().toISOString()
       });
       const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
-      const queryStart = admin15.firestore.Timestamp.fromMillis(
+      const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
       const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
-      const events = snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id
+      const events = snapshot.docs.map((doc2) => ({
+        ...doc2.data(),
+        id: doc2.id
       })).filter((event) => {
         return event.eventTime.end.toMillis() > start.toMillis();
       });
@@ -7616,14 +9773,14 @@ var BookingAdmin = class {
         endTime: end.toDate().toISOString()
       });
       const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
-      const queryStart = admin15.firestore.Timestamp.fromMillis(
+      const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
       const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
-      const events = snapshot.docs.map((doc) => ({
-        ...doc.data(),
-        id: doc.id
+      const events = snapshot.docs.map((doc2) => ({
+        ...doc2.data(),
+        id: doc2.id
       })).filter((event) => {
         return event.eventTime.end.toMillis() > start.toMillis();
       });
@@ -7685,8 +9842,8 @@ var BookingAdmin = class {
       `[BookingAdmin] Orchestrating appointment creation for patient ${data.patientId} by user ${authenticatedUserId}`
     );
     const batch = this.db.batch();
-    const adminTsNow = admin15.firestore.Timestamp.now();
-    const serverTimestampValue = admin15.firestore.FieldValue.serverTimestamp();
+    const adminTsNow = admin16.firestore.Timestamp.now();
+    const serverTimestampValue = admin16.firestore.FieldValue.serverTimestamp();
     try {
       if (!data.patientId || !data.procedureId || !data.appointmentStartTime || !data.appointmentEndTime) {
         return {
@@ -7783,7 +9940,7 @@ var BookingAdmin = class {
         fullName: `${(patientSensitiveData == null ? void 0 : patientSensitiveData.firstName) || ""} ${(patientSensitiveData == null ? void 0 : patientSensitiveData.lastName) || ""}`.trim() || patientProfileData.displayName,
         email: (patientSensitiveData == null ? void 0 : patientSensitiveData.email) || "",
         phone: (patientSensitiveData == null ? void 0 : patientSensitiveData.phoneNumber) || patientProfileData.phoneNumber || null,
-        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin15.firestore.Timestamp.now(),
+        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin16.firestore.Timestamp.now(),
         gender: (patientSensitiveData == null ? void 0 : patientSensitiveData.gender) || "other" /* OTHER */
       };
       const newAppointmentId = this.db.collection(APPOINTMENTS_COLLECTION).doc().id;
@@ -8048,7 +10205,7 @@ var BookingAdmin = class {
 };
 
 // src/admin/free-consultation/free-consultation-utils.admin.ts
-import * as admin16 from "firebase-admin";
+import * as admin17 from "firebase-admin";
 
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
@@ -8061,10 +10218,10 @@ var TECHNOLOGIES_COLLECTION = "technologies";
 
 // src/admin/free-consultation/free-consultation-utils.admin.ts
 async function freeConsultationInfrastructure(db) {
-  const firestore18 = db || admin16.firestore();
+  const firestore19 = db || admin17.firestore();
   try {
     console.log("[freeConsultationInfrastructure] Checking free consultation infrastructure...");
-    const technologyRef = firestore18.collection(TECHNOLOGIES_COLLECTION).doc("free-consultation-tech");
+    const technologyRef = firestore19.collection(TECHNOLOGIES_COLLECTION).doc("free-consultation-tech");
     const technologyDoc = await technologyRef.get();
     if (technologyDoc.exists) {
       console.log(
@@ -8073,7 +10230,7 @@ async function freeConsultationInfrastructure(db) {
       return true;
     }
     console.log("[freeConsultationInfrastructure] Creating free consultation infrastructure...");
-    await createFreeConsultationInfrastructure(firestore18);
+    await createFreeConsultationInfrastructure(firestore19);
     console.log(
       "[freeConsultationInfrastructure] Successfully created free consultation infrastructure"
     );
@@ -8270,8 +10427,8 @@ var PractitionerInviteMailingService = class extends BaseMailingService {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore18, mailgunClient) {
-    super(firestore18, mailgunClient);
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
     this.DEFAULT_REGISTRATION_URL = "https://metaesthetics.net/register";
     this.DEFAULT_SUBJECT = "You've Been Invited to Join as a Practitioner";
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
@@ -9134,8 +11291,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore18, mailgunClient) {
-    super(firestore18, mailgunClient);
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
     this.DEFAULT_FROM_ADDRESS = "MetaEstetics <no-reply@mg.metaesthetics.net>";
   }
@@ -9478,8 +11635,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    */
   async fetchPractitionerById(practitionerId) {
     try {
-      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      return doc.exists ? doc.data() : null;
+      const doc2 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+      return doc2.exists ? doc2.data() : null;
     } catch (error) {
       Logger.error(
         "[ExistingPractitionerInviteMailingService] Error fetching practitioner:",
@@ -9495,8 +11652,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    */
   async fetchClinicById(clinicId) {
     try {
-      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      return doc.exists ? doc.data() : null;
+      const doc2 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+      return doc2.exists ? doc2.data() : null;
     } catch (error) {
       Logger.error(
         "[ExistingPractitionerInviteMailingService] Error fetching clinic:",
@@ -9508,14 +11665,14 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
 };
 
 // src/admin/users/user-profile.admin.ts
-import * as admin17 from "firebase-admin";
+import * as admin18 from "firebase-admin";
 var UserProfileAdminService = class {
   /**
    * Constructor for UserProfileAdminService
    * @param firestore Optional Firestore instance. If not provided, uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin17.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin18.firestore();
   }
   /**
    * Creates a blank user profile with minimal information
@@ -9532,9 +11689,9 @@ var UserProfileAdminService = class {
       roles: [],
       // Empty roles array as requested
       isAnonymous: authUserData.isAnonymous,
-      createdAt: admin17.firestore.FieldValue.serverTimestamp(),
-      updatedAt: admin17.firestore.FieldValue.serverTimestamp(),
-      lastLoginAt: admin17.firestore.FieldValue.serverTimestamp()
+      createdAt: admin18.firestore.FieldValue.serverTimestamp(),
+      updatedAt: admin18.firestore.FieldValue.serverTimestamp(),
+      lastLoginAt: admin18.firestore.FieldValue.serverTimestamp()
     };
     try {
       const userRef = this.db.collection(USERS_COLLECTION).doc(authUserData.uid);
@@ -9610,8 +11767,8 @@ var UserProfileAdminService = class {
           clinics: mergedProfileData.clinics || [],
           doctorIds: mergedProfileData.doctorIds || [],
           clinicIds: mergedProfileData.clinicIds || [],
-          createdAt: admin17.firestore.FieldValue.serverTimestamp(),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          createdAt: admin18.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         };
         await patientProfileRef.set(patientProfileData);
         patientProfile = {
@@ -9650,8 +11807,8 @@ var UserProfileAdminService = class {
         };
         const sensitiveInfoData = {
           ...mergedSensitiveData,
-          createdAt: admin17.firestore.FieldValue.serverTimestamp(),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          createdAt: admin18.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
           // Leave dateOfBirth as is
         };
         await sensitiveInfoRef.set(sensitiveInfoData);
@@ -9677,7 +11834,7 @@ var UserProfileAdminService = class {
           contraindications: [],
           allergies: [],
           currentMedications: [],
-          lastUpdated: admin17.firestore.FieldValue.serverTimestamp(),
+          lastUpdated: admin18.firestore.FieldValue.serverTimestamp(),
           updatedBy: userId
         };
         await medicalInfoRef.set(medicalInfoData);
@@ -9694,14 +11851,14 @@ var UserProfileAdminService = class {
       const batch = this.db.batch();
       if (!userData.roles.includes("patient" /* PATIENT */)) {
         batch.update(userRef, {
-          roles: admin17.firestore.FieldValue.arrayUnion("patient" /* PATIENT */),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          roles: admin18.firestore.FieldValue.arrayUnion("patient" /* PATIENT */),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       if (!userData.patientProfile) {
         batch.update(userRef, {
           patientProfile: patientProfileId,
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       await batch.commit();
@@ -9742,8 +11899,8 @@ var UserProfileAdminService = class {
       const userData = userDoc.data();
       if (!userData.roles.includes("clinic_admin" /* CLINIC_ADMIN */)) {
         await userRef.update({
-          roles: admin17.firestore.FieldValue.arrayUnion("clinic_admin" /* CLINIC_ADMIN */),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          roles: admin18.firestore.FieldValue.arrayUnion("clinic_admin" /* CLINIC_ADMIN */),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       const updatedUserDoc = await userRef.get();
@@ -9774,8 +11931,8 @@ var UserProfileAdminService = class {
       const userData = userDoc.data();
       if (!userData.roles.includes("practitioner" /* PRACTITIONER */)) {
         await userRef.update({
-          roles: admin17.firestore.FieldValue.arrayUnion("practitioner" /* PRACTITIONER */),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          roles: admin18.firestore.FieldValue.arrayUnion("practitioner" /* PRACTITIONER */),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       const updatedUserDoc = await userRef.get();
@@ -9794,6 +11951,8 @@ var UserProfileAdminService = class {
 console.log("[Admin Module] Initialized and services exported.");
 TimestampUtils.enableServerMode();
 export {
+  ANALYTICS_COLLECTION,
+  AnalyticsAdminService,
   AppointmentAggregationService,
   AppointmentMailingService,
   AppointmentStatus,
@@ -9801,19 +11960,26 @@ export {
   BillingTransactionType,
   BookingAdmin,
   BookingAvailabilityCalculator,
+  CANCELLATION_ANALYTICS_SUBCOLLECTION,
+  CLINICS_COLLECTION,
+  CLINIC_ANALYTICS_SUBCOLLECTION,
   CalendarAdminService,
   ClinicAggregationService,
+  DASHBOARD_ANALYTICS_SUBCOLLECTION,
   DocumentManagerAdminService,
   ExistingPractitionerInviteMailingService,
   FilledFormsAggregationService,
   Logger,
   NOTIFICATIONS_COLLECTION,
+  NO_SHOW_ANALYTICS_SUBCOLLECTION,
   NotificationStatus,
   NotificationType,
   NotificationsAdmin,
   PATIENTS_COLLECTION,
   PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME,
   PATIENT_SENSITIVE_INFO_COLLECTION,
+  PRACTITIONER_ANALYTICS_SUBCOLLECTION,
+  PROCEDURE_ANALYTICS_SUBCOLLECTION,
   PatientAggregationService,
   PatientInstructionStatus,
   PatientRequirementOverallStatus,
@@ -9824,8 +11990,10 @@ export {
   PractitionerInviteStatus,
   PractitionerTokenStatus,
   ProcedureAggregationService,
+  REVENUE_ANALYTICS_SUBCOLLECTION,
   ReviewsAggregationService,
   SubscriptionStatus,
+  TIME_EFFICIENCY_ANALYTICS_SUBCOLLECTION,
   UserProfileAdminService,
   UserRole,
   freeConsultationInfrastructure