@blackcode_sa/metaestetics-api 1.8.1 → 1.8.2

package/dist/index.js

@@ -43,6 +43,7 @@ __export(index_exports, {
   CLINIC_GROUPS_COLLECTION: () => CLINIC_GROUPS_COLLECTION,
   CalendarEventStatus: () => CalendarEventStatus,
   CalendarEventType: () => CalendarEventType,
+  CalendarServiceV2: () => CalendarServiceV2,
   CalendarServiceV3: () => CalendarServiceV3,
   CalendarSyncStatus: () => CalendarSyncStatus,
   ClinicAdminService: () => ClinicAdminService,
@@ -111,6 +112,7 @@ __export(index_exports, {
   USERS_COLLECTION: () => USERS_COLLECTION,
   USER_FORMS_SUBCOLLECTION: () => USER_FORMS_SUBCOLLECTION,
   UserRole: () => UserRole,
+  UserService: () => UserService,
   addAllergySchema: () => addAllergySchema,
   addBlockingConditionSchema: () => addBlockingConditionSchema,
   addContraindicationSchema: () => addContraindicationSchema,
@@ -843,20 +845,20 @@ var rescheduleAppointmentSchema = import_zod3.z.object({
 var import_firestore = require("firebase/firestore");
 
 // src/types/calendar/index.ts
-var CalendarEventStatus = /* @__PURE__ */ ((CalendarEventStatus3) => {
-  CalendarEventStatus3["PENDING"] = "pending";
-  CalendarEventStatus3["CONFIRMED"] = "confirmed";
-  CalendarEventStatus3["REJECTED"] = "rejected";
-  CalendarEventStatus3["CANCELED"] = "canceled";
-  CalendarEventStatus3["RESCHEDULED"] = "rescheduled";
-  CalendarEventStatus3["COMPLETED"] = "completed";
-  CalendarEventStatus3["NO_SHOW"] = "no_show";
-  return CalendarEventStatus3;
+var CalendarEventStatus = /* @__PURE__ */ ((CalendarEventStatus4) => {
+  CalendarEventStatus4["PENDING"] = "pending";
+  CalendarEventStatus4["CONFIRMED"] = "confirmed";
+  CalendarEventStatus4["REJECTED"] = "rejected";
+  CalendarEventStatus4["CANCELED"] = "canceled";
+  CalendarEventStatus4["RESCHEDULED"] = "rescheduled";
+  CalendarEventStatus4["COMPLETED"] = "completed";
+  CalendarEventStatus4["NO_SHOW"] = "no_show";
+  return CalendarEventStatus4;
 })(CalendarEventStatus || {});
-var CalendarSyncStatus = /* @__PURE__ */ ((CalendarSyncStatus3) => {
-  CalendarSyncStatus3["INTERNAL"] = "internal";
-  CalendarSyncStatus3["EXTERNAL"] = "external";
-  return CalendarSyncStatus3;
+var CalendarSyncStatus = /* @__PURE__ */ ((CalendarSyncStatus4) => {
+  CalendarSyncStatus4["INTERNAL"] = "internal";
+  CalendarSyncStatus4["EXTERNAL"] = "external";
+  return CalendarSyncStatus4;
 })(CalendarSyncStatus || {});
 var CalendarEventType = /* @__PURE__ */ ((CalendarEventType3) => {
   CalendarEventType3["APPOINTMENT"] = "appointment";
@@ -1228,7 +1230,7 @@ async function searchAppointmentsUtil(db, params) {
     const q = (0, import_firestore.query)((0, import_firestore.collection)(db, APPOINTMENTS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore.getDocs)(q);
     const appointments = querySnapshot.docs.map(
-      (doc26) => doc26.data()
+      (doc32) => doc32.data()
     );
     const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
     return { appointments, lastDoc };
@@ -2035,7 +2037,7 @@ var AppointmentService = class extends BaseService {
       );
       const querySnapshot = await (0, import_firestore2.getDocs)(q);
       const appointments = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       console.log(
@@ -2108,7 +2110,7 @@ var AppointmentService = class extends BaseService {
       );
       const querySnapshot = await (0, import_firestore2.getDocs)(q);
       const appointments = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       console.log(
@@ -2819,11 +2821,11 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/types/calendar/synced-calendar.types.ts
-var SyncedCalendarProvider = /* @__PURE__ */ ((SyncedCalendarProvider2) => {
-  SyncedCalendarProvider2["GOOGLE"] = "google";
-  SyncedCalendarProvider2["OUTLOOK"] = "outlook";
-  SyncedCalendarProvider2["APPLE"] = "apple";
-  return SyncedCalendarProvider2;
+var SyncedCalendarProvider = /* @__PURE__ */ ((SyncedCalendarProvider3) => {
+  SyncedCalendarProvider3["GOOGLE"] = "google";
+  SyncedCalendarProvider3["OUTLOOK"] = "outlook";
+  SyncedCalendarProvider3["APPLE"] = "apple";
+  return SyncedCalendarProvider3;
 })(SyncedCalendarProvider || {});
 var SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 
@@ -3361,7 +3363,7 @@ var MediaService = class extends BaseService {
     try {
       const querySnapshot = await (0, import_firestore5.getDocs)(finalQuery);
       const mediaList = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       console.log(`[MediaService] Found ${mediaList.length} media items.`);
       return mediaList;
@@ -3415,8 +3417,8 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
     }
     const patientsSnapshot = await (0, import_firestore6.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc26) => {
-      patients.push(doc26.data());
+    patientsSnapshot.forEach((doc32) => {
+      patients.push(doc32.data());
     });
     console.log(
       `[getPatientsByClinicUtil] Found ${patients.length} patients for clinic ID: ${clinicId}`
@@ -3769,8 +3771,8 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
     }
     const patientsSnapshot = await (0, import_firestore9.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc26) => {
-      patients.push(doc26.data());
+    patientsSnapshot.forEach((doc32) => {
+      patients.push(doc32.data());
     });
     console.log(
       `[getPatientsByPractitionerUtil] Found ${patients.length} patients for practitioner ID: ${practitionerId}`
@@ -4338,7 +4340,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     (0, import_firestore11.where)("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await (0, import_firestore11.getDocs)(q);
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
   const admin2 = await getClinicAdmin(db, adminId);
@@ -5001,9 +5003,9 @@ var updateAllergyUtil = async (db, patientId, data, requesterId, requesterRoles)
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -5030,9 +5032,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, requesterId, reque
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -5049,9 +5051,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, requesterId, reque
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -5078,9 +5080,9 @@ var updateContraindicationUtil = async (db, patientId, data, requesterId, reques
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -5097,9 +5099,9 @@ var updateContraindicationUtil = async (db, patientId, data, requesterId, reques
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -5126,9 +5128,9 @@ var updateMedicationUtil = async (db, patientId, data, requesterId, requesterRol
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -5145,9 +5147,9 @@ var updateMedicationUtil = async (db, patientId, data, requesterId, requesterRol
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, requesterId, requesterRoles) => {
   await checkMedicalAccessUtil(db, patientId, requesterId, requesterRoles);
-  const doc26 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await (0, import_firestore16.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc32.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc32.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -5434,7 +5436,7 @@ var searchPatientsUtil = async (db, params, requester) => {
     const finalQuery = (0, import_firestore17.query)(patientsCollectionRef, ...constraints);
     const querySnapshot = await (0, import_firestore17.getDocs)(finalQuery);
     const patients = querySnapshot.docs.map(
-      (doc26) => doc26.data()
+      (doc32) => doc32.data()
     );
     console.log(
       `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
@@ -5466,8 +5468,8 @@ var getAllPatientsUtil = async (db, options) => {
     }
     const patientsSnapshot = await (0, import_firestore17.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc26) => {
-      patients.push(doc26.data());
+    patientsSnapshot.forEach((doc32) => {
+      patients.push(doc32.data());
     });
     console.log(`[getAllPatientsUtil] Found ${patients.length} patients`);
     return patients;
@@ -5589,7 +5591,7 @@ var getActiveInviteTokensByClinicUtil = async (db, clinicId) => {
   if (querySnapshot.empty) {
     return [];
   }
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 };
 var getActiveInviteTokensByPatientUtil = async (db, patientId) => {
   const tokensRef = (0, import_firestore18.collection)(
@@ -5607,7 +5609,7 @@ var getActiveInviteTokensByPatientUtil = async (db, patientId) => {
   if (querySnapshot.empty) {
     return [];
   }
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 };
 
 // src/services/patient/patient.service.ts
@@ -6713,7 +6715,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore21.where)("expiresAt", ">", import_firestore21.Timestamp.now())
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => doc26.data());
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets a token by its string value and validates it
@@ -6823,7 +6825,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore21.where)("status", "==", "active" /* ACTIVE */)
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => doc26.data());
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
@@ -6835,7 +6837,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore21.where)("isActive", "==", true)
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => doc26.data());
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
@@ -6847,7 +6849,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore21.where)("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => doc26.data());
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Updates a practitioner
@@ -7061,7 +7063,7 @@ var PractitionerService = class extends BaseService {
       );
       const querySnapshot = await (0, import_firestore21.getDocs)(q);
       const practitioners = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       return {
@@ -7132,8 +7134,8 @@ var PractitionerService = class extends BaseService {
       console.log(
         `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
       );
-      let practitioners = querySnapshot.docs.map((doc26) => {
-        return { ...doc26.data(), id: doc26.id };
+      let practitioners = querySnapshot.docs.map((doc32) => {
+        return { ...doc32.data(), id: doc32.id };
       });
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       if (filters.nameSearch && filters.nameSearch.trim() !== "") {
@@ -7617,7 +7619,7 @@ var UserService = class extends BaseService {
     ];
     const q = (0, import_firestore22.query)((0, import_firestore22.collection)(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore22.getDocs)(q);
-    const users = querySnapshot.docs.map((doc26) => doc26.data());
+    const users = querySnapshot.docs.map((doc32) => doc32.data());
     return users.map((userData) => userSchema.parse(userData));
   }
   /**
@@ -7981,7 +7983,7 @@ async function getAllActiveGroups(db) {
     (0, import_firestore23.where)("isActive", "==", true)
   );
   const querySnapshot = await (0, import_firestore23.getDocs)(q);
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
   console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
@@ -8421,7 +8423,7 @@ async function getClinicsByGroup(db, groupId) {
     (0, import_firestore24.where)("isActive", "==", true)
   );
   const querySnapshot = await (0, import_firestore24.getDocs)(q);
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
   console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
@@ -8615,7 +8617,7 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   }
   const q = (0, import_firestore24.query)((0, import_firestore24.collection)(db, CLINICS_COLLECTION), ...constraints);
   const querySnapshot = await (0, import_firestore24.getDocs)(q);
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -8660,11 +8662,11 @@ async function getAllClinics(db, pagination, lastDoc) {
     }
     const clinicsSnapshot = await (0, import_firestore24.getDocs)(clinicsQuery);
     const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
-    const clinics = clinicsSnapshot.docs.map((doc26) => {
-      const data = doc26.data();
+    const clinics = clinicsSnapshot.docs.map((doc32) => {
+      const data = doc32.data();
       return {
         ...data,
-        id: doc26.id
+        id: doc32.id
       };
     });
     return {
@@ -8691,8 +8693,8 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
     ];
     const q = (0, import_firestore24.query)((0, import_firestore24.collection)(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore24.getDocs)(q);
-    for (const doc26 of querySnapshot.docs) {
-      const clinic = doc26.data();
+    for (const doc32 of querySnapshot.docs) {
+      const clinic = doc32.data();
       const distance = (0, import_geofire_common4.distanceBetween)(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -8809,8 +8811,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = (0, import_firestore25.query)((0, import_firestore25.collection)(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore25.getDocs)(q);
-    for (const doc26 of querySnapshot.docs) {
-      const clinic = doc26.data();
+    for (const doc32 of querySnapshot.docs) {
+      const clinic = doc32.data();
       const distance = (0, import_geofire_common5.distanceBetween)(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -8898,8 +8900,8 @@ async function getClinicsByFilters(db, filters) {
       console.log(
         `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
       );
-      for (const doc26 of querySnapshot.docs) {
-        const clinic = { ...doc26.data(), id: doc26.id };
+      for (const doc32 of querySnapshot.docs) {
+        const clinic = { ...doc32.data(), id: doc32.id };
         const distance = (0, import_geofire_common6.distanceBetween)(
           [center.latitude, center.longitude],
           [clinic.location.latitude, clinic.location.longitude]
@@ -8955,8 +8957,8 @@ async function getClinicsByFilters(db, filters) {
     console.log(
       `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    const clinics = querySnapshot.docs.map((doc26) => {
-      return { ...doc26.data(), id: doc26.id };
+    const clinics = querySnapshot.docs.map((doc32) => {
+      return { ...doc32.data(), id: doc32.id };
     });
     let filteredClinics = clinics;
     if (filters.center) {
@@ -10274,12 +10276,226 @@ var AuthService = class extends BaseService {
   }
 };
 
-// src/services/calendar/calendar.v3.service.ts
+// src/services/calendar/calendar.v2.service.ts
+var import_firestore36 = require("firebase/firestore");
+var import_firestore37 = require("firebase/firestore");
+
+// src/services/calendar/utils/clinic.utils.ts
 var import_firestore30 = require("firebase/firestore");
+
+// src/services/calendar/utils/docs.utils.ts
+var import_firestore29 = require("firebase/firestore");
+function getPractitionerCalendarEventDocRef(db, practitionerId, eventId) {
+  return (0, import_firestore29.doc)(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getPatientCalendarEventDocRef(db, patientId, eventId) {
+  return (0, import_firestore29.doc)(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getClinicCalendarEventDocRef(db, clinicId, eventId) {
+  return (0, import_firestore29.doc)(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getPractitionerSyncedCalendarDocRef(db, practitionerId, syncedCalendarId) {
+  return (0, import_firestore29.doc)(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+function getPatientSyncedCalendarDocRef(db, patientId, syncedCalendarId) {
+  return (0, import_firestore29.doc)(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+function getClinicSyncedCalendarDocRef(db, clinicId, syncedCalendarId) {
+  return (0, import_firestore29.doc)(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+
+// src/services/calendar/utils/clinic.utils.ts
+async function createClinicCalendarEventUtil(db, clinicId, eventData, generateId2) {
+  const eventId = generateId2();
+  const eventRef = getClinicCalendarEventDocRef(db, clinicId, eventId);
+  const newEvent = {
+    id: eventId,
+    ...eventData,
+    createdAt: (0, import_firestore30.serverTimestamp)(),
+    updatedAt: (0, import_firestore30.serverTimestamp)()
+  };
+  await (0, import_firestore30.setDoc)(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: import_firestore30.Timestamp.now(),
+    updatedAt: import_firestore30.Timestamp.now()
+  };
+}
+async function updateClinicCalendarEventUtil(db, clinicId, eventId, updateData) {
+  const eventRef = getClinicCalendarEventDocRef(db, clinicId, eventId);
+  const updates = {
+    ...updateData,
+    updatedAt: (0, import_firestore30.serverTimestamp)()
+  };
+  await (0, import_firestore30.updateDoc)(eventRef, updates);
+  const updatedDoc = await (0, import_firestore30.getDoc)(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+async function checkAutoConfirmAppointmentsUtil(db, clinicId) {
+  const clinicDoc = await (0, import_firestore30.getDoc)((0, import_firestore30.doc)(db, `clinics/${clinicId}`));
+  if (!clinicDoc.exists()) {
+    throw new Error(`Clinic with ID ${clinicId} not found`);
+  }
+  const clinicData = clinicDoc.data();
+  const clinicGroupId = clinicData.clinicGroupId;
+  if (!clinicGroupId) {
+    return false;
+  }
+  const clinicGroupDoc = await (0, import_firestore30.getDoc)(
+    (0, import_firestore30.doc)(db, `${CLINIC_GROUPS_COLLECTION}/${clinicGroupId}`)
+  );
+  if (!clinicGroupDoc.exists()) {
+    return false;
+  }
+  const clinicGroupData = clinicGroupDoc.data();
+  return !!clinicGroupData.autoConfirmAppointments;
+}
+
+// src/services/calendar/utils/patient.utils.ts
 var import_firestore31 = require("firebase/firestore");
+async function createPatientCalendarEventUtil(db, patientId, eventData, generateId2) {
+  const eventId = generateId2();
+  const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
+  const newEvent = {
+    id: eventId,
+    ...eventData,
+    createdAt: (0, import_firestore31.serverTimestamp)(),
+    updatedAt: (0, import_firestore31.serverTimestamp)()
+  };
+  await (0, import_firestore31.setDoc)(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: import_firestore31.Timestamp.now(),
+    updatedAt: import_firestore31.Timestamp.now()
+  };
+}
+async function updatePatientCalendarEventUtil(db, patientId, eventId, updateData) {
+  const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
+  const updates = {
+    ...updateData,
+    updatedAt: (0, import_firestore31.serverTimestamp)()
+  };
+  await (0, import_firestore31.updateDoc)(eventRef, updates);
+  const updatedDoc = await (0, import_firestore31.getDoc)(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+
+// src/services/calendar/utils/practitioner.utils.ts
+var import_firestore32 = require("firebase/firestore");
+async function createPractitionerCalendarEventUtil(db, practitionerId, eventData, generateId2) {
+  const eventId = generateId2();
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  const newEvent = {
+    id: eventId,
+    ...eventData,
+    createdAt: (0, import_firestore32.serverTimestamp)(),
+    updatedAt: (0, import_firestore32.serverTimestamp)()
+  };
+  await (0, import_firestore32.setDoc)(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: import_firestore32.Timestamp.now(),
+    updatedAt: import_firestore32.Timestamp.now()
+  };
+}
+async function updatePractitionerCalendarEventUtil(db, practitionerId, eventId, updateData) {
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  const updates = {
+    ...updateData,
+    updatedAt: (0, import_firestore32.serverTimestamp)()
+  };
+  await (0, import_firestore32.updateDoc)(eventRef, updates);
+  const updatedDoc = await (0, import_firestore32.getDoc)(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+
+// src/services/calendar/utils/appointment.utils.ts
+async function createAppointmentUtil2(db, clinicId, practitionerId, patientId, eventData, generateId2) {
+  const eventId = generateId2();
+  const autoConfirm = await checkAutoConfirmAppointmentsUtil(db, clinicId);
+  const initialStatus = autoConfirm ? "confirmed" /* CONFIRMED */ : "pending" /* PENDING */;
+  const appointmentData = {
+    ...eventData,
+    clinicBranchId: clinicId,
+    practitionerProfileId: practitionerId,
+    patientProfileId: patientId,
+    eventType: "appointment" /* APPOINTMENT */,
+    status: eventData.status || initialStatus
+  };
+  const clinicPromise = createClinicCalendarEventUtil(
+    db,
+    clinicId,
+    appointmentData,
+    () => eventId
+    // Use the same ID for all calendars
+  );
+  const practitionerPromise = createPractitionerCalendarEventUtil(
+    db,
+    practitionerId,
+    appointmentData,
+    () => eventId
+    // Use the same ID for all calendars
+  );
+  const patientPromise = createPatientCalendarEventUtil(
+    db,
+    patientId,
+    appointmentData,
+    () => eventId
+    // Use the same ID for all calendars
+  );
+  const [clinicEvent] = await Promise.all([clinicPromise, practitionerPromise, patientPromise]);
+  return clinicEvent;
+}
+async function updateAppointmentUtil2(db, clinicId, practitionerId, patientId, eventId, updateData) {
+  const clinicPromise = updateClinicCalendarEventUtil(db, clinicId, eventId, updateData);
+  const practitionerPromise = updatePractitionerCalendarEventUtil(
+    db,
+    practitionerId,
+    eventId,
+    updateData
+  );
+  const patientPromise = updatePatientCalendarEventUtil(db, patientId, eventId, updateData);
+  const [clinicEvent] = await Promise.all([clinicPromise, practitionerPromise, patientPromise]);
+  return clinicEvent;
+}
 
 // src/services/calendar/utils/calendar-event.utils.ts
-var import_firestore29 = require("firebase/firestore");
+var import_firestore33 = require("firebase/firestore");
 async function searchCalendarEventsUtil(db, params) {
   const { searchLocation, entityId, ...filters } = params;
   let baseCollectionPath;
@@ -10291,88 +10507,2312 @@ async function searchCalendarEventsUtil(db, params) {
           "Practitioner ID (entityId) is required when searching practitioner calendar."
         );
       }
-      baseCollectionPath = `${PRACTITIONERS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
-      if (filters.practitionerId && filters.practitionerId !== entityId) {
-        console.warn(
-          `Provided practitionerId filter (${filters.practitionerId}) does not match search entityId (${entityId}). Returning empty results.`
-        );
-        return [];
+      baseCollectionPath = `${PRACTITIONERS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+      if (filters.practitionerId && filters.practitionerId !== entityId) {
+        console.warn(
+          `Provided practitionerId filter (${filters.practitionerId}) does not match search entityId (${entityId}). Returning empty results.`
+        );
+        return [];
+      }
+      filters.practitionerId = void 0;
+      break;
+    case "patient" /* PATIENT */:
+      if (!entityId) {
+        throw new Error(
+          "Patient ID (entityId) is required when searching patient calendar."
+        );
+      }
+      baseCollectionPath = `${PATIENTS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+      if (filters.patientId && filters.patientId !== entityId) {
+        console.warn(
+          `Provided patientId filter (${filters.patientId}) does not match search entityId (${entityId}). Returning empty results.`
+        );
+        return [];
+      }
+      filters.patientId = void 0;
+      break;
+    case "clinic" /* CLINIC */:
+      if (!entityId) {
+        throw new Error(
+          "Clinic ID (entityId) is required when searching clinic-related events."
+        );
+      }
+      baseCollectionPath = `${CLINICS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+      constraints.push((0, import_firestore33.where)("clinicBranchId", "==", entityId));
+      if (filters.clinicId && filters.clinicId !== entityId) {
+        console.warn(
+          `Provided clinicId filter (${filters.clinicId}) does not match search entityId (${entityId}). Returning empty results.`
+        );
+        return [];
+      }
+      filters.clinicId = void 0;
+      break;
+    default:
+      throw new Error(`Invalid search location: ${searchLocation}`);
+  }
+  const collectionRef = (0, import_firestore33.collection)(db, baseCollectionPath);
+  if (filters.clinicId) {
+    constraints.push((0, import_firestore33.where)("clinicBranchId", "==", filters.clinicId));
+  }
+  if (filters.practitionerId) {
+    constraints.push(
+      (0, import_firestore33.where)("practitionerProfileId", "==", filters.practitionerId)
+    );
+  }
+  if (filters.patientId) {
+    constraints.push((0, import_firestore33.where)("patientProfileId", "==", filters.patientId));
+  }
+  if (filters.procedureId) {
+    constraints.push((0, import_firestore33.where)("procedureId", "==", filters.procedureId));
+  }
+  if (filters.eventStatus) {
+    constraints.push((0, import_firestore33.where)("status", "==", filters.eventStatus));
+  }
+  if (filters.eventType) {
+    constraints.push((0, import_firestore33.where)("eventType", "==", filters.eventType));
+  }
+  if (filters.dateRange) {
+    constraints.push((0, import_firestore33.where)("eventTime.start", ">=", filters.dateRange.start));
+    constraints.push((0, import_firestore33.where)("eventTime.start", "<=", filters.dateRange.end));
+  }
+  try {
+    const finalQuery = (0, import_firestore33.query)(collectionRef, ...constraints);
+    const querySnapshot = await (0, import_firestore33.getDocs)(finalQuery);
+    const events = querySnapshot.docs.map(
+      (doc32) => ({ id: doc32.id, ...doc32.data() })
+    );
+    return events;
+  } catch (error) {
+    console.error("Error searching calendar events:", error);
+    return [];
+  }
+}
+
+// src/services/calendar/utils/synced-calendar.utils.ts
+var import_firestore34 = require("firebase/firestore");
+async function createPractitionerSyncedCalendarUtil(db, practitionerId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: (0, import_firestore34.serverTimestamp)(),
+    updatedAt: (0, import_firestore34.serverTimestamp)()
+  };
+  await (0, import_firestore34.setDoc)(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: import_firestore34.Timestamp.now(),
+    updatedAt: import_firestore34.Timestamp.now()
+  };
+}
+async function createPatientSyncedCalendarUtil(db, patientId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: (0, import_firestore34.serverTimestamp)(),
+    updatedAt: (0, import_firestore34.serverTimestamp)()
+  };
+  await (0, import_firestore34.setDoc)(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: import_firestore34.Timestamp.now(),
+    updatedAt: import_firestore34.Timestamp.now()
+  };
+}
+async function createClinicSyncedCalendarUtil(db, clinicId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: (0, import_firestore34.serverTimestamp)(),
+    updatedAt: (0, import_firestore34.serverTimestamp)()
+  };
+  await (0, import_firestore34.setDoc)(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: import_firestore34.Timestamp.now(),
+    updatedAt: import_firestore34.Timestamp.now()
+  };
+}
+async function getPractitionerSyncedCalendarUtil(db, practitionerId, calendarId) {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const calendarDoc = await (0, import_firestore34.getDoc)(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
+  const calendarsRef = (0, import_firestore34.collection)(
+    db,
+    `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = (0, import_firestore34.query)(calendarsRef, (0, import_firestore34.orderBy)("createdAt", "desc"));
+  const querySnapshot = await (0, import_firestore34.getDocs)(q);
+  return querySnapshot.docs.map((doc32) => doc32.data());
+}
+async function getPatientSyncedCalendarUtil(db, patientId, calendarId) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const calendarDoc = await (0, import_firestore34.getDoc)(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getPatientSyncedCalendarsUtil(db, patientId) {
+  const calendarsRef = (0, import_firestore34.collection)(
+    db,
+    `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = (0, import_firestore34.query)(calendarsRef, (0, import_firestore34.orderBy)("createdAt", "desc"));
+  const querySnapshot = await (0, import_firestore34.getDocs)(q);
+  return querySnapshot.docs.map((doc32) => doc32.data());
+}
+async function getClinicSyncedCalendarUtil(db, clinicId, calendarId) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const calendarDoc = await (0, import_firestore34.getDoc)(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getClinicSyncedCalendarsUtil(db, clinicId) {
+  const calendarsRef = (0, import_firestore34.collection)(
+    db,
+    `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = (0, import_firestore34.query)(calendarsRef, (0, import_firestore34.orderBy)("createdAt", "desc"));
+  const querySnapshot = await (0, import_firestore34.getDocs)(q);
+  return querySnapshot.docs.map((doc32) => doc32.data());
+}
+async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendarId, updateData) {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const updates = {
+    ...updateData,
+    updatedAt: (0, import_firestore34.serverTimestamp)()
+  };
+  await (0, import_firestore34.updateDoc)(calendarRef, updates);
+  const updatedDoc = await (0, import_firestore34.getDoc)(calendarRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+  return updatedDoc.data();
+}
+async function updatePatientSyncedCalendarUtil(db, patientId, calendarId, updateData) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const updates = {
+    ...updateData,
+    updatedAt: (0, import_firestore34.serverTimestamp)()
+  };
+  await (0, import_firestore34.updateDoc)(calendarRef, updates);
+  const updatedDoc = await (0, import_firestore34.getDoc)(calendarRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+  return updatedDoc.data();
+}
+async function updateClinicSyncedCalendarUtil(db, clinicId, calendarId, updateData) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const updates = {
+    ...updateData,
+    updatedAt: (0, import_firestore34.serverTimestamp)()
+  };
+  await (0, import_firestore34.updateDoc)(calendarRef, updates);
+  const updatedDoc = await (0, import_firestore34.getDoc)(calendarRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+  return updatedDoc.data();
+}
+async function deletePractitionerSyncedCalendarUtil(db, practitionerId, calendarId) {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  await (0, import_firestore34.deleteDoc)(calendarRef);
+}
+async function deletePatientSyncedCalendarUtil(db, patientId, calendarId) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  await (0, import_firestore34.deleteDoc)(calendarRef);
+}
+async function deleteClinicSyncedCalendarUtil(db, clinicId, calendarId) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  await (0, import_firestore34.deleteDoc)(calendarRef);
+}
+async function updateLastSyncedTimestampUtil(db, entityType, entityId, calendarId) {
+  const updateData = {
+    lastSyncedAt: import_firestore34.Timestamp.now()
+  };
+  switch (entityType) {
+    case "practitioner":
+      return updatePractitionerSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    case "patient":
+      return updatePatientSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    case "clinic":
+      return updateClinicSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    default:
+      throw new Error(`Invalid entity type: ${entityType}`);
+  }
+}
+
+// src/services/calendar/utils/google-calendar.utils.ts
+var import_firestore35 = require("firebase/firestore");
+var GOOGLE_CALENDAR_API_URL = "https://www.googleapis.com/calendar/v3";
+var GOOGLE_OAUTH_URL = "https://oauth2.googleapis.com/token";
+var CLIENT_ID = "your-client-id";
+var CLIENT_SECRET = "your-client-secret";
+var REDIRECT_URI = "your-redirect-uri";
+async function makeRequest(method, url, headers, data, params) {
+  const queryParams = params ? "?" + Object.entries(params).map(
+    ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+  ).join("&") : "";
+  const finalUrl = url + queryParams;
+  const options = {
+    method,
+    headers,
+    body: data ? JSON.stringify(data) : void 0
+  };
+  const response = await fetch(finalUrl, options);
+  if (!response.ok) {
+    const error = new Error(
+      `Request failed with status ${response.status}`
+    );
+    error.response = response;
+    throw error;
+  }
+  return response.json();
+}
+async function authenticateWithGoogleCalendarUtil(authCode) {
+  try {
+    const data = {
+      code: authCode,
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      redirect_uri: REDIRECT_URI,
+      grant_type: "authorization_code"
+    };
+    const response = await makeRequest(
+      "post",
+      GOOGLE_OAUTH_URL,
+      { "Content-Type": "application/json" },
+      data
+    );
+    return {
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token,
+      expiresIn: response.expires_in
+    };
+  } catch (error) {
+    const apiError = error;
+    console.error(
+      "Error authenticating with Google Calendar:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to authenticate with Google Calendar: ${apiError.message || "Unknown error"}`
+    );
+  }
+}
+async function refreshGoogleCalendarTokenUtil(refreshToken) {
+  try {
+    const data = {
+      refresh_token: refreshToken,
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      grant_type: "refresh_token"
+    };
+    const response = await makeRequest(
+      "post",
+      GOOGLE_OAUTH_URL,
+      { "Content-Type": "application/json" },
+      data
+    );
+    return {
+      accessToken: response.access_token,
+      expiresIn: response.expires_in
+    };
+  } catch (error) {
+    const apiError = error;
+    console.error(
+      "Error refreshing Google Calendar token:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to refresh Google Calendar token: ${apiError.message || "Unknown error"}`
+    );
+  }
+}
+async function listGoogleCalendarsUtil(accessToken) {
+  try {
+    const response = await makeRequest(
+      "get",
+      `${GOOGLE_CALENDAR_API_URL}/users/me/calendarList`,
+      { Authorization: `Bearer ${accessToken}` }
+    );
+    return response.items.map((calendar) => ({
+      id: calendar.id,
+      name: calendar.summary
+    }));
+  } catch (error) {
+    const apiError = error;
+    console.error(
+      "Error listing Google Calendars:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to list Google Calendars: ${apiError.message || "Unknown error"}`
+    );
+  }
+}
+async function ensureValidToken(db, entityType, entityId, syncedCalendar) {
+  const expiryTime = syncedCalendar.tokenExpiry.toDate();
+  const now = /* @__PURE__ */ new Date();
+  const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1e3);
+  if (expiryTime < fiveMinutesFromNow) {
+    const { accessToken, expiresIn } = await refreshGoogleCalendarTokenUtil(
+      syncedCalendar.refreshToken
+    );
+    const tokenExpiry = /* @__PURE__ */ new Date();
+    tokenExpiry.setSeconds(tokenExpiry.getSeconds() + expiresIn);
+    const updateData = {
+      accessToken,
+      tokenExpiry: import_firestore35.Timestamp.fromDate(tokenExpiry)
+    };
+    switch (entityType) {
+      case "practitioner":
+        await updatePractitionerSyncedCalendarUtil(
+          db,
+          entityId,
+          syncedCalendar.id,
+          updateData
+        );
+        break;
+      case "patient":
+        await updatePatientSyncedCalendarUtil(
+          db,
+          entityId,
+          syncedCalendar.id,
+          updateData
+        );
+        break;
+      case "clinic":
+        await updateClinicSyncedCalendarUtil(
+          db,
+          entityId,
+          syncedCalendar.id,
+          updateData
+        );
+        break;
+    }
+    return accessToken;
+  }
+  return syncedCalendar.accessToken;
+}
+async function syncEventsToGoogleCalendarUtil(db, entityType, entityId, syncedCalendar, events, existingSyncId) {
+  var _a, _b;
+  try {
+    const { accessToken } = await refreshGoogleCalendarTokenUtil(
+      syncedCalendar.refreshToken
+    );
+    let syncedCount = 0;
+    const errors = [];
+    const eventIds = [];
+    for (const event of events) {
+      try {
+        if (event.syncStatus === "external" /* EXTERNAL */) {
+          continue;
+        }
+        if (entityType === "practitioner" && event.status !== "confirmed" /* CONFIRMED */) {
+          continue;
+        }
+        if (entityType === "patient" && (event.status === "canceled" /* CANCELED */ || event.status === "rejected" /* REJECTED */)) {
+          continue;
+        }
+        if (entityType === "clinic") {
+          continue;
+        }
+        const googleEvent = convertCalendarEventToGoogleEventUtil(event);
+        const headers = {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        };
+        let responseId = "";
+        if (existingSyncId) {
+          const response = await makeRequest(
+            "put",
+            `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${existingSyncId}`,
+            headers,
+            googleEvent
+          );
+          responseId = response.id;
+        } else {
+          const existingSync = (_a = event.syncedCalendarEventId) == null ? void 0 : _a.find(
+            (sync) => sync.syncedCalendarProvider === "google" /* GOOGLE */ && // We should check if this is the same calendar we're syncing with, but that information isn't stored
+            // For now, we'll just use the first Google Calendar sync ID
+            sync.syncedCalendarProvider === syncedCalendar.provider
+          );
+          if (existingSync) {
+            const response = await makeRequest(
+              "put",
+              `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${existingSync.eventId}`,
+              headers,
+              googleEvent
+            );
+            responseId = response.id;
+          } else {
+            const response = await makeRequest(
+              "post",
+              `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events`,
+              headers,
+              googleEvent
+            );
+            responseId = response.id;
+          }
+        }
+        if (responseId) {
+          eventIds.push(responseId);
+          syncedCount++;
+        }
+      } catch (error) {
+        const apiError = error;
+        errors.push({
+          eventId: event.id,
+          error: apiError.message || "Unknown error",
+          status: (_b = apiError.response) == null ? void 0 : _b.status
+        });
+      }
+    }
+    await updateLastSyncedTimestampUtil(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar.id
+    );
+    return {
+      success: errors.length === 0,
+      syncedEvents: syncedCount,
+      errors,
+      eventIds
+    };
+  } catch (error) {
+    console.error("Error syncing with Google Calendar:", error);
+    return {
+      success: false,
+      syncedEvents: 0,
+      errors: [{ error: error.message || "Unknown error" }],
+      eventIds: []
+    };
+  }
+}
+async function fetchEventsFromGoogleCalendarUtil(db, entityType, entityId, syncedCalendar, startDate, endDate) {
+  try {
+    const accessToken = await ensureValidToken(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar
+    );
+    const timeMin = startDate.toISOString();
+    const timeMax = endDate.toISOString();
+    const response = await makeRequest(
+      "get",
+      `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events`,
+      { Authorization: `Bearer ${accessToken}` },
+      void 0,
+      {
+        timeMin,
+        timeMax,
+        singleEvents: "true",
+        orderBy: "startTime"
+      }
+    );
+    await updateLastSyncedTimestampUtil(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar.id
+    );
+    return response.items;
+  } catch (error) {
+    const apiError = error;
+    console.error(
+      "Error fetching events from Google Calendar:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to fetch events from Google Calendar: ${apiError.message || "Unknown error"}`
+    );
+  }
+}
+function convertGoogleEventToCalendarEventUtil(googleEvent, entityId, entityType) {
+  const start = googleEvent.start.dateTime ? new Date(googleEvent.start.dateTime) : new Date(googleEvent.start.date);
+  const end = googleEvent.end.dateTime ? new Date(googleEvent.end.dateTime) : new Date(googleEvent.end.date);
+  const calendarEvent = {
+    eventName: googleEvent.summary || "External Event",
+    eventLocation: googleEvent.location,
+    eventTime: {
+      start: import_firestore35.Timestamp.fromDate(start),
+      end: import_firestore35.Timestamp.fromDate(end)
+    },
+    description: googleEvent.description || "",
+    // External events are always set as CONFIRMED - status updates will happen externally
+    status: "confirmed" /* CONFIRMED */,
+    // All external events are marked as EXTERNAL to indicate they originated outside our system
+    syncStatus: "external" /* EXTERNAL */,
+    // All external events are treated as BLOCKING events
+    eventType: "blocking" /* BLOCKING */,
+    // Store the original Google Calendar event ID
+    syncedCalendarEventId: [
+      {
+        eventId: googleEvent.id,
+        syncedCalendarProvider: "google" /* GOOGLE */,
+        syncedAt: import_firestore35.Timestamp.now()
+      }
+    ]
+  };
+  switch (entityType) {
+    case "practitioner":
+      calendarEvent.practitionerProfileId = entityId;
+      break;
+    case "patient":
+      calendarEvent.patientProfileId = entityId;
+      break;
+    case "clinic":
+      calendarEvent.clinicBranchId = entityId;
+      break;
+  }
+  return calendarEvent;
+}
+function convertCalendarEventToGoogleEventUtil(calendarEvent) {
+  const googleEvent = {
+    summary: calendarEvent.eventName,
+    location: calendarEvent.eventLocation,
+    description: calendarEvent.description,
+    start: {
+      dateTime: calendarEvent.eventTime.start.toDate().toISOString(),
+      timeZone: "UTC"
+    },
+    end: {
+      dateTime: calendarEvent.eventTime.end.toDate().toISOString(),
+      timeZone: "UTC"
+    },
+    // Add reminders
+    reminders: {
+      useDefault: false,
+      overrides: [
+        { method: "email", minutes: 24 * 60 },
+        // 1 day before
+        { method: "popup", minutes: 30 }
+        // 30 minutes before
+      ]
+    }
+  };
+  switch (calendarEvent.status) {
+    case "confirmed" /* CONFIRMED */:
+      googleEvent.status = "confirmed";
+      break;
+    case "canceled" /* CANCELED */:
+      googleEvent.status = "cancelled";
+      break;
+    case "pending" /* PENDING */:
+      googleEvent.status = "tentative";
+      break;
+    default:
+      googleEvent.status = "confirmed";
+  }
+  if (calendarEvent.eventType === "appointment" /* APPOINTMENT */) {
+    googleEvent.attendees = [];
+    if (calendarEvent.practitionerProfileId) {
+      googleEvent.attendees.push({
+        email: "practitioner@example.com",
+        // This would be fetched from the practitioner profile
+        displayName: "Dr. Practitioner",
+        // This would be fetched from the practitioner profile
+        responseStatus: "accepted"
+      });
+    }
+    if (calendarEvent.patientProfileId) {
+      googleEvent.attendees.push({
+        email: "patient@example.com",
+        // This would be fetched from the patient profile
+        displayName: "Patient",
+        // This would be fetched from the patient profile
+        responseStatus: "needsAction"
+      });
+    }
+  }
+  return googleEvent;
+}
+async function deleteGoogleCalendarEventUtil(db, entityType, entityId, syncedCalendar, eventId) {
+  try {
+    const accessToken = await ensureValidToken(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar
+    );
+    await makeRequest(
+      "delete",
+      `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${eventId}`,
+      { Authorization: `Bearer ${accessToken}` }
+    );
+    return true;
+  } catch (error) {
+    const apiError = error;
+    console.error(
+      "Error deleting event from Google Calendar:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to delete event from Google Calendar: ${apiError.message || "Unknown error"}`
+    );
+  }
+}
+function getGoogleCalendarOAuthUrlUtil(scopes = ["https://www.googleapis.com/auth/calendar"]) {
+  const scopeString = encodeURIComponent(scopes.join(" "));
+  return `https://accounts.google.com/o/oauth2/v2/auth?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(
+    REDIRECT_URI
+  )}&response_type=code&scope=${scopeString}&access_type=offline&prompt=consent`;
+}
+
+// src/services/calendar/synced-calendars.service.ts
+var SyncedCalendarsService = class extends BaseService {
+  /**
+   * Creates a new SyncedCalendarsService instance
+   * @param db - Firestore instance
+   * @param auth - Firebase Auth instance
+   * @param app - Firebase App instance
+   */
+  constructor(db, auth, app) {
+    super(db, auth, app);
+  }
+  // ===== Practitioner Synced Calendars =====
+  /**
+   * Creates a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarData - Synced calendar data
+   * @returns Created synced calendar
+   */
+  async createPractitionerSyncedCalendar(practitionerId, calendarData) {
+    return createPractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarData,
+      this.generateId.bind(this)
+    );
+  }
+  /**
+   * Gets a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @returns Synced calendar or null if not found
+   */
+  async getPractitionerSyncedCalendar(practitionerId, calendarId) {
+    return getPractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarId
+    );
+  }
+  /**
+   * Gets all synced calendars for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @returns Array of synced calendars
+   */
+  async getPractitionerSyncedCalendars(practitionerId) {
+    return getPractitionerSyncedCalendarsUtil(this.db, practitionerId);
+  }
+  /**
+   * Updates a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param updateData - Data to update
+   * @returns Updated synced calendar
+   */
+  async updatePractitionerSyncedCalendar(practitionerId, calendarId, updateData) {
+    return updatePractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarId,
+      updateData
+    );
+  }
+  /**
+   * Deletes a synced calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   */
+  async deletePractitionerSyncedCalendar(practitionerId, calendarId) {
+    return deletePractitionerSyncedCalendarUtil(
+      this.db,
+      practitionerId,
+      calendarId
+    );
+  }
+  // ===== Patient Synced Calendars =====
+  /**
+   * Creates a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarData - Synced calendar data
+   * @returns Created synced calendar
+   */
+  async createPatientSyncedCalendar(patientId, calendarData) {
+    return createPatientSyncedCalendarUtil(
+      this.db,
+      patientId,
+      calendarData,
+      this.generateId.bind(this)
+    );
+  }
+  /**
+   * Gets a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @returns Synced calendar or null if not found
+   */
+  async getPatientSyncedCalendar(patientId, calendarId) {
+    return getPatientSyncedCalendarUtil(this.db, patientId, calendarId);
+  }
+  /**
+   * Gets all synced calendars for a patient
+   * @param patientId - ID of the patient
+   * @returns Array of synced calendars
+   */
+  async getPatientSyncedCalendars(patientId) {
+    return getPatientSyncedCalendarsUtil(this.db, patientId);
+  }
+  /**
+   * Updates a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param updateData - Data to update
+   * @returns Updated synced calendar
+   */
+  async updatePatientSyncedCalendar(patientId, calendarId, updateData) {
+    return updatePatientSyncedCalendarUtil(
+      this.db,
+      patientId,
+      calendarId,
+      updateData
+    );
+  }
+  /**
+   * Deletes a synced calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   */
+  async deletePatientSyncedCalendar(patientId, calendarId) {
+    return deletePatientSyncedCalendarUtil(this.db, patientId, calendarId);
+  }
+  // ===== Clinic Synced Calendars =====
+  /**
+   * Creates a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarData - Synced calendar data
+   * @returns Created synced calendar
+   */
+  async createClinicSyncedCalendar(clinicId, calendarData) {
+    return createClinicSyncedCalendarUtil(
+      this.db,
+      clinicId,
+      calendarData,
+      this.generateId.bind(this)
+    );
+  }
+  /**
+   * Gets a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @returns Synced calendar or null if not found
+   */
+  async getClinicSyncedCalendar(clinicId, calendarId) {
+    return getClinicSyncedCalendarUtil(this.db, clinicId, calendarId);
+  }
+  /**
+   * Gets all synced calendars for a clinic
+   * @param clinicId - ID of the clinic
+   * @returns Array of synced calendars
+   */
+  async getClinicSyncedCalendars(clinicId) {
+    return getClinicSyncedCalendarsUtil(this.db, clinicId);
+  }
+  /**
+   * Updates a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param updateData - Data to update
+   * @returns Updated synced calendar
+   */
+  async updateClinicSyncedCalendar(clinicId, calendarId, updateData) {
+    return updateClinicSyncedCalendarUtil(
+      this.db,
+      clinicId,
+      calendarId,
+      updateData
+    );
+  }
+  /**
+   * Deletes a synced calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   */
+  async deleteClinicSyncedCalendar(clinicId, calendarId) {
+    return deleteClinicSyncedCalendarUtil(this.db, clinicId, calendarId);
+  }
+  // ===== Google Calendar Integration =====
+  /**
+   * Gets the OAuth URL for Google Calendar
+   * @param scopes - OAuth scopes to request
+   * @returns OAuth URL
+   */
+  getGoogleCalendarOAuthUrl(scopes = ["https://www.googleapis.com/auth/calendar"]) {
+    return getGoogleCalendarOAuthUrlUtil(scopes);
+  }
+  /**
+   * Authenticates with Google Calendar using an authorization code
+   * @param authCode - Authorization code from Google OAuth
+   * @returns Access token, refresh token, and expiration time
+   */
+  async authenticateWithGoogleCalendar(authCode) {
+    return authenticateWithGoogleCalendarUtil(authCode);
+  }
+  /**
+   * Lists available Google Calendars for a user
+   * @param accessToken - Google API access token
+   * @returns List of available calendars
+   */
+  async listGoogleCalendars(accessToken) {
+    return listGoogleCalendarsUtil(accessToken);
+  }
+  /**
+   * Syncs events from our system to Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param events - Events to sync
+   * @param existingSyncId - Optional existing sync ID for updating an event
+   * @returns Result of the sync operation
+   */
+  async syncPractitionerEventsToGoogleCalendar(practitionerId, calendarId, events, existingSyncId) {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return syncEventsToGoogleCalendarUtil(
+      this.db,
+      "practitioner",
+      practitionerId,
+      syncedCalendar,
+      events,
+      existingSyncId
+    );
+  }
+  /**
+   * Syncs events from our system to Google Calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param events - Events to sync
+   * @param existingSyncId - Optional existing sync ID for updating an event
+   * @returns Result of the sync operation
+   */
+  async syncPatientEventsToGoogleCalendar(patientId, calendarId, events, existingSyncId) {
+    const syncedCalendar = await this.getPatientSyncedCalendar(
+      patientId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return syncEventsToGoogleCalendarUtil(
+      this.db,
+      "patient",
+      patientId,
+      syncedCalendar,
+      events,
+      existingSyncId
+    );
+  }
+  /**
+   * Syncs events from our system to Google Calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param events - Events to sync
+   * @returns Result of the sync operation
+   */
+  async syncClinicEventsToGoogleCalendar(clinicId, calendarId, events) {
+    const syncedCalendar = await this.getClinicSyncedCalendar(
+      clinicId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return syncEventsToGoogleCalendarUtil(
+      this.db,
+      "clinic",
+      clinicId,
+      syncedCalendar,
+      events
+    );
+  }
+  /**
+   * Fetches events from Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Events fetched from Google Calendar
+   */
+  async fetchEventsFromPractitionerGoogleCalendar(practitionerId, calendarId, startDate, endDate) {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return fetchEventsFromGoogleCalendarUtil(
+      this.db,
+      "practitioner",
+      practitionerId,
+      syncedCalendar,
+      startDate,
+      endDate
+    );
+  }
+  /**
+   * Fetches events from Google Calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Events fetched from Google Calendar
+   */
+  async fetchEventsFromPatientGoogleCalendar(patientId, calendarId, startDate, endDate) {
+    const syncedCalendar = await this.getPatientSyncedCalendar(
+      patientId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return fetchEventsFromGoogleCalendarUtil(
+      this.db,
+      "patient",
+      patientId,
+      syncedCalendar,
+      startDate,
+      endDate
+    );
+  }
+  /**
+   * Fetches events from Google Calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Events fetched from Google Calendar
+   */
+  async fetchEventsFromClinicGoogleCalendar(clinicId, calendarId, startDate, endDate) {
+    const syncedCalendar = await this.getClinicSyncedCalendar(
+      clinicId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return fetchEventsFromGoogleCalendarUtil(
+      this.db,
+      "clinic",
+      clinicId,
+      syncedCalendar,
+      startDate,
+      endDate
+    );
+  }
+  /**
+   * Deletes an event from Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns Success status
+   */
+  async deletePractitionerGoogleCalendarEvent(practitionerId, calendarId, eventId) {
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return deleteGoogleCalendarEventUtil(
+      this.db,
+      "practitioner",
+      practitionerId,
+      syncedCalendar,
+      eventId
+    );
+  }
+  /**
+   * Deletes an event from Google Calendar for a patient
+   * @param patientId - ID of the patient
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns Success status
+   */
+  async deletePatientGoogleCalendarEvent(patientId, calendarId, eventId) {
+    const syncedCalendar = await this.getPatientSyncedCalendar(
+      patientId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return deleteGoogleCalendarEventUtil(
+      this.db,
+      "patient",
+      patientId,
+      syncedCalendar,
+      eventId
+    );
+  }
+  /**
+   * Deletes an event from Google Calendar for a clinic
+   * @param clinicId - ID of the clinic
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns Success status
+   */
+  async deleteClinicGoogleCalendarEvent(clinicId, calendarId, eventId) {
+    const syncedCalendar = await this.getClinicSyncedCalendar(
+      clinicId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    return deleteGoogleCalendarEventUtil(
+      this.db,
+      "clinic",
+      clinicId,
+      syncedCalendar,
+      eventId
+    );
+  }
+  /**
+   * Converts Google Calendar events to our system's format for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param googleEvents - Google Calendar events
+   * @returns Converted calendar events
+   */
+  convertGoogleEventsToPractitionerEvents(practitionerId, googleEvents) {
+    return googleEvents.map(
+      (event) => convertGoogleEventToCalendarEventUtil(
+        event,
+        practitionerId,
+        "practitioner"
+      )
+    );
+  }
+  /**
+   * Converts Google Calendar events to our system's format for a patient
+   * @param patientId - ID of the patient
+   * @param googleEvents - Google Calendar events
+   * @returns Converted calendar events
+   */
+  convertGoogleEventsToPatientEvents(patientId, googleEvents) {
+    return googleEvents.map(
+      (event) => convertGoogleEventToCalendarEventUtil(event, patientId, "patient")
+    );
+  }
+  /**
+   * Converts Google Calendar events to our system's format for a clinic
+   * @param clinicId - ID of the clinic
+   * @param googleEvents - Google Calendar events
+   * @returns Converted calendar events
+   */
+  convertGoogleEventsToClinicEvents(clinicId, googleEvents) {
+    return googleEvents.map(
+      (event) => convertGoogleEventToCalendarEventUtil(event, clinicId, "clinic")
+    );
+  }
+  /**
+   * Fetches a single event from Google Calendar for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param calendarId - ID of the synced calendar
+   * @param eventId - ID of the event in Google Calendar
+   * @returns The event data or null if not found
+   */
+  async fetchEventFromPractitionerGoogleCalendar(practitionerId, calendarId, eventId) {
+    var _a;
+    const syncedCalendar = await this.getPractitionerSyncedCalendar(
+      practitionerId,
+      calendarId
+    );
+    if (!syncedCalendar) {
+      throw new Error("Synced calendar not found");
+    }
+    try {
+      const { accessToken } = await refreshGoogleCalendarTokenUtil(
+        syncedCalendar.refreshToken
+      );
+      const response = await makeRequest(
+        "get",
+        `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${eventId}`,
+        { Authorization: `Bearer ${accessToken}` }
+      );
+      await updateLastSyncedTimestampUtil(
+        this.db,
+        "practitioner",
+        practitionerId,
+        syncedCalendar.id
+      );
+      return response;
+    } catch (error) {
+      if (((_a = error.response) == null ? void 0 : _a.status) === 404) {
+        return null;
+      }
+      console.error(
+        `Error fetching event from Google Calendar: ${error.message}`
+      );
+      throw error;
+    }
+  }
+};
+
+// src/services/calendar/calendar.v2.service.ts
+var MIN_APPOINTMENT_DURATION = 15;
+var CalendarServiceV2 = class extends BaseService {
+  /**
+   * Creates a new CalendarService instance
+   * @param db - Firestore instance
+   * @param auth - Firebase Auth instance
+   * @param app - Firebase App instance
+   */
+  constructor(db, auth, app) {
+    super(db, auth, app);
+    this.syncedCalendarsService = new SyncedCalendarsService(db, auth, app);
+  }
+  // #region Public API Methods
+  /**
+   * Creates a new appointment with proper validation and scheduling rules
+   * @param params - Appointment creation parameters
+   * @returns Created calendar event
+   */
+  async createAppointment(params) {
+    await this.validateAppointmentParams(params);
+    await this.validateClinicWorkingHours(params.clinicId, params.eventTime);
+    await this.validateDoctorAvailability(
+      params.doctorId,
+      params.eventTime,
+      params.clinicId
+    );
+    const { clinicInfo, practitionerInfo, patientInfo } = await this.fetchProfileInfoCards(
+      params.clinicId,
+      params.doctorId,
+      params.patientId
+    );
+    const appointmentData = {
+      clinicBranchId: params.clinicId,
+      clinicBranchInfo: clinicInfo,
+      practitionerProfileId: params.doctorId,
+      practitionerProfileInfo: practitionerInfo,
+      patientProfileId: params.patientId,
+      patientProfileInfo: patientInfo,
+      procedureId: params.procedureId,
+      eventLocation: params.eventLocation,
+      eventName: "Appointment",
+      // TODO: Add procedure name when procedure model is available
+      eventTime: params.eventTime,
+      description: params.description || "",
+      status: "pending" /* PENDING */,
+      syncStatus: "internal" /* INTERNAL */,
+      eventType: "appointment" /* APPOINTMENT */
+    };
+    const appointment = await createAppointmentUtil2(
+      this.db,
+      params.clinicId,
+      params.doctorId,
+      params.patientId,
+      appointmentData,
+      this.generateId.bind(this)
+    );
+    await this.syncAppointmentWithExternalCalendars(appointment);
+    return appointment;
+  }
+  /**
+   * Updates an existing appointment
+   * @param params - Appointment update parameters
+   * @returns Updated calendar event
+   */
+  async updateAppointment(params) {
+    await this.validateUpdatePermissions(params);
+    const updateData = {
+      eventTime: params.eventTime,
+      description: params.description,
+      status: params.status
+    };
+    const appointment = await updateAppointmentUtil2(
+      this.db,
+      params.clinicId,
+      params.doctorId,
+      params.patientId,
+      params.appointmentId,
+      updateData
+    );
+    await this.syncAppointmentWithExternalCalendars(appointment);
+    return appointment;
+  }
+  /**
+   * Gets available appointment slots for a doctor at a clinic
+   * @param clinicId - ID of the clinic
+   * @param doctorId - ID of the doctor
+   * @param date - Date to check availability for
+   * @returns Array of available time slots
+   */
+  async getAvailableSlots(clinicId, doctorId, date) {
+    const workingHours = await this.getClinicWorkingHours(clinicId, date);
+    const doctorSchedule = await this.getDoctorSchedule(doctorId, date);
+    const existingAppointments = await this.getDoctorAppointments(
+      doctorId,
+      date
+    );
+    return this.calculateAvailableSlots(
+      workingHours,
+      doctorSchedule,
+      existingAppointments
+    );
+  }
+  /**
+   * Confirms an appointment
+   * @param appointmentId - ID of the appointment
+   * @param clinicId - ID of the clinic
+   * @returns Confirmed calendar event
+   */
+  async confirmAppointment(appointmentId, clinicId) {
+    return this.updateAppointmentStatus(
+      appointmentId,
+      clinicId,
+      "confirmed" /* CONFIRMED */
+    );
+  }
+  /**
+   * Rejects an appointment
+   * @param appointmentId - ID of the appointment
+   * @param clinicId - ID of the clinic
+   * @returns Rejected calendar event
+   */
+  async rejectAppointment(appointmentId, clinicId) {
+    return this.updateAppointmentStatus(
+      appointmentId,
+      clinicId,
+      "rejected" /* REJECTED */
+    );
+  }
+  /**
+   * Cancels an appointment
+   * @param appointmentId - ID of the appointment
+   * @param clinicId - ID of the clinic
+   * @returns Canceled calendar event
+   */
+  async cancelAppointment(appointmentId, clinicId) {
+    return this.updateAppointmentStatus(
+      appointmentId,
+      clinicId,
+      "canceled" /* CANCELED */
+    );
+  }
+  /**
+   * Imports events from external calendars
+   * @param entityType - Type of entity (practitioner or patient)
+   * @param entityId - ID of the entity
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Number of events imported
+   */
+  async importEventsFromExternalCalendars(entityType, entityId, startDate, endDate) {
+    if (entityType === "patient") {
+      return 0;
+    }
+    const syncedCalendars = await this.syncedCalendarsService.getPractitionerSyncedCalendars(
+      entityId
+    );
+    const activeCalendars = syncedCalendars.filter((cal) => cal.isActive);
+    if (activeCalendars.length === 0) {
+      return 0;
+    }
+    let importedEventsCount = 0;
+    const currentTime = import_firestore36.Timestamp.now();
+    for (const calendar of activeCalendars) {
+      try {
+        let externalEvents = [];
+        if (calendar.provider === "google" /* GOOGLE */) {
+          externalEvents = await this.syncedCalendarsService.fetchEventsFromPractitionerGoogleCalendar(
+            entityId,
+            calendar.id,
+            startDate,
+            endDate
+          );
+        }
+        for (const externalEvent of externalEvents) {
+          try {
+            const convertedEvent = this.syncedCalendarsService.convertGoogleEventsToPractitionerEvents(
+              entityId,
+              [externalEvent]
+            )[0];
+            if (!convertedEvent.eventTime) {
+              continue;
+            }
+            const eventData = {
+              // Ensure all required fields are set
+              eventName: convertedEvent.eventName || "External Event",
+              eventTime: convertedEvent.eventTime,
+              description: convertedEvent.description || "",
+              status: "confirmed" /* CONFIRMED */,
+              syncStatus: "external" /* EXTERNAL */,
+              eventType: "blocking" /* BLOCKING */,
+              practitionerProfileId: entityId,
+              syncedCalendarEventId: [
+                {
+                  eventId: externalEvent.id,
+                  syncedCalendarProvider: calendar.provider,
+                  syncedAt: currentTime
+                }
+              ]
+            };
+            const doctorEvent = await this.createDoctorBlockingEvent(
+              entityId,
+              eventData
+            );
+            if (doctorEvent) {
+              importedEventsCount++;
+            }
+          } catch (eventError) {
+            console.error("Error importing event:", eventError);
+          }
+        }
+      } catch (calendarError) {
+        console.error(
+          `Error fetching events from calendar ${calendar.id}:`,
+          calendarError
+        );
+      }
+    }
+    return importedEventsCount;
+  }
+  /**
+   * Creates a blocking event in a doctor's calendar
+   * @param doctorId - ID of the doctor
+   * @param eventData - Calendar event data
+   * @returns Created calendar event
+   */
+  async createDoctorBlockingEvent(doctorId, eventData) {
+    try {
+      const eventId = this.generateId();
+      const eventRef = (0, import_firestore37.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      const newEvent = {
+        id: eventId,
+        ...eventData,
+        createdAt: (0, import_firestore36.serverTimestamp)(),
+        updatedAt: (0, import_firestore36.serverTimestamp)()
+      };
+      await (0, import_firestore37.setDoc)(eventRef, newEvent);
+      return {
+        ...newEvent,
+        createdAt: import_firestore36.Timestamp.now(),
+        updatedAt: import_firestore36.Timestamp.now()
+      };
+    } catch (error) {
+      console.error(
+        `Error creating blocking event for doctor ${doctorId}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Periodically syncs events from external calendars for doctors
+   * This would be called via a scheduled Cloud Function
+   * @param lookbackDays - Number of days to look back for events
+   * @param lookforwardDays - Number of days to look forward for events
+   */
+  async synchronizeExternalCalendars(lookbackDays = 7, lookforwardDays = 30) {
+    try {
+      const practitionersRef = (0, import_firestore37.collection)(this.db, PRACTITIONERS_COLLECTION);
+      const practitionersSnapshot = await (0, import_firestore37.getDocs)(practitionersRef);
+      const startDate = /* @__PURE__ */ new Date();
+      startDate.setDate(startDate.getDate() - lookbackDays);
+      const endDate = /* @__PURE__ */ new Date();
+      endDate.setDate(endDate.getDate() + lookforwardDays);
+      const syncPromises = [];
+      for (const docSnapshot of practitionersSnapshot.docs) {
+        const practitionerId = docSnapshot.id;
+        syncPromises.push(
+          this.importEventsFromExternalCalendars(
+            "doctor",
+            practitionerId,
+            startDate,
+            endDate
+          ).then((count) => {
+            console.log(
+              `Imported ${count} events for doctor ${practitionerId}`
+            );
+          }).catch((error) => {
+            console.error(
+              `Error importing events for doctor ${practitionerId}:`,
+              error
+            );
+          })
+        );
+        syncPromises.push(
+          this.updateExistingEventsFromExternalCalendars(
+            practitionerId,
+            startDate,
+            endDate
+          ).then((count) => {
+            console.log(
+              `Updated ${count} events for doctor ${practitionerId}`
+            );
+          }).catch((error) => {
+            console.error(
+              `Error updating events for doctor ${practitionerId}:`,
+              error
+            );
+          })
+        );
+      }
+      await Promise.all(syncPromises);
+      console.log("Completed external calendar synchronization");
+    } catch (error) {
+      console.error("Error synchronizing external calendars:", error);
+    }
+  }
+  /**
+   * Updates existing events that were synced from external calendars
+   * @param doctorId - ID of the doctor
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Number of events updated
+   */
+  async updateExistingEventsFromExternalCalendars(doctorId, startDate, endDate) {
+    var _a;
+    try {
+      const eventsRef = (0, import_firestore37.collection)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION
+      );
+      const q = (0, import_firestore37.query)(
+        eventsRef,
+        (0, import_firestore37.where)("syncStatus", "==", "external" /* EXTERNAL */),
+        (0, import_firestore37.where)("eventTime.start", ">=", import_firestore36.Timestamp.fromDate(startDate)),
+        (0, import_firestore37.where)("eventTime.start", "<=", import_firestore36.Timestamp.fromDate(endDate))
+      );
+      const eventsSnapshot = await (0, import_firestore37.getDocs)(q);
+      const events = eventsSnapshot.docs.map((doc32) => ({
+        id: doc32.id,
+        ...doc32.data()
+      }));
+      const calendars = await this.syncedCalendarsService.getPractitionerSyncedCalendars(
+        doctorId
+      );
+      const activeCalendars = calendars.filter((cal) => cal.isActive);
+      if (activeCalendars.length === 0 || events.length === 0) {
+        return 0;
+      }
+      let updatedCount = 0;
+      for (const event of events) {
+        if (!((_a = event.syncedCalendarEventId) == null ? void 0 : _a.length)) continue;
+        for (const syncId of event.syncedCalendarEventId) {
+          const calendar = activeCalendars.find(
+            (cal) => cal.provider === syncId.syncedCalendarProvider
+          );
+          if (!calendar) continue;
+          if (syncId.syncedCalendarProvider === "google" /* GOOGLE */) {
+            try {
+              const externalEvent = await this.fetchExternalEvent(
+                doctorId,
+                calendar,
+                syncId.eventId
+              );
+              if (externalEvent) {
+                const externalStartTime = new Date(
+                  externalEvent.start.dateTime || externalEvent.start.date
+                ).getTime();
+                const externalEndTime = new Date(
+                  externalEvent.end.dateTime || externalEvent.end.date
+                ).getTime();
+                const localStartTime = event.eventTime.start.toDate().getTime();
+                const localEndTime = event.eventTime.end.toDate().getTime();
+                if (externalStartTime !== localStartTime || externalEndTime !== localEndTime || externalEvent.summary !== event.eventName || externalEvent.description !== event.description) {
+                  await this.updateLocalEventFromExternal(
+                    doctorId,
+                    event.id,
+                    externalEvent
+                  );
+                  updatedCount++;
+                }
+              } else {
+                await this.updateEventStatus(
+                  doctorId,
+                  event.id,
+                  "canceled" /* CANCELED */
+                );
+                updatedCount++;
+              }
+            } catch (error) {
+              console.error(
+                `Error updating external event ${event.id}:`,
+                error
+              );
+            }
+          }
+        }
+      }
+      return updatedCount;
+    } catch (error) {
+      console.error(
+        "Error updating existing events from external calendars:",
+        error
+      );
+      return 0;
+    }
+  }
+  /**
+   * Fetches a single external event from Google Calendar
+   * @param doctorId - ID of the doctor
+   * @param calendar - Calendar information
+   * @param externalEventId - ID of the external event
+   * @returns External event data or null if not found
+   */
+  async fetchExternalEvent(doctorId, calendar, externalEventId) {
+    try {
+      if (calendar.provider === "google" /* GOOGLE */) {
+        const result = await this.syncedCalendarsService.fetchEventFromPractitionerGoogleCalendar(
+          doctorId,
+          calendar.id,
+          externalEventId
+        );
+        return result;
+      }
+      return null;
+    } catch (error) {
+      console.error(`Error fetching external event ${externalEventId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Updates a local event with data from an external event
+   * @param doctorId - ID of the doctor
+   * @param eventId - ID of the local event
+   * @param externalEvent - External event data
+   */
+  async updateLocalEventFromExternal(doctorId, eventId, externalEvent) {
+    try {
+      const startTime = new Date(
+        externalEvent.start.dateTime || externalEvent.start.date
+      );
+      const endTime = new Date(
+        externalEvent.end.dateTime || externalEvent.end.date
+      );
+      const eventRef = (0, import_firestore37.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      await (0, import_firestore37.updateDoc)(eventRef, {
+        eventName: externalEvent.summary || "External Event",
+        eventTime: {
+          start: import_firestore36.Timestamp.fromDate(startTime),
+          end: import_firestore36.Timestamp.fromDate(endTime)
+        },
+        description: externalEvent.description || "",
+        updatedAt: (0, import_firestore36.serverTimestamp)()
+      });
+      console.log(`Updated local event ${eventId} from external event`);
+    } catch (error) {
+      console.error(
+        `Error updating local event ${eventId} from external:`,
+        error
+      );
+    }
+  }
+  /**
+   * Updates an event's status
+   * @param doctorId - ID of the doctor
+   * @param eventId - ID of the event
+   * @param status - New status
+   */
+  async updateEventStatus(doctorId, eventId, status) {
+    try {
+      const eventRef = (0, import_firestore37.doc)(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      await (0, import_firestore37.updateDoc)(eventRef, {
+        status,
+        updatedAt: (0, import_firestore36.serverTimestamp)()
+      });
+      console.log(`Updated event ${eventId} status to ${status}`);
+    } catch (error) {
+      console.error(`Error updating event ${eventId} status:`, error);
+    }
+  }
+  /**
+   * Creates a scheduled job to periodically sync external calendars
+   * Note: This would be implemented using Cloud Functions in a real application
+   * This is a sample implementation to show how it could be set up
+   * @param interval - Interval in hours
+   */
+  createScheduledSyncJob(interval = 3) {
+    console.log(
+      `Setting up scheduled calendar sync job every ${interval} hours`
+    );
+  }
+  /**
+   * Searches for calendar events based on specified criteria.
+   *
+   * @param {SearchCalendarEventsParams} params - The search parameters.
+   * @param {SearchLocationEnum} params.searchLocation - The primary location to search (practitioner, patient, or clinic).
+   * @param {string} params.entityId - The ID of the entity (practitioner, patient, or clinic) to search within/for.
+   * @param {string} [params.clinicId] - Optional clinic ID to filter by.
+   * @param {string} [params.practitionerId] - Optional practitioner ID to filter by.
+   * @param {string} [params.patientId] - Optional patient ID to filter by.
+   * @param {string} [params.procedureId] - Optional procedure ID to filter by.
+   * @param {DateRange} [params.dateRange] - Optional date range to filter by (event start time).
+   * @param {CalendarEventStatus} [params.eventStatus] - Optional event status to filter by.
+   * @param {CalendarEventType} [params.eventType] - Optional event type to filter by.
+   * @returns {Promise<CalendarEvent[]>} A promise that resolves to an array of matching calendar events.
+   * @throws {Error} If the search location requires an entity ID that is not provided.
+   */
+  async searchCalendarEvents(params) {
+    return searchCalendarEventsUtil(this.db, params);
+  }
+  /**
+   * Gets a doctor's upcoming appointments for a specific date range
+   *
+   * @param {string} doctorId - ID of the practitioner
+   * @param {Date} startDate - Start date of the range
+   * @param {Date} endDate - End date of the range
+   * @param {CalendarEventStatus} [status] - Optional status filter (defaults to CONFIRMED)
+   * @returns {Promise<CalendarEvent[]>} A promise that resolves to an array of appointments
+   */
+  async getPractitionerUpcomingAppointments(doctorId, startDate, endDate, status = "confirmed" /* CONFIRMED */) {
+    const dateRange = {
+      start: import_firestore36.Timestamp.fromDate(startDate),
+      end: import_firestore36.Timestamp.fromDate(endDate)
+    };
+    const searchParams = {
+      searchLocation: "practitioner" /* PRACTITIONER */,
+      entityId: doctorId,
+      dateRange,
+      eventStatus: status,
+      eventType: "appointment" /* APPOINTMENT */
+    };
+    return this.searchCalendarEvents(searchParams);
+  }
+  /**
+   * Gets a patient's appointments for a specific date range
+   *
+   * @param {string} patientId - ID of the patient
+   * @param {Date} startDate - Start date of the range
+   * @param {Date} endDate - End date of the range
+   * @param {CalendarEventStatus} [status] - Optional status filter (defaults to all non-canceled appointments)
+   * @returns {Promise<CalendarEvent[]>} A promise that resolves to an array of appointments
+   */
+  async getPatientAppointments(patientId, startDate, endDate, status) {
+    const dateRange = {
+      start: import_firestore36.Timestamp.fromDate(startDate),
+      end: import_firestore36.Timestamp.fromDate(endDate)
+    };
+    const searchParams = {
+      searchLocation: "patient" /* PATIENT */,
+      entityId: patientId,
+      dateRange,
+      eventType: "appointment" /* APPOINTMENT */
+    };
+    if (status) {
+      searchParams.eventStatus = status;
+    }
+    return this.searchCalendarEvents(searchParams);
+  }
+  /**
+   * Gets all appointments for a clinic within a specific date range
+   *
+   * @param {string} clinicId - ID of the clinic
+   * @param {Date} startDate - Start date of the range
+   * @param {Date} endDate - End date of the range
+   * @param {string} [doctorId] - Optional doctor ID to filter by
+   * @param {CalendarEventStatus} [status] - Optional status filter
+   * @returns {Promise<CalendarEvent[]>} A promise that resolves to an array of appointments
+   */
+  async getClinicAppointments(clinicId, startDate, endDate, doctorId, status) {
+    const dateRange = {
+      start: import_firestore36.Timestamp.fromDate(startDate),
+      end: import_firestore36.Timestamp.fromDate(endDate)
+    };
+    const searchParams = {
+      searchLocation: "clinic" /* CLINIC */,
+      entityId: clinicId,
+      dateRange,
+      eventType: "appointment" /* APPOINTMENT */
+    };
+    if (doctorId) {
+      searchParams.practitionerId = doctorId;
+    }
+    if (status) {
+      searchParams.eventStatus = status;
+    }
+    return this.searchCalendarEvents(searchParams);
+  }
+  // #endregion
+  // #region Private Helper Methods
+  /**
+   * Validates appointment creation parameters
+   * @param params - Appointment parameters to validate
+   * @throws Error if validation fails
+   */
+  async validateAppointmentParams(params) {
+    await createAppointmentSchema.parseAsync(params);
+  }
+  /**
+   * Validates if the event time falls within clinic working hours
+   * @param clinicId - ID of the clinic
+   * @param eventTime - Event time to validate
+   * @throws Error if validation fails
+   */
+  async validateClinicWorkingHours(clinicId, eventTime) {
+    const startDate = eventTime.start.toDate();
+    const workingHours = await this.getClinicWorkingHours(clinicId, startDate);
+    if (workingHours.length === 0) {
+      throw new Error("Clinic is not open on this day");
+    }
+    const startTime = startDate;
+    const endTime = eventTime.end.toDate();
+    const isWithinWorkingHours = workingHours.some((slot) => {
+      return slot.start <= startTime && slot.end >= endTime && slot.isAvailable;
+    });
+    if (!isWithinWorkingHours) {
+      throw new Error("Appointment time is outside clinic working hours");
+    }
+  }
+  /**
+   * Validates if the doctor is available during the event time
+   * @param doctorId - ID of the doctor
+   * @param eventTime - Event time to validate
+   * @param clinicId - ID of the clinic where the appointment is being booked
+   * @throws Error if validation fails
+   */
+  async validateDoctorAvailability(doctorId, eventTime, clinicId) {
+    var _a;
+    const startDate = eventTime.start.toDate();
+    const startTime = startDate;
+    const endTime = eventTime.end.toDate();
+    const practitionerRef = (0, import_firestore37.doc)(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await (0, import_firestore37.getDoc)(practitionerRef);
+    if (!practitionerDoc.exists()) {
+      throw new Error(`Doctor with ID ${doctorId} not found`);
+    }
+    const practitioner = practitionerDoc.data();
+    if (!practitioner.clinics.includes(clinicId)) {
+      throw new Error("Doctor does not work at this clinic");
+    }
+    const clinicWorkingHours = (_a = practitioner.clinicWorkingHours) == null ? void 0 : _a.find(
+      (hours) => hours.clinicId === clinicId && hours.isActive
+    );
+    if (!clinicWorkingHours) {
+      throw new Error("Doctor does not have working hours set for this clinic");
+    }
+    const dayOfWeek = startDate.getDay();
+    const dayKey = [
+      "sunday",
+      "monday",
+      "tuesday",
+      "wednesday",
+      "thursday",
+      "friday",
+      "saturday"
+    ][dayOfWeek];
+    const daySchedule = clinicWorkingHours.workingHours[dayKey];
+    if (!daySchedule) {
+      throw new Error("Doctor is not working on this day at this clinic");
+    }
+    const [startHour, startMinute] = daySchedule.start.split(":").map(Number);
+    const [endHour, endMinute] = daySchedule.end.split(":").map(Number);
+    const scheduleStart = new Date(startDate);
+    scheduleStart.setHours(startHour, startMinute, 0, 0);
+    const scheduleEnd = new Date(startDate);
+    scheduleEnd.setHours(endHour, endMinute, 0, 0);
+    if (startTime < scheduleStart || endTime > scheduleEnd) {
+      throw new Error(
+        "Appointment time is outside doctor's working hours at this clinic"
+      );
+    }
+    const appointments = await this.getDoctorAppointments(doctorId, startDate);
+    const hasOverlap = appointments.some((appointment) => {
+      const appointmentStart = appointment.eventTime.start.toDate();
+      const appointmentEnd = appointment.eventTime.end.toDate();
+      return startTime >= appointmentStart && startTime < appointmentEnd || endTime > appointmentStart && endTime <= appointmentEnd || startTime <= appointmentStart && endTime >= appointmentEnd;
+    });
+    if (hasOverlap) {
+      throw new Error("Doctor has another appointment during this time");
+    }
+  }
+  /**
+   * Updates appointment status
+   * @param appointmentId - ID of the appointment
+   * @param clinicId - ID of the clinic
+   * @param status - New status
+   * @returns Updated calendar event
+   */
+  async updateAppointmentStatus(appointmentId, clinicId, status) {
+    const baseCollectionPath = `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}`;
+    const appointmentRef = (0, import_firestore37.doc)(this.db, baseCollectionPath, appointmentId);
+    const appointmentDoc = await (0, import_firestore37.getDoc)(appointmentRef);
+    if (!appointmentDoc.exists()) {
+      throw new Error(`Appointment with ID ${appointmentId} not found`);
+    }
+    const appointment = appointmentDoc.data();
+    if (appointment.clinicBranchId !== clinicId) {
+      throw new Error("Appointment does not belong to the specified clinic");
+    }
+    this.validateStatusTransition(appointment.status, status);
+    const updateParams = {
+      appointmentId,
+      clinicId,
+      eventTime: appointment.eventTime,
+      description: appointment.description || "",
+      doctorId: appointment.practitionerProfileId || "",
+      patientId: appointment.patientProfileId || "",
+      status
+    };
+    await this.validateUpdatePermissions(updateParams);
+    return this.updateAppointment(updateParams);
+  }
+  /**
+   * Validates status transition
+   * @param currentStatus - Current status
+   * @param newStatus - New status
+   * @throws Error if transition is invalid
+   */
+  validateStatusTransition(currentStatus, newStatus) {
+    const validTransitions = {
+      ["pending" /* PENDING */]: [
+        "confirmed" /* CONFIRMED */,
+        "rejected" /* REJECTED */,
+        "canceled" /* CANCELED */
+      ],
+      ["confirmed" /* CONFIRMED */]: [
+        "canceled" /* CANCELED */,
+        "completed" /* COMPLETED */,
+        "rescheduled" /* RESCHEDULED */,
+        "no_show" /* NO_SHOW */
+      ],
+      ["rejected" /* REJECTED */]: [],
+      ["canceled" /* CANCELED */]: [],
+      ["rescheduled" /* RESCHEDULED */]: [
+        "confirmed" /* CONFIRMED */,
+        "canceled" /* CANCELED */
+      ],
+      ["completed" /* COMPLETED */]: [],
+      ["no_show" /* NO_SHOW */]: []
+    };
+    if (!validTransitions[currentStatus].includes(newStatus)) {
+      throw new Error(
+        `Invalid status transition from ${currentStatus} to ${newStatus}`
+      );
+    }
+  }
+  /**
+   * Syncs appointment with external calendars based on entity type and status
+   * @param appointment - Calendar event to sync
+   */
+  async syncAppointmentWithExternalCalendars(appointment) {
+    if (!appointment.practitionerProfileId || !appointment.patientProfileId) {
+      return;
+    }
+    try {
+      const [doctorCalendars, patientCalendars] = await Promise.all([
+        this.syncedCalendarsService.getPractitionerSyncedCalendars(
+          appointment.practitionerProfileId
+        ),
+        this.syncedCalendarsService.getPatientSyncedCalendars(
+          appointment.patientProfileId
+        )
+      ]);
+      const activeDoctorCalendars = doctorCalendars.filter(
+        (cal) => cal.isActive
+      );
+      const activePatientCalendars = patientCalendars.filter(
+        (cal) => cal.isActive
+      );
+      if (activeDoctorCalendars.length === 0 && activePatientCalendars.length === 0) {
+        return;
+      }
+      if (appointment.syncStatus !== "internal" /* INTERNAL */) {
+        return;
       }
-      filters.practitionerId = void 0;
-      break;
-    case "patient" /* PATIENT */:
-      if (!entityId) {
-        throw new Error(
-          "Patient ID (entityId) is required when searching patient calendar."
+      if (appointment.status === "confirmed" /* CONFIRMED */ && activeDoctorCalendars.length > 0) {
+        await Promise.all(
+          activeDoctorCalendars.map(
+            (calendar) => this.syncEventToExternalCalendar(appointment, calendar, "doctor")
+          )
         );
       }
-      baseCollectionPath = `${PATIENTS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
-      if (filters.patientId && filters.patientId !== entityId) {
-        console.warn(
-          `Provided patientId filter (${filters.patientId}) does not match search entityId (${entityId}). Returning empty results.`
+      if (appointment.status !== "canceled" /* CANCELED */ && appointment.status !== "rejected" /* REJECTED */ && activePatientCalendars.length > 0) {
+        await Promise.all(
+          activePatientCalendars.map(
+            (calendar) => this.syncEventToExternalCalendar(appointment, calendar, "patient")
+          )
         );
-        return [];
       }
-      filters.patientId = void 0;
-      break;
-    case "clinic" /* CLINIC */:
-      if (!entityId) {
-        throw new Error(
-          "Clinic ID (entityId) is required when searching clinic-related events."
-        );
+    } catch (error) {
+      console.error("Error syncing with external calendars:", error);
+    }
+  }
+  /**
+   * Syncs a single event to an external calendar
+   * @param appointment - Calendar event to sync
+   * @param calendar - External calendar to sync with
+   * @param entityType - Type of entity owning the calendar
+   */
+  async syncEventToExternalCalendar(appointment, calendar, entityType) {
+    var _a, _b, _c, _d, _e;
+    try {
+      const eventToSync = { ...appointment };
+      let eventTitle = appointment.eventName;
+      const clinicName = ((_a = appointment.clinicBranchInfo) == null ? void 0 : _a.name) || "Clinic";
+      if (entityType === "patient") {
+        eventTitle = `[${appointment.status}] ${eventTitle} @ ${clinicName}`;
+      } else {
+        eventTitle = `${eventTitle} - Patient: ${((_b = appointment.patientProfileInfo) == null ? void 0 : _b.fullName) || "Unknown"} @ ${clinicName}`;
       }
-      baseCollectionPath = `${CLINICS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
-      constraints.push((0, import_firestore29.where)("clinicBranchId", "==", entityId));
-      if (filters.clinicId && filters.clinicId !== entityId) {
-        console.warn(
-          `Provided clinicId filter (${filters.clinicId}) does not match search entityId (${entityId}). Returning empty results.`
+      eventToSync.eventName = eventTitle;
+      const existingSyncId = (_d = (_c = appointment.syncedCalendarEventId) == null ? void 0 : _c.find(
+        (sync) => sync.syncedCalendarProvider === calendar.provider
+      )) == null ? void 0 : _d.eventId;
+      if (calendar.provider === "google" /* GOOGLE */) {
+        const result = await this.syncedCalendarsService.syncPractitionerEventsToGoogleCalendar(
+          entityType === "doctor" ? appointment.practitionerProfileId : appointment.patientProfileId,
+          calendar.id,
+          [eventToSync],
+          existingSyncId
+          // Pass existing sync ID if we have one
         );
-        return [];
+        if (result.success && ((_e = result.eventIds) == null ? void 0 : _e.length) && !existingSyncId) {
+          const newSyncEvent = {
+            eventId: result.eventIds[0],
+            syncedCalendarProvider: calendar.provider,
+            syncedAt: import_firestore36.Timestamp.now()
+          };
+          await this.updateEventWithSyncId(
+            entityType === "doctor" ? appointment.practitionerProfileId : appointment.patientProfileId,
+            entityType,
+            appointment.id,
+            newSyncEvent
+          );
+        }
       }
-      filters.clinicId = void 0;
-      break;
-    default:
-      throw new Error(`Invalid search location: ${searchLocation}`);
-  }
-  const collectionRef = (0, import_firestore29.collection)(db, baseCollectionPath);
-  if (filters.clinicId) {
-    constraints.push((0, import_firestore29.where)("clinicBranchId", "==", filters.clinicId));
+    } catch (error) {
+      console.error(`Error syncing with ${entityType}'s calendar:`, error);
+    }
   }
-  if (filters.practitionerId) {
-    constraints.push(
-      (0, import_firestore29.where)("practitionerProfileId", "==", filters.practitionerId)
-    );
+  /**
+   * Updates an event with a new sync ID
+   * @param entityId - ID of the entity (doctor or patient)
+   * @param entityType - Type of entity
+   * @param eventId - ID of the event
+   * @param syncEvent - Sync event information
+   */
+  async updateEventWithSyncId(entityId, entityType, eventId, syncEvent) {
+    try {
+      const collectionPath = entityType === "doctor" ? `${PRACTITIONERS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}` : `${PATIENTS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+      const eventRef = (0, import_firestore37.doc)(this.db, collectionPath, eventId);
+      const eventDoc = await (0, import_firestore37.getDoc)(eventRef);
+      if (eventDoc.exists()) {
+        const event = eventDoc.data();
+        const syncIds = [...event.syncedCalendarEventId || []];
+        const existingSyncIndex = syncIds.findIndex(
+          (sync) => sync.syncedCalendarProvider === syncEvent.syncedCalendarProvider
+        );
+        if (existingSyncIndex >= 0) {
+          syncIds[existingSyncIndex] = syncEvent;
+        } else {
+          syncIds.push(syncEvent);
+        }
+        await (0, import_firestore37.updateDoc)(eventRef, {
+          syncedCalendarEventId: syncIds,
+          updatedAt: (0, import_firestore36.serverTimestamp)()
+        });
+        console.log(
+          `Updated event ${eventId} with sync ID ${syncEvent.eventId}`
+        );
+      }
+    } catch (error) {
+      console.error("Error updating event with sync ID:", error);
+    }
   }
-  if (filters.patientId) {
-    constraints.push((0, import_firestore29.where)("patientProfileId", "==", filters.patientId));
+  /**
+   * Validates update permissions and parameters
+   * @param params - Update parameters to validate
+   */
+  async validateUpdatePermissions(params) {
+    await updateAppointmentSchema.parseAsync(params);
   }
-  if (filters.procedureId) {
-    constraints.push((0, import_firestore29.where)("procedureId", "==", filters.procedureId));
+  /**
+   * Gets clinic working hours for a specific date
+   * @param clinicId - ID of the clinic
+   * @param date - Date to get working hours for
+   * @returns Working hours for the clinic
+   */
+  async getClinicWorkingHours(clinicId, date) {
+    const clinicRef = (0, import_firestore37.doc)(this.db, CLINICS_COLLECTION, clinicId);
+    const clinicDoc = await (0, import_firestore37.getDoc)(clinicRef);
+    if (!clinicDoc.exists()) {
+      throw new Error(`Clinic with ID ${clinicId} not found`);
+    }
+    const workingHours = [];
+    const dayOfWeek = date.getDay();
+    if (dayOfWeek === 0 || dayOfWeek === 6) {
+      return workingHours;
+    }
+    const workingDate = new Date(date);
+    workingDate.setHours(9, 0, 0, 0);
+    const startTime = new Date(workingDate);
+    workingDate.setHours(17, 0, 0, 0);
+    const endTime = new Date(workingDate);
+    workingHours.push({
+      start: startTime,
+      end: endTime,
+      isAvailable: true
+    });
+    return workingHours;
   }
-  if (filters.eventStatus) {
-    constraints.push((0, import_firestore29.where)("status", "==", filters.eventStatus));
+  /**
+   * Gets doctor's schedule for a specific date
+   * @param doctorId - ID of the doctor
+   * @param date - Date to get schedule for
+   * @returns Doctor's schedule
+   */
+  async getDoctorSchedule(doctorId, date) {
+    const practitionerRef = (0, import_firestore37.doc)(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await (0, import_firestore37.getDoc)(practitionerRef);
+    if (!practitionerDoc.exists()) {
+      throw new Error(`Doctor with ID ${doctorId} not found`);
+    }
+    const schedule = [];
+    const dayOfWeek = date.getDay();
+    if (dayOfWeek === 0 || dayOfWeek === 6) {
+      return schedule;
+    }
+    const scheduleDate = new Date(date);
+    scheduleDate.setHours(9, 0, 0, 0);
+    const startTime = new Date(scheduleDate);
+    scheduleDate.setHours(17, 0, 0, 0);
+    const endTime = new Date(scheduleDate);
+    schedule.push({
+      start: startTime,
+      end: endTime,
+      isAvailable: true
+    });
+    return schedule;
   }
-  if (filters.eventType) {
-    constraints.push((0, import_firestore29.where)("eventType", "==", filters.eventType));
+  /**
+   * Gets doctor's appointments for a specific date
+   * @param doctorId - ID of the doctor
+   * @param date - Date to get appointments for
+   * @returns Array of calendar events
+   */
+  async getDoctorAppointments(doctorId, date) {
+    const startOfDay = new Date(date);
+    startOfDay.setHours(0, 0, 0, 0);
+    const endOfDay = new Date(date);
+    endOfDay.setHours(23, 59, 59, 999);
+    const appointmentsRef = (0, import_firestore37.collection)(this.db, CALENDAR_COLLECTION);
+    const q = (0, import_firestore37.query)(
+      appointmentsRef,
+      (0, import_firestore37.where)("practitionerProfileId", "==", doctorId),
+      (0, import_firestore37.where)("eventTime.start", ">=", import_firestore36.Timestamp.fromDate(startOfDay)),
+      (0, import_firestore37.where)("eventTime.start", "<=", import_firestore36.Timestamp.fromDate(endOfDay)),
+      (0, import_firestore37.where)("status", "in", [
+        "confirmed" /* CONFIRMED */,
+        "pending" /* PENDING */
+      ])
+    );
+    const querySnapshot = await (0, import_firestore37.getDocs)(q);
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
-  if (filters.dateRange) {
-    constraints.push((0, import_firestore29.where)("eventTime.start", ">=", filters.dateRange.start));
-    constraints.push((0, import_firestore29.where)("eventTime.start", "<=", filters.dateRange.end));
+  /**
+   * Calculates available time slots based on working hours, schedule and existing appointments
+   * @param workingHours - Clinic working hours
+   * @param doctorSchedule - Doctor's schedule
+   * @param existingAppointments - Existing appointments
+   * @returns Array of available time slots
+   */
+  calculateAvailableSlots(workingHours, doctorSchedule, existingAppointments) {
+    const availableSlots = [];
+    for (const workingHour of workingHours) {
+      for (const scheduleSlot of doctorSchedule) {
+        const overlapStart = new Date(
+          Math.max(workingHour.start.getTime(), scheduleSlot.start.getTime())
+        );
+        const overlapEnd = new Date(
+          Math.min(workingHour.end.getTime(), scheduleSlot.end.getTime())
+        );
+        if (overlapStart < overlapEnd && workingHour.isAvailable && scheduleSlot.isAvailable) {
+          let slotStart = new Date(overlapStart);
+          while (slotStart < overlapEnd) {
+            const slotEnd = new Date(
+              slotStart.getTime() + MIN_APPOINTMENT_DURATION * 60 * 1e3
+            );
+            const hasOverlap = existingAppointments.some((appointment) => {
+              const appointmentStart = appointment.eventTime.start.toDate();
+              const appointmentEnd = appointment.eventTime.end.toDate();
+              return slotStart >= appointmentStart && slotStart < appointmentEnd || slotEnd > appointmentStart && slotEnd <= appointmentEnd;
+            });
+            if (!hasOverlap && slotEnd <= overlapEnd) {
+              availableSlots.push({
+                start: new Date(slotStart),
+                end: new Date(slotEnd),
+                isAvailable: true
+              });
+            }
+            slotStart = new Date(
+              slotStart.getTime() + MIN_APPOINTMENT_DURATION * 60 * 1e3
+            );
+          }
+        }
+      }
+    }
+    return availableSlots;
   }
-  try {
-    const finalQuery = (0, import_firestore29.query)(collectionRef, ...constraints);
-    const querySnapshot = await (0, import_firestore29.getDocs)(finalQuery);
-    const events = querySnapshot.docs.map(
-      (doc26) => ({ id: doc26.id, ...doc26.data() })
-    );
-    return events;
-  } catch (error) {
-    console.error("Error searching calendar events:", error);
-    return [];
+  /**
+   * Fetches and creates info cards for clinic, doctor, and patient profiles
+   * @param clinicId - ID of the clinic
+   * @param doctorId - ID of the doctor
+   * @param patientId - ID of the patient
+   * @returns Object containing info cards for all profiles
+   */
+  async fetchProfileInfoCards(clinicId, doctorId, patientId) {
+    var _a;
+    try {
+      const [clinicDoc, practitionerDoc, patientDoc, patientSensitiveInfoDoc] = await Promise.all([
+        (0, import_firestore37.getDoc)((0, import_firestore37.doc)(this.db, CLINICS_COLLECTION, clinicId)),
+        (0, import_firestore37.getDoc)((0, import_firestore37.doc)(this.db, PRACTITIONERS_COLLECTION, doctorId)),
+        (0, import_firestore37.getDoc)((0, import_firestore37.doc)(this.db, PATIENTS_COLLECTION, patientId)),
+        (0, import_firestore37.getDoc)(
+          (0, import_firestore37.doc)(
+            this.db,
+            PATIENTS_COLLECTION,
+            patientId,
+            PATIENT_SENSITIVE_INFO_COLLECTION,
+            patientId
+          )
+        )
+      ]);
+      const clinicInfo = clinicDoc.exists() ? {
+        id: clinicDoc.id,
+        featuredPhoto: clinicDoc.data().featuredPhoto || "",
+        name: clinicDoc.data().name,
+        description: clinicDoc.data().description || "",
+        location: clinicDoc.data().location,
+        contactInfo: clinicDoc.data().contactInfo
+      } : null;
+      const practitionerInfo = practitionerDoc.exists() ? {
+        id: practitionerDoc.id,
+        practitionerPhoto: practitionerDoc.data().basicInfo.profileImageUrl || null,
+        name: `${practitionerDoc.data().basicInfo.firstName} ${practitionerDoc.data().basicInfo.lastName}`,
+        email: practitionerDoc.data().basicInfo.email,
+        phone: practitionerDoc.data().basicInfo.phoneNumber || null,
+        certification: practitionerDoc.data().certification
+      } : null;
+      let patientInfo = null;
+      if (patientSensitiveInfoDoc.exists()) {
+        const sensitiveData = patientSensitiveInfoDoc.data();
+        patientInfo = {
+          id: patientId,
+          fullName: `${sensitiveData.firstName} ${sensitiveData.lastName}`,
+          email: sensitiveData.email || "",
+          phone: sensitiveData.phoneNumber || null,
+          dateOfBirth: sensitiveData.dateOfBirth || import_firestore36.Timestamp.now(),
+          gender: sensitiveData.gender || "other" /* OTHER */
+        };
+      } else if (patientDoc.exists()) {
+        patientInfo = {
+          id: patientDoc.id,
+          fullName: patientDoc.data().displayName,
+          email: ((_a = patientDoc.data().contactInfo) == null ? void 0 : _a.email) || "",
+          phone: patientDoc.data().phoneNumber || null,
+          dateOfBirth: patientDoc.data().dateOfBirth || import_firestore36.Timestamp.now(),
+          gender: patientDoc.data().gender || "other" /* OTHER */
+        };
+      }
+      return {
+        clinicInfo,
+        practitionerInfo,
+        patientInfo
+      };
+    } catch (error) {
+      console.error("Error fetching profile info cards:", error);
+      return {
+        clinicInfo: null,
+        practitionerInfo: null,
+        patientInfo: null
+      };
+    }
   }
-}
+  // #endregion
+};
 
 // src/services/calendar/calendar.v3.service.ts
+var import_firestore38 = require("firebase/firestore");
+var import_firestore39 = require("firebase/firestore");
 var CalendarServiceV3 = class extends BaseService {
   /**
    * Creates a new CalendarServiceV3 instance
@@ -10396,7 +12836,7 @@ var CalendarServiceV3 = class extends BaseService {
       params.entityType,
       params.entityId
     );
-    const eventRef = (0, import_firestore31.doc)(this.db, collectionPath, eventId);
+    const eventRef = (0, import_firestore39.doc)(this.db, collectionPath, eventId);
     const eventData = {
       id: eventId,
       eventName: params.eventName,
@@ -10406,19 +12846,19 @@ var CalendarServiceV3 = class extends BaseService {
       status: "confirmed" /* CONFIRMED */,
       // Blocking events are always confirmed
       syncStatus: "internal" /* INTERNAL */,
-      createdAt: (0, import_firestore30.serverTimestamp)(),
-      updatedAt: (0, import_firestore30.serverTimestamp)()
+      createdAt: (0, import_firestore38.serverTimestamp)(),
+      updatedAt: (0, import_firestore38.serverTimestamp)()
     };
     if (params.entityType === "practitioner") {
       eventData.practitionerProfileId = params.entityId;
     } else {
       eventData.clinicBranchId = params.entityId;
     }
-    await (0, import_firestore31.setDoc)(eventRef, eventData);
+    await (0, import_firestore39.setDoc)(eventRef, eventData);
     return {
       ...eventData,
-      createdAt: import_firestore30.Timestamp.now(),
-      updatedAt: import_firestore30.Timestamp.now()
+      createdAt: import_firestore38.Timestamp.now(),
+      updatedAt: import_firestore38.Timestamp.now()
     };
   }
   /**
@@ -10431,13 +12871,13 @@ var CalendarServiceV3 = class extends BaseService {
       params.entityType,
       params.entityId
     );
-    const eventRef = (0, import_firestore31.doc)(this.db, collectionPath, params.eventId);
-    const eventDoc = await (0, import_firestore31.getDoc)(eventRef);
+    const eventRef = (0, import_firestore39.doc)(this.db, collectionPath, params.eventId);
+    const eventDoc = await (0, import_firestore39.getDoc)(eventRef);
     if (!eventDoc.exists()) {
       throw new Error(`Blocking event with ID ${params.eventId} not found`);
     }
     const updateData = {
-      updatedAt: (0, import_firestore30.serverTimestamp)()
+      updatedAt: (0, import_firestore38.serverTimestamp)()
     };
     if (params.eventName !== void 0) {
       updateData.eventName = params.eventName;
@@ -10451,8 +12891,8 @@ var CalendarServiceV3 = class extends BaseService {
     if (params.status !== void 0) {
       updateData.status = params.status;
     }
-    await (0, import_firestore31.updateDoc)(eventRef, updateData);
-    const updatedEventDoc = await (0, import_firestore31.getDoc)(eventRef);
+    await (0, import_firestore39.updateDoc)(eventRef, updateData);
+    const updatedEventDoc = await (0, import_firestore39.getDoc)(eventRef);
     return updatedEventDoc.data();
   }
   /**
@@ -10463,12 +12903,12 @@ var CalendarServiceV3 = class extends BaseService {
    */
   async deleteBlockingEvent(entityType, entityId, eventId) {
     const collectionPath = this.getEntityCalendarPath(entityType, entityId);
-    const eventRef = (0, import_firestore31.doc)(this.db, collectionPath, eventId);
-    const eventDoc = await (0, import_firestore31.getDoc)(eventRef);
+    const eventRef = (0, import_firestore39.doc)(this.db, collectionPath, eventId);
+    const eventDoc = await (0, import_firestore39.getDoc)(eventRef);
     if (!eventDoc.exists()) {
       throw new Error(`Blocking event with ID ${eventId} not found`);
     }
-    await (0, import_firestore31.deleteDoc)(eventRef);
+    await (0, import_firestore39.deleteDoc)(eventRef);
   }
   /**
    * Gets a specific blocking event
@@ -10479,8 +12919,8 @@ var CalendarServiceV3 = class extends BaseService {
    */
   async getBlockingEvent(entityType, entityId, eventId) {
     const collectionPath = this.getEntityCalendarPath(entityType, entityId);
-    const eventRef = (0, import_firestore31.doc)(this.db, collectionPath, eventId);
-    const eventDoc = await (0, import_firestore31.getDoc)(eventRef);
+    const eventRef = (0, import_firestore39.doc)(this.db, collectionPath, eventId);
+    const eventDoc = await (0, import_firestore39.getDoc)(eventRef);
     if (!eventDoc.exists()) {
       return null;
     }
@@ -10673,7 +13113,7 @@ var ExternalCalendarService = class extends BaseService {
 };
 
 // src/services/clinic/practitioner-invite.service.ts
-var import_firestore32 = require("firebase/firestore");
+var import_firestore40 = require("firebase/firestore");
 var PractitionerInviteService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -10735,7 +13175,7 @@ var PractitionerInviteService = class extends BaseService {
         message: message || null,
         status: "pending" /* PENDING */
       };
-      const now = import_firestore32.Timestamp.now();
+      const now = import_firestore40.Timestamp.now();
       const invite = {
         id: inviteId,
         ...inviteData,
@@ -10746,8 +13186,8 @@ var PractitionerInviteService = class extends BaseService {
         rejectedAt: null,
         cancelledAt: null
       };
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await (0, import_firestore32.setDoc)(docRef, invite);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await (0, import_firestore40.setDoc)(docRef, invite);
       return invite;
     } catch (error) {
       console.error(
@@ -10766,18 +13206,18 @@ var PractitionerInviteService = class extends BaseService {
   async getAllInvitesDoctor(practitionerId, statusFilter) {
     try {
       const constraints = [
-        (0, import_firestore32.where)("practitionerId", "==", practitionerId),
-        (0, import_firestore32.orderBy)("createdAt", "desc")
+        (0, import_firestore40.where)("practitionerId", "==", practitionerId),
+        (0, import_firestore40.orderBy)("createdAt", "desc")
       ];
       if (statusFilter && statusFilter.length > 0) {
-        constraints.push((0, import_firestore32.where)("status", "in", statusFilter));
+        constraints.push((0, import_firestore40.where)("status", "in", statusFilter));
       }
-      const q = (0, import_firestore32.query)(
-        (0, import_firestore32.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
+      const q = (0, import_firestore40.query)(
+        (0, import_firestore40.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore32.getDocs)(q);
-      return querySnapshot.docs.map((doc26) => doc26.data());
+      const querySnapshot = await (0, import_firestore40.getDocs)(q);
+      return querySnapshot.docs.map((doc32) => doc32.data());
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error getting doctor invites:",
@@ -10795,18 +13235,18 @@ var PractitionerInviteService = class extends BaseService {
   async getAllInvitesClinic(clinicId, statusFilter) {
     try {
       const constraints = [
-        (0, import_firestore32.where)("clinicId", "==", clinicId),
-        (0, import_firestore32.orderBy)("createdAt", "desc")
+        (0, import_firestore40.where)("clinicId", "==", clinicId),
+        (0, import_firestore40.orderBy)("createdAt", "desc")
       ];
       if (statusFilter && statusFilter.length > 0) {
-        constraints.push((0, import_firestore32.where)("status", "in", statusFilter));
+        constraints.push((0, import_firestore40.where)("status", "in", statusFilter));
       }
-      const q = (0, import_firestore32.query)(
-        (0, import_firestore32.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
+      const q = (0, import_firestore40.query)(
+        (0, import_firestore40.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore32.getDocs)(q);
-      return querySnapshot.docs.map((doc26) => doc26.data());
+      const querySnapshot = await (0, import_firestore40.getDocs)(q);
+      return querySnapshot.docs.map((doc32) => doc32.data());
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error getting clinic invites:",
@@ -10831,11 +13271,11 @@ var PractitionerInviteService = class extends BaseService {
       }
       const updateData = {
         status: "accepted" /* ACCEPTED */,
-        acceptedAt: import_firestore32.Timestamp.now(),
-        updatedAt: (0, import_firestore32.serverTimestamp)()
+        acceptedAt: import_firestore40.Timestamp.now(),
+        updatedAt: (0, import_firestore40.serverTimestamp)()
       };
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await (0, import_firestore32.updateDoc)(docRef, updateData);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await (0, import_firestore40.updateDoc)(docRef, updateData);
       return await this.getInviteById(inviteId);
     } catch (error) {
       console.error(
@@ -10863,11 +13303,11 @@ var PractitionerInviteService = class extends BaseService {
       const updateData = {
         status: "rejected" /* REJECTED */,
         rejectionReason: rejectionReason || null,
-        rejectedAt: import_firestore32.Timestamp.now(),
-        updatedAt: (0, import_firestore32.serverTimestamp)()
+        rejectedAt: import_firestore40.Timestamp.now(),
+        updatedAt: (0, import_firestore40.serverTimestamp)()
       };
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await (0, import_firestore32.updateDoc)(docRef, updateData);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await (0, import_firestore40.updateDoc)(docRef, updateData);
       return await this.getInviteById(inviteId);
     } catch (error) {
       console.error(
@@ -10895,11 +13335,11 @@ var PractitionerInviteService = class extends BaseService {
       const updateData = {
         status: "cancelled" /* CANCELLED */,
         cancelReason: cancelReason || null,
-        cancelledAt: import_firestore32.Timestamp.now(),
-        updatedAt: (0, import_firestore32.serverTimestamp)()
+        cancelledAt: import_firestore40.Timestamp.now(),
+        updatedAt: (0, import_firestore40.serverTimestamp)()
       };
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await (0, import_firestore32.updateDoc)(docRef, updateData);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await (0, import_firestore40.updateDoc)(docRef, updateData);
       return await this.getInviteById(inviteId);
     } catch (error) {
       console.error(
@@ -10916,8 +13356,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async getInviteById(inviteId) {
     try {
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      const docSnap = await (0, import_firestore32.getDoc)(docRef);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      const docSnap = await (0, import_firestore40.getDoc)(docRef);
       if (docSnap.exists()) {
         return docSnap.data();
       }
@@ -10939,30 +13379,30 @@ var PractitionerInviteService = class extends BaseService {
     try {
       const constraints = [];
       if (filters.practitionerId) {
-        constraints.push((0, import_firestore32.where)("practitionerId", "==", filters.practitionerId));
+        constraints.push((0, import_firestore40.where)("practitionerId", "==", filters.practitionerId));
       }
       if (filters.clinicId) {
-        constraints.push((0, import_firestore32.where)("clinicId", "==", filters.clinicId));
+        constraints.push((0, import_firestore40.where)("clinicId", "==", filters.clinicId));
       }
       if (filters.invitedBy) {
-        constraints.push((0, import_firestore32.where)("invitedBy", "==", filters.invitedBy));
+        constraints.push((0, import_firestore40.where)("invitedBy", "==", filters.invitedBy));
       }
       if (filters.status && filters.status.length > 0) {
-        constraints.push((0, import_firestore32.where)("status", "in", filters.status));
+        constraints.push((0, import_firestore40.where)("status", "in", filters.status));
       }
       const orderField = filters.orderBy || "createdAt";
       const orderDirection = filters.orderDirection || "desc";
-      constraints.push((0, import_firestore32.orderBy)(orderField, orderDirection));
+      constraints.push((0, import_firestore40.orderBy)(orderField, orderDirection));
       if (filters.limit) {
-        constraints.push((0, import_firestore32.limit)(filters.limit));
+        constraints.push((0, import_firestore40.limit)(filters.limit));
       }
-      const q = (0, import_firestore32.query)(
-        (0, import_firestore32.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
+      const q = (0, import_firestore40.query)(
+        (0, import_firestore40.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore32.getDocs)(q);
+      const querySnapshot = await (0, import_firestore40.getDocs)(q);
       let invites = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       if (filters.fromDate) {
         invites = invites.filter(
@@ -10989,8 +13429,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async deleteInvite(inviteId) {
     try {
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await (0, import_firestore32.deleteDoc)(docRef);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await (0, import_firestore40.deleteDoc)(docRef);
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error deleting invite:",
@@ -11007,8 +13447,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async getPractitionerById(practitionerId) {
     try {
-      const docRef = (0, import_firestore32.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId);
-      const docSnap = await (0, import_firestore32.getDoc)(docRef);
+      const docRef = (0, import_firestore40.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId);
+      const docSnap = await (0, import_firestore40.getDoc)(docRef);
       return docSnap.exists() ? docSnap.data() : null;
     } catch (error) {
       console.error(
@@ -11025,8 +13465,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async getClinicById(clinicId) {
     try {
-      const docRef = (0, import_firestore32.doc)(this.db, CLINICS_COLLECTION, clinicId);
-      const docSnap = await (0, import_firestore32.getDoc)(docRef);
+      const docRef = (0, import_firestore40.doc)(this.db, CLINICS_COLLECTION, clinicId);
+      const docSnap = await (0, import_firestore40.getDoc)(docRef);
       return docSnap.exists() ? docSnap.data() : null;
     } catch (error) {
       console.error("[PractitionerInviteService] Error getting clinic:", error);
@@ -11041,14 +13481,14 @@ var PractitionerInviteService = class extends BaseService {
    */
   async findExistingInvite(practitionerId, clinicId) {
     try {
-      const q = (0, import_firestore32.query)(
-        (0, import_firestore32.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
-        (0, import_firestore32.where)("practitionerId", "==", practitionerId),
-        (0, import_firestore32.where)("clinicId", "==", clinicId),
-        (0, import_firestore32.orderBy)("createdAt", "desc"),
-        (0, import_firestore32.limit)(1)
-      );
-      const querySnapshot = await (0, import_firestore32.getDocs)(q);
+      const q = (0, import_firestore40.query)(
+        (0, import_firestore40.collection)(this.db, PRACTITIONER_INVITES_COLLECTION),
+        (0, import_firestore40.where)("practitionerId", "==", practitionerId),
+        (0, import_firestore40.where)("clinicId", "==", clinicId),
+        (0, import_firestore40.orderBy)("createdAt", "desc"),
+        (0, import_firestore40.limit)(1)
+      );
+      const querySnapshot = await (0, import_firestore40.getDocs)(q);
       if (querySnapshot.empty) {
         return null;
       }
@@ -11064,11 +13504,11 @@ var PractitionerInviteService = class extends BaseService {
 };
 
 // src/services/documentation-templates/documentation-template.service.ts
-var import_firestore33 = require("firebase/firestore");
+var import_firestore41 = require("firebase/firestore");
 var DocumentationTemplateService = class extends BaseService {
   constructor() {
     super(...arguments);
-    this.collectionRef = (0, import_firestore33.collection)(
+    this.collectionRef = (0, import_firestore41.collection)(
       this.db,
       DOCUMENTATION_TEMPLATES_COLLECTION
     );
@@ -11102,8 +13542,8 @@ var DocumentationTemplateService = class extends BaseService {
       isRequired: validatedData.isRequired || false,
       sortingOrder: validatedData.sortingOrder || 0
     };
-    const docRef = (0, import_firestore33.doc)(this.collectionRef, templateId);
-    await (0, import_firestore33.setDoc)(docRef, template);
+    const docRef = (0, import_firestore41.doc)(this.collectionRef, templateId);
+    await (0, import_firestore41.setDoc)(docRef, template);
     return template;
   }
   /**
@@ -11113,8 +13553,8 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns The template or null if not found
    */
   async getTemplateById(templateId, version) {
-    const docRef = (0, import_firestore33.doc)(this.collectionRef, templateId);
-    const docSnap = await (0, import_firestore33.getDoc)(docRef);
+    const docRef = (0, import_firestore41.doc)(this.collectionRef, templateId);
+    const docSnap = await (0, import_firestore41.getDoc)(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -11152,15 +13592,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
-    const versionsCollectionRef = (0, import_firestore33.collection)(
+    const versionsCollectionRef = (0, import_firestore41.collection)(
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
     );
-    const versionDocRef = (0, import_firestore33.doc)(
+    const versionDocRef = (0, import_firestore41.doc)(
       versionsCollectionRef,
       template.version.toString()
     );
-    await (0, import_firestore33.setDoc)(versionDocRef, template);
+    await (0, import_firestore41.setDoc)(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -11184,9 +13624,9 @@ var DocumentationTemplateService = class extends BaseService {
     updatePayload.isUserForm = (_a = validatedData.isUserForm) != null ? _a : false;
     updatePayload.isRequired = (_b = validatedData.isRequired) != null ? _b : false;
     updatePayload.sortingOrder = (_c = validatedData.sortingOrder) != null ? _c : 0;
-    const docRef = (0, import_firestore33.doc)(this.collectionRef, templateId);
+    const docRef = (0, import_firestore41.doc)(this.collectionRef, templateId);
     console.log("Update payload", updatePayload);
-    await (0, import_firestore33.updateDoc)(docRef, updatePayload);
+    await (0, import_firestore41.updateDoc)(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
   /**
@@ -11196,11 +13636,11 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns The template version or null if not found
    */
   async getTemplateVersion(templateId, versionNumber) {
-    const versionDocRef = (0, import_firestore33.doc)(
+    const versionDocRef = (0, import_firestore41.doc)(
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
     );
-    const versionDocSnap = await (0, import_firestore33.getDoc)(versionDocRef);
+    const versionDocSnap = await (0, import_firestore41.getDoc)(versionDocRef);
     if (!versionDocSnap.exists()) {
       return null;
     }
@@ -11212,15 +13652,15 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of template versions
    */
   async getTemplateOldVersions(templateId) {
-    const versionsCollectionRef = (0, import_firestore33.collection)(
+    const versionsCollectionRef = (0, import_firestore41.collection)(
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
     );
-    const q = (0, import_firestore33.query)(versionsCollectionRef, (0, import_firestore33.orderBy)("version", "desc"));
-    const querySnapshot = await (0, import_firestore33.getDocs)(q);
+    const q = (0, import_firestore41.query)(versionsCollectionRef, (0, import_firestore41.orderBy)("version", "desc"));
+    const querySnapshot = await (0, import_firestore41.getDocs)(q);
     const versions = [];
-    querySnapshot.forEach((doc26) => {
-      versions.push(doc26.data());
+    querySnapshot.forEach((doc32) => {
+      versions.push(doc32.data());
     });
     return versions;
   }
@@ -11229,8 +13669,8 @@ var DocumentationTemplateService = class extends BaseService {
    * @param templateId - ID of the template to delete
    */
   async deleteTemplate(templateId) {
-    const docRef = (0, import_firestore33.doc)(this.collectionRef, templateId);
-    await (0, import_firestore33.deleteDoc)(docRef);
+    const docRef = (0, import_firestore41.doc)(this.collectionRef, templateId);
+    await (0, import_firestore41.deleteDoc)(docRef);
   }
   /**
    * Get all active templates
@@ -11239,21 +13679,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getActiveTemplates(pageSize = 20, lastDoc) {
-    let q = (0, import_firestore33.query)(
+    let q = (0, import_firestore41.query)(
       this.collectionRef,
-      (0, import_firestore33.where)("isActive", "==", true),
-      (0, import_firestore33.orderBy)("updatedAt", "desc"),
-      (0, import_firestore33.limit)(pageSize)
+      (0, import_firestore41.where)("isActive", "==", true),
+      (0, import_firestore41.orderBy)("updatedAt", "desc"),
+      (0, import_firestore41.limit)(pageSize)
     );
     if (lastDoc) {
-      q = (0, import_firestore33.query)(q, (0, import_firestore33.startAfter)(lastDoc));
+      q = (0, import_firestore41.query)(q, (0, import_firestore41.startAfter)(lastDoc));
     }
-    const querySnapshot = await (0, import_firestore33.getDocs)(q);
+    const querySnapshot = await (0, import_firestore41.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc26) => {
-      templates.push(doc26.data());
-      lastVisible = doc26;
+    querySnapshot.forEach((doc32) => {
+      templates.push(doc32.data());
+      lastVisible = doc32;
     });
     return {
       templates,
@@ -11268,22 +13708,22 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
-    let q = (0, import_firestore33.query)(
+    let q = (0, import_firestore41.query)(
       this.collectionRef,
-      (0, import_firestore33.where)("isActive", "==", true),
-      (0, import_firestore33.where)("tags", "array-contains-any", tags),
-      (0, import_firestore33.orderBy)("updatedAt", "desc"),
-      (0, import_firestore33.limit)(pageSize)
+      (0, import_firestore41.where)("isActive", "==", true),
+      (0, import_firestore41.where)("tags", "array-contains-any", tags),
+      (0, import_firestore41.orderBy)("updatedAt", "desc"),
+      (0, import_firestore41.limit)(pageSize)
     );
     if (lastDoc) {
-      q = (0, import_firestore33.query)(q, (0, import_firestore33.startAfter)(lastDoc));
+      q = (0, import_firestore41.query)(q, (0, import_firestore41.startAfter)(lastDoc));
     }
-    const querySnapshot = await (0, import_firestore33.getDocs)(q);
+    const querySnapshot = await (0, import_firestore41.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc26) => {
-      templates.push(doc26.data());
-      lastVisible = doc26;
+    querySnapshot.forEach((doc32) => {
+      templates.push(doc32.data());
+      lastVisible = doc32;
     });
     return {
       templates,
@@ -11298,21 +13738,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
-    let q = (0, import_firestore33.query)(
+    let q = (0, import_firestore41.query)(
       this.collectionRef,
-      (0, import_firestore33.where)("createdBy", "==", userId),
-      (0, import_firestore33.orderBy)("updatedAt", "desc"),
-      (0, import_firestore33.limit)(pageSize)
+      (0, import_firestore41.where)("createdBy", "==", userId),
+      (0, import_firestore41.orderBy)("updatedAt", "desc"),
+      (0, import_firestore41.limit)(pageSize)
     );
     if (lastDoc) {
-      q = (0, import_firestore33.query)(q, (0, import_firestore33.startAfter)(lastDoc));
+      q = (0, import_firestore41.query)(q, (0, import_firestore41.startAfter)(lastDoc));
     }
-    const querySnapshot = await (0, import_firestore33.getDocs)(q);
+    const querySnapshot = await (0, import_firestore41.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc26) => {
-      templates.push(doc26.data());
-      lastVisible = doc26;
+    querySnapshot.forEach((doc32) => {
+      templates.push(doc32.data());
+      lastVisible = doc32;
     });
     return {
       templates,
@@ -11325,28 +13765,28 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates
    */
   async getAllTemplatesForSelection(options) {
-    let q = (0, import_firestore33.query)(
+    let q = (0, import_firestore41.query)(
       this.collectionRef,
-      (0, import_firestore33.where)("isActive", "==", true),
-      (0, import_firestore33.orderBy)("updatedAt", "desc")
+      (0, import_firestore41.where)("isActive", "==", true),
+      (0, import_firestore41.orderBy)("updatedAt", "desc")
     );
     if ((options == null ? void 0 : options.isUserForm) !== void 0) {
-      q = (0, import_firestore33.query)(q, (0, import_firestore33.where)("isUserForm", "==", options.isUserForm));
+      q = (0, import_firestore41.query)(q, (0, import_firestore41.where)("isUserForm", "==", options.isUserForm));
     }
     if ((options == null ? void 0 : options.isRequired) !== void 0) {
-      q = (0, import_firestore33.query)(q, (0, import_firestore33.where)("isRequired", "==", options.isRequired));
+      q = (0, import_firestore41.query)(q, (0, import_firestore41.where)("isRequired", "==", options.isRequired));
     }
-    const querySnapshot = await (0, import_firestore33.getDocs)(q);
+    const querySnapshot = await (0, import_firestore41.getDocs)(q);
     const templates = [];
-    querySnapshot.forEach((doc26) => {
-      templates.push(doc26.data());
+    querySnapshot.forEach((doc32) => {
+      templates.push(doc32.data());
     });
     return templates;
   }
 };
 
 // src/services/documentation-templates/filled-document.service.ts
-var import_firestore34 = require("firebase/firestore");
+var import_firestore42 = require("firebase/firestore");
 var FilledDocumentService = class extends BaseService {
   constructor(...args) {
     super(...args);
@@ -11401,7 +13841,7 @@ var FilledDocumentService = class extends BaseService {
       values: initialValues,
       status: initialStatus
     };
-    const docRef = (0, import_firestore34.doc)(
+    const docRef = (0, import_firestore42.doc)(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
@@ -11409,7 +13849,7 @@ var FilledDocumentService = class extends BaseService {
       formSubcollection,
       documentId3
     );
-    await (0, import_firestore34.setDoc)(docRef, filledDocument);
+    await (0, import_firestore42.setDoc)(docRef, filledDocument);
     return filledDocument;
   }
   /**
@@ -11421,7 +13861,7 @@ var FilledDocumentService = class extends BaseService {
    */
   async getFilledDocumentFromAppointmentById(appointmentId, formId, isUserForm) {
     const formSubcollection = this.getFormSubcollectionPath(isUserForm);
-    const docRef = (0, import_firestore34.doc)(
+    const docRef = (0, import_firestore42.doc)(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
@@ -11429,7 +13869,7 @@ var FilledDocumentService = class extends BaseService {
       formSubcollection,
       formId
     );
-    const docSnap = await (0, import_firestore34.getDoc)(docRef);
+    const docSnap = await (0, import_firestore42.getDoc)(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -11446,7 +13886,7 @@ var FilledDocumentService = class extends BaseService {
    */
   async updateFilledDocumentInAppointment(appointmentId, formId, isUserForm, values, status) {
     const formSubcollection = this.getFormSubcollectionPath(isUserForm);
-    const docRef = (0, import_firestore34.doc)(
+    const docRef = (0, import_firestore42.doc)(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
@@ -11478,7 +13918,7 @@ var FilledDocumentService = class extends BaseService {
     }
     if (Object.keys(updatePayload).length === 1 && "updatedAt" in updatePayload) {
     }
-    await (0, import_firestore34.updateDoc)(docRef, updatePayload);
+    await (0, import_firestore42.updateDoc)(docRef, updatePayload);
     return { ...existingDoc, ...updatePayload };
   }
   /**
@@ -11488,20 +13928,20 @@ var FilledDocumentService = class extends BaseService {
    * @param lastDoc Last document from previous page for pagination.
    */
   async getFilledUserFormsForAppointment(appointmentId, pageSize = 20, lastDoc) {
-    const subcollectionRef = (0, import_firestore34.collection)(
+    const subcollectionRef = (0, import_firestore42.collection)(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
       appointmentId,
       USER_FORMS_SUBCOLLECTION
     );
-    let q = (0, import_firestore34.query)(
+    let q = (0, import_firestore42.query)(
       subcollectionRef,
-      (0, import_firestore34.orderBy)("updatedAt", "desc"),
-      (0, import_firestore34.limit)(pageSize)
+      (0, import_firestore42.orderBy)("updatedAt", "desc"),
+      (0, import_firestore42.limit)(pageSize)
     );
     if (lastDoc) {
-      q = (0, import_firestore34.query)(q, (0, import_firestore34.startAfter)(lastDoc));
+      q = (0, import_firestore42.query)(q, (0, import_firestore42.startAfter)(lastDoc));
     }
     return this.executeQuery(q);
   }
@@ -11512,31 +13952,31 @@ var FilledDocumentService = class extends BaseService {
    * @param lastDoc Last document from previous page for pagination.
    */
   async getFilledDoctorFormsForAppointment(appointmentId, pageSize = 20, lastDoc) {
-    const subcollectionRef = (0, import_firestore34.collection)(
+    const subcollectionRef = (0, import_firestore42.collection)(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
       appointmentId,
       DOCTOR_FORMS_SUBCOLLECTION
     );
-    let q = (0, import_firestore34.query)(
+    let q = (0, import_firestore42.query)(
       subcollectionRef,
-      (0, import_firestore34.orderBy)("updatedAt", "desc"),
-      (0, import_firestore34.limit)(pageSize)
+      (0, import_firestore42.orderBy)("updatedAt", "desc"),
+      (0, import_firestore42.limit)(pageSize)
     );
     if (lastDoc) {
-      q = (0, import_firestore34.query)(q, (0, import_firestore34.startAfter)(lastDoc));
+      q = (0, import_firestore42.query)(q, (0, import_firestore42.startAfter)(lastDoc));
     }
     return this.executeQuery(q);
   }
   // Helper to execute query and return documents + lastDoc
   async executeQuery(q) {
-    const querySnapshot = await (0, import_firestore34.getDocs)(q);
+    const querySnapshot = await (0, import_firestore42.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc26) => {
-      documents.push(doc26.data());
-      lastVisible = doc26;
+    querySnapshot.forEach((doc32) => {
+      documents.push(doc32.data());
+      lastVisible = doc32;
     });
     return {
       documents,
@@ -11695,14 +14135,14 @@ var FilledDocumentService = class extends BaseService {
 };
 
 // src/services/notifications/notification.service.ts
-var import_firestore35 = require("firebase/firestore");
+var import_firestore43 = require("firebase/firestore");
 var NotificationService = class extends BaseService {
   /**
    * Kreira novu notifikaciju
    */
   async createNotification(notification) {
-    const notificationsRef = (0, import_firestore35.collection)(this.db, NOTIFICATIONS_COLLECTION);
-    const now = import_firestore35.Timestamp.now();
+    const notificationsRef = (0, import_firestore43.collection)(this.db, NOTIFICATIONS_COLLECTION);
+    const now = import_firestore43.Timestamp.now();
     const notificationData = {
       ...notification,
       createdAt: now,
@@ -11711,7 +14151,7 @@ var NotificationService = class extends BaseService {
       isRead: false,
       userRole: notification.userRole || "patient" /* PATIENT */
     };
-    const docRef = await (0, import_firestore35.addDoc)(notificationsRef, notificationData);
+    const docRef = await (0, import_firestore43.addDoc)(notificationsRef, notificationData);
     return {
       ...notificationData,
       id: docRef.id
@@ -11721,12 +14161,12 @@ var NotificationService = class extends BaseService {
    * Dohvata notifikaciju po ID-u
    */
   async getNotification(notificationId) {
-    const notificationRef = (0, import_firestore35.doc)(
+    const notificationRef = (0, import_firestore43.doc)(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    const notificationDoc = await (0, import_firestore35.getDoc)(notificationRef);
+    const notificationDoc = await (0, import_firestore43.getDoc)(notificationRef);
     if (!notificationDoc.exists()) {
       return null;
     }
@@ -11739,45 +14179,45 @@ var NotificationService = class extends BaseService {
    * Dohvata sve notifikacije za korisnika
    */
   async getUserNotifications(userId) {
-    const q = (0, import_firestore35.query)(
-      (0, import_firestore35.collection)(this.db, NOTIFICATIONS_COLLECTION),
-      (0, import_firestore35.where)("userId", "==", userId),
-      (0, import_firestore35.orderBy)("notificationTime", "desc")
-    );
-    const querySnapshot = await (0, import_firestore35.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = (0, import_firestore43.query)(
+      (0, import_firestore43.collection)(this.db, NOTIFICATIONS_COLLECTION),
+      (0, import_firestore43.where)("userId", "==", userId),
+      (0, import_firestore43.orderBy)("notificationTime", "desc")
+    );
+    const querySnapshot = await (0, import_firestore43.getDocs)(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
   /**
    * Dohvata nepročitane notifikacije za korisnika
    */
   async getUnreadNotifications(userId) {
-    const q = (0, import_firestore35.query)(
-      (0, import_firestore35.collection)(this.db, NOTIFICATIONS_COLLECTION),
-      (0, import_firestore35.where)("userId", "==", userId),
-      (0, import_firestore35.where)("isRead", "==", false),
-      (0, import_firestore35.orderBy)("notificationTime", "desc")
-    );
-    const querySnapshot = await (0, import_firestore35.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = (0, import_firestore43.query)(
+      (0, import_firestore43.collection)(this.db, NOTIFICATIONS_COLLECTION),
+      (0, import_firestore43.where)("userId", "==", userId),
+      (0, import_firestore43.where)("isRead", "==", false),
+      (0, import_firestore43.orderBy)("notificationTime", "desc")
+    );
+    const querySnapshot = await (0, import_firestore43.getDocs)(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
   /**
    * Označava notifikaciju kao pročitanu
    */
   async markAsRead(notificationId) {
-    const notificationRef = (0, import_firestore35.doc)(
+    const notificationRef = (0, import_firestore43.doc)(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await (0, import_firestore35.updateDoc)(notificationRef, {
+    await (0, import_firestore43.updateDoc)(notificationRef, {
       isRead: true,
-      updatedAt: import_firestore35.Timestamp.now()
+      updatedAt: import_firestore43.Timestamp.now()
     });
   }
   /**
@@ -11785,16 +14225,16 @@ var NotificationService = class extends BaseService {
    */
   async markAllAsRead(userId) {
     const notifications = await this.getUnreadNotifications(userId);
-    const batch = (0, import_firestore35.writeBatch)(this.db);
+    const batch = (0, import_firestore43.writeBatch)(this.db);
     notifications.forEach((notification) => {
-      const notificationRef = (0, import_firestore35.doc)(
+      const notificationRef = (0, import_firestore43.doc)(
         this.db,
         NOTIFICATIONS_COLLECTION,
         notification.id
       );
       batch.update(notificationRef, {
         isRead: true,
-        updatedAt: import_firestore35.Timestamp.now()
+        updatedAt: import_firestore43.Timestamp.now()
       });
     });
     await batch.commit();
@@ -11803,74 +14243,74 @@ var NotificationService = class extends BaseService {
    * Ažurira status notifikacije
    */
   async updateNotificationStatus(notificationId, status) {
-    const notificationRef = (0, import_firestore35.doc)(
+    const notificationRef = (0, import_firestore43.doc)(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await (0, import_firestore35.updateDoc)(notificationRef, {
+    await (0, import_firestore43.updateDoc)(notificationRef, {
       status,
-      updatedAt: import_firestore35.Timestamp.now()
+      updatedAt: import_firestore43.Timestamp.now()
     });
   }
   /**
    * Briše notifikaciju
    */
   async deleteNotification(notificationId) {
-    const notificationRef = (0, import_firestore35.doc)(
+    const notificationRef = (0, import_firestore43.doc)(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await (0, import_firestore35.deleteDoc)(notificationRef);
+    await (0, import_firestore43.deleteDoc)(notificationRef);
   }
   /**
    * Dohvata notifikacije po tipu
    */
   async getNotificationsByType(userId, type) {
-    const q = (0, import_firestore35.query)(
-      (0, import_firestore35.collection)(this.db, NOTIFICATIONS_COLLECTION),
-      (0, import_firestore35.where)("userId", "==", userId),
-      (0, import_firestore35.where)("notificationType", "==", type),
-      (0, import_firestore35.orderBy)("notificationTime", "desc")
-    );
-    const querySnapshot = await (0, import_firestore35.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = (0, import_firestore43.query)(
+      (0, import_firestore43.collection)(this.db, NOTIFICATIONS_COLLECTION),
+      (0, import_firestore43.where)("userId", "==", userId),
+      (0, import_firestore43.where)("notificationType", "==", type),
+      (0, import_firestore43.orderBy)("notificationTime", "desc")
+    );
+    const querySnapshot = await (0, import_firestore43.getDocs)(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
   /**
    * Dohvata notifikacije za određeni termin
    */
   async getAppointmentNotifications(appointmentId) {
-    const q = (0, import_firestore35.query)(
-      (0, import_firestore35.collection)(this.db, NOTIFICATIONS_COLLECTION),
-      (0, import_firestore35.where)("appointmentId", "==", appointmentId),
-      (0, import_firestore35.orderBy)("notificationTime", "desc")
-    );
-    const querySnapshot = await (0, import_firestore35.getDocs)(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = (0, import_firestore43.query)(
+      (0, import_firestore43.collection)(this.db, NOTIFICATIONS_COLLECTION),
+      (0, import_firestore43.where)("appointmentId", "==", appointmentId),
+      (0, import_firestore43.orderBy)("notificationTime", "desc")
+    );
+    const querySnapshot = await (0, import_firestore43.getDocs)(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
 };
 
 // src/services/patient/patientRequirements.service.ts
-var import_firestore36 = require("firebase/firestore");
+var import_firestore44 = require("firebase/firestore");
 var PatientRequirementsService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
   }
   getPatientRequirementsCollectionRef(patientId) {
-    return (0, import_firestore36.collection)(
+    return (0, import_firestore44.collection)(
       this.db,
       `patients/${patientId}/${PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME}`
     );
   }
   getPatientRequirementDocRef(patientId, instanceId) {
-    return (0, import_firestore36.doc)(
+    return (0, import_firestore44.doc)(
       this.getPatientRequirementsCollectionRef(patientId),
       instanceId
     );
@@ -11883,7 +14323,7 @@ var PatientRequirementsService = class extends BaseService {
    */
   async getPatientRequirementInstance(patientId, instanceId) {
     const docRef = this.getPatientRequirementDocRef(patientId, instanceId);
-    const docSnap = await (0, import_firestore36.getDoc)(docRef);
+    const docSnap = await (0, import_firestore44.getDoc)(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -11902,22 +14342,22 @@ var PatientRequirementsService = class extends BaseService {
    */
   async getAllPatientRequirementInstances(patientId, filters, pageLimit = 20, lastVisible) {
     const collRef = this.getPatientRequirementsCollectionRef(patientId);
-    let q = (0, import_firestore36.query)(collRef, (0, import_firestore36.orderBy)("createdAt", "desc"));
+    let q = (0, import_firestore44.query)(collRef, (0, import_firestore44.orderBy)("createdAt", "desc"));
     const queryConstraints = [];
     if ((filters == null ? void 0 : filters.appointmentId) && filters.appointmentId !== "all") {
       queryConstraints.push(
-        (0, import_firestore36.where)("appointmentId", "==", filters.appointmentId)
+        (0, import_firestore44.where)("appointmentId", "==", filters.appointmentId)
       );
     }
     if ((filters == null ? void 0 : filters.statuses) && filters.statuses.length > 0) {
-      queryConstraints.push((0, import_firestore36.where)("overallStatus", "in", filters.statuses));
+      queryConstraints.push((0, import_firestore44.where)("overallStatus", "in", filters.statuses));
     }
     if (lastVisible) {
-      queryConstraints.push((0, import_firestore36.startAfter)(lastVisible));
+      queryConstraints.push((0, import_firestore44.startAfter)(lastVisible));
     }
-    queryConstraints.push((0, import_firestore36.limit)(pageLimit));
-    q = (0, import_firestore36.query)(collRef, ...queryConstraints);
-    const snapshot = await (0, import_firestore36.getDocs)(q);
+    queryConstraints.push((0, import_firestore44.limit)(pageLimit));
+    q = (0, import_firestore44.query)(collRef, ...queryConstraints);
+    const snapshot = await (0, import_firestore44.getDocs)(q);
     let requirements = snapshot.docs.map((docSnap) => {
       const data = docSnap.data();
       return { id: docSnap.id, ...data };
@@ -11960,7 +14400,7 @@ var PatientRequirementsService = class extends BaseService {
    */
   async completeInstruction(patientId, instanceId, instructionId) {
     const instanceRef = this.getPatientRequirementDocRef(patientId, instanceId);
-    const instanceSnap = await (0, import_firestore36.getDoc)(instanceRef);
+    const instanceSnap = await (0, import_firestore44.getDoc)(instanceRef);
     if (!instanceSnap.exists()) {
       throw new Error(
         `PatientRequirementInstance ${instanceId} not found for patient ${patientId}.`
@@ -11988,7 +14428,7 @@ var PatientRequirementsService = class extends BaseService {
         `Instruction ${instructionId} is in status ${instructionToUpdate.status} and cannot be marked as completed.`
       );
     }
-    const now = import_firestore36.Timestamp.now();
+    const now = import_firestore44.Timestamp.now();
     const updatedInstructions = [...instance.instructions];
     updatedInstructions[instructionIndex] = {
       ...instructionToUpdate,
@@ -12015,7 +14455,7 @@ var PatientRequirementsService = class extends BaseService {
     if (newOverallStatus !== instance.overallStatus) {
       updatePayload.overallStatus = newOverallStatus;
     }
-    await (0, import_firestore36.updateDoc)(instanceRef, updatePayload);
+    await (0, import_firestore44.updateDoc)(instanceRef, updatePayload);
     return {
       ...instance,
       instructions: updatedInstructions,
@@ -12028,7 +14468,7 @@ var PatientRequirementsService = class extends BaseService {
 };
 
 // src/services/procedure/procedure.service.ts
-var import_firestore37 = require("firebase/firestore");
+var import_firestore45 = require("firebase/firestore");
 
 // src/validations/procedure.schema.ts
 var import_zod24 = require("zod");
@@ -12183,24 +14623,24 @@ var ProcedureService = class extends BaseService {
     if (!category || !subcategory || !technology || !product) {
       throw new Error("One or more required base entities not found");
     }
-    const clinicRef = (0, import_firestore37.doc)(
+    const clinicRef = (0, import_firestore45.doc)(
       this.db,
       CLINICS_COLLECTION,
       validatedData.clinicBranchId
     );
-    const clinicSnapshot = await (0, import_firestore37.getDoc)(clinicRef);
+    const clinicSnapshot = await (0, import_firestore45.getDoc)(clinicRef);
     if (!clinicSnapshot.exists()) {
       throw new Error(
         `Clinic with ID ${validatedData.clinicBranchId} not found`
       );
     }
     const clinic = clinicSnapshot.data();
-    const practitionerRef = (0, import_firestore37.doc)(
+    const practitionerRef = (0, import_firestore45.doc)(
       this.db,
       PRACTITIONERS_COLLECTION,
       validatedData.practitionerId
     );
-    const practitionerSnapshot = await (0, import_firestore37.getDoc)(practitionerRef);
+    const practitionerSnapshot = await (0, import_firestore45.getDoc)(practitionerRef);
     if (!practitionerSnapshot.exists()) {
       throw new Error(
         `Practitioner with ID ${validatedData.practitionerId} not found`
@@ -12266,13 +14706,13 @@ var ProcedureService = class extends BaseService {
       isActive: true
       // Default to active
     };
-    const procedureRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, procedureId);
-    await (0, import_firestore37.setDoc)(procedureRef, {
+    const procedureRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, procedureId);
+    await (0, import_firestore45.setDoc)(procedureRef, {
       ...newProcedure,
-      createdAt: (0, import_firestore37.serverTimestamp)(),
-      updatedAt: (0, import_firestore37.serverTimestamp)()
+      createdAt: (0, import_firestore45.serverTimestamp)(),
+      updatedAt: (0, import_firestore45.serverTimestamp)()
     });
-    const savedDoc = await (0, import_firestore37.getDoc)(procedureRef);
+    const savedDoc = await (0, import_firestore45.getDoc)(procedureRef);
     return savedDoc.data();
   }
   /**
@@ -12301,7 +14741,7 @@ var ProcedureService = class extends BaseService {
         validatedData.technologyId,
         validatedData.productId
       ),
-      (0, import_firestore37.getDoc)((0, import_firestore37.doc)(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId))
+      (0, import_firestore45.getDoc)((0, import_firestore45.doc)(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId))
     ]);
     if (!category || !subcategory || !technology || !product) {
       throw new Error("One or more required base entities not found");
@@ -12324,13 +14764,13 @@ var ProcedureService = class extends BaseService {
     const practitionersMap = /* @__PURE__ */ new Map();
     for (let i = 0; i < practitionerIds.length; i += 30) {
       const chunk = practitionerIds.slice(i, i + 30);
-      const practitionersQuery = (0, import_firestore37.query)(
-        (0, import_firestore37.collection)(this.db, PRACTITIONERS_COLLECTION),
-        (0, import_firestore37.where)((0, import_firestore37.documentId)(), "in", chunk)
+      const practitionersQuery = (0, import_firestore45.query)(
+        (0, import_firestore45.collection)(this.db, PRACTITIONERS_COLLECTION),
+        (0, import_firestore45.where)((0, import_firestore45.documentId)(), "in", chunk)
       );
-      const practitionersSnapshot = await (0, import_firestore37.getDocs)(practitionersQuery);
-      practitionersSnapshot.docs.forEach((doc26) => {
-        practitionersMap.set(doc26.id, doc26.data());
+      const practitionersSnapshot = await (0, import_firestore45.getDocs)(practitionersQuery);
+      practitionersSnapshot.docs.forEach((doc32) => {
+        practitionersMap.set(doc32.id, doc32.data());
       });
     }
     if (practitionersMap.size !== practitionerIds.length) {
@@ -12342,7 +14782,7 @@ var ProcedureService = class extends BaseService {
         `The following practitioners were not found: ${notFoundIds.join(", ")}`
       );
     }
-    const batch = (0, import_firestore37.writeBatch)(this.db);
+    const batch = (0, import_firestore45.writeBatch)(this.db);
     const createdProcedureIds = [];
     const clinicInfo = {
       id: clinicSnapshot.id,
@@ -12364,7 +14804,7 @@ var ProcedureService = class extends BaseService {
       };
       const procedureId = this.generateId();
       createdProcedureIds.push(procedureId);
-      const procedureRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, procedureId);
+      const procedureRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, procedureId);
       const newProcedure = {
         id: procedureId,
         ...validatedData,
@@ -12399,21 +14839,21 @@ var ProcedureService = class extends BaseService {
       };
       batch.set(procedureRef, {
         ...newProcedure,
-        createdAt: (0, import_firestore37.serverTimestamp)(),
-        updatedAt: (0, import_firestore37.serverTimestamp)()
+        createdAt: (0, import_firestore45.serverTimestamp)(),
+        updatedAt: (0, import_firestore45.serverTimestamp)()
       });
     }
     await batch.commit();
     const fetchedProcedures = [];
     for (let i = 0; i < createdProcedureIds.length; i += 30) {
       const chunk = createdProcedureIds.slice(i, i + 30);
-      const q = (0, import_firestore37.query)(
-        (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION),
-        (0, import_firestore37.where)((0, import_firestore37.documentId)(), "in", chunk)
+      const q = (0, import_firestore45.query)(
+        (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION),
+        (0, import_firestore45.where)((0, import_firestore45.documentId)(), "in", chunk)
       );
-      const snapshot = await (0, import_firestore37.getDocs)(q);
-      snapshot.forEach((doc26) => {
-        fetchedProcedures.push(doc26.data());
+      const snapshot = await (0, import_firestore45.getDocs)(q);
+      snapshot.forEach((doc32) => {
+        fetchedProcedures.push(doc32.data());
       });
     }
     return fetchedProcedures;
@@ -12424,8 +14864,8 @@ var ProcedureService = class extends BaseService {
    * @returns The procedure if found, null otherwise
    */
   async getProcedure(id) {
-    const docRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, id);
-    const docSnap = await (0, import_firestore37.getDoc)(docRef);
+    const docRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, id);
+    const docSnap = await (0, import_firestore45.getDoc)(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -12437,13 +14877,13 @@ var ProcedureService = class extends BaseService {
    * @returns List of procedures
    */
   async getProceduresByClinicBranch(clinicBranchId) {
-    const q = (0, import_firestore37.query)(
-      (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION),
-      (0, import_firestore37.where)("clinicBranchId", "==", clinicBranchId),
-      (0, import_firestore37.where)("isActive", "==", true)
+    const q = (0, import_firestore45.query)(
+      (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION),
+      (0, import_firestore45.where)("clinicBranchId", "==", clinicBranchId),
+      (0, import_firestore45.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore37.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore45.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all procedures for a practitioner
@@ -12451,13 +14891,13 @@ var ProcedureService = class extends BaseService {
    * @returns List of procedures
    */
   async getProceduresByPractitioner(practitionerId) {
-    const q = (0, import_firestore37.query)(
-      (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION),
-      (0, import_firestore37.where)("practitionerId", "==", practitionerId),
-      (0, import_firestore37.where)("isActive", "==", true)
+    const q = (0, import_firestore45.query)(
+      (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION),
+      (0, import_firestore45.where)("practitionerId", "==", practitionerId),
+      (0, import_firestore45.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore37.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore45.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all inactive procedures for a practitioner
@@ -12465,13 +14905,13 @@ var ProcedureService = class extends BaseService {
    * @returns List of inactive procedures
    */
   async getInactiveProceduresByPractitioner(practitionerId) {
-    const q = (0, import_firestore37.query)(
-      (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION),
-      (0, import_firestore37.where)("practitionerId", "==", practitionerId),
-      (0, import_firestore37.where)("isActive", "==", false)
+    const q = (0, import_firestore45.query)(
+      (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION),
+      (0, import_firestore45.where)("practitionerId", "==", practitionerId),
+      (0, import_firestore45.where)("isActive", "==", false)
     );
-    const snapshot = await (0, import_firestore37.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore45.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Updates a procedure
@@ -12482,8 +14922,8 @@ var ProcedureService = class extends BaseService {
   async updateProcedure(id, data) {
     var _a;
     const validatedData = updateProcedureSchema.parse(data);
-    const procedureRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, id);
-    const procedureSnapshot = await (0, import_firestore37.getDoc)(procedureRef);
+    const procedureRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await (0, import_firestore45.getDoc)(procedureRef);
     if (!procedureSnapshot.exists()) {
       throw new Error(`Procedure with ID ${id} not found`);
     }
@@ -12504,12 +14944,12 @@ var ProcedureService = class extends BaseService {
     }
     if (validatedData.practitionerId && validatedData.practitionerId !== oldPractitionerId) {
       practitionerChanged = true;
-      const newPractitionerRef = (0, import_firestore37.doc)(
+      const newPractitionerRef = (0, import_firestore45.doc)(
         this.db,
         PRACTITIONERS_COLLECTION,
         validatedData.practitionerId
       );
-      const newPractitionerSnap = await (0, import_firestore37.getDoc)(newPractitionerRef);
+      const newPractitionerSnap = await (0, import_firestore45.getDoc)(newPractitionerRef);
       if (!newPractitionerSnap.exists())
         throw new Error(
           `New Practitioner ${validatedData.practitionerId} not found`
@@ -12527,12 +14967,12 @@ var ProcedureService = class extends BaseService {
     }
     if (validatedData.clinicBranchId && validatedData.clinicBranchId !== oldClinicId) {
       clinicChanged = true;
-      const newClinicRef = (0, import_firestore37.doc)(
+      const newClinicRef = (0, import_firestore45.doc)(
         this.db,
         CLINICS_COLLECTION,
         validatedData.clinicBranchId
       );
-      const newClinicSnap = await (0, import_firestore37.getDoc)(newClinicRef);
+      const newClinicSnap = await (0, import_firestore45.getDoc)(newClinicRef);
       if (!newClinicSnap.exists())
         throw new Error(`New Clinic ${validatedData.clinicBranchId} not found`);
       newClinic = newClinicSnap.data();
@@ -12599,11 +15039,11 @@ var ProcedureService = class extends BaseService {
     } else if (validatedData.productId) {
       console.warn("Attempted to update product without a valid technologyId");
     }
-    await (0, import_firestore37.updateDoc)(procedureRef, {
+    await (0, import_firestore45.updateDoc)(procedureRef, {
       ...updatedProcedureData,
-      updatedAt: (0, import_firestore37.serverTimestamp)()
+      updatedAt: (0, import_firestore45.serverTimestamp)()
     });
-    const updatedSnapshot = await (0, import_firestore37.getDoc)(procedureRef);
+    const updatedSnapshot = await (0, import_firestore45.getDoc)(procedureRef);
     return updatedSnapshot.data();
   }
   /**
@@ -12611,15 +15051,15 @@ var ProcedureService = class extends BaseService {
    * @param id - The ID of the procedure to deactivate
    */
   async deactivateProcedure(id) {
-    const procedureRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, id);
-    const procedureSnap = await (0, import_firestore37.getDoc)(procedureRef);
+    const procedureRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnap = await (0, import_firestore45.getDoc)(procedureRef);
     if (!procedureSnap.exists()) {
       console.warn(`Procedure ${id} not found for deactivation.`);
       return;
     }
-    await (0, import_firestore37.updateDoc)(procedureRef, {
+    await (0, import_firestore45.updateDoc)(procedureRef, {
       isActive: false,
-      updatedAt: (0, import_firestore37.serverTimestamp)()
+      updatedAt: (0, import_firestore45.serverTimestamp)()
     });
   }
   /**
@@ -12628,12 +15068,12 @@ var ProcedureService = class extends BaseService {
    * @returns A boolean indicating if the deletion was successful
    */
   async deleteProcedure(id) {
-    const procedureRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, id);
-    const procedureSnapshot = await (0, import_firestore37.getDoc)(procedureRef);
+    const procedureRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await (0, import_firestore45.getDoc)(procedureRef);
     if (!procedureSnapshot.exists()) {
       return false;
     }
-    await (0, import_firestore37.deleteDoc)(procedureRef);
+    await (0, import_firestore45.deleteDoc)(procedureRef);
     return true;
   }
   /**
@@ -12659,35 +15099,35 @@ var ProcedureService = class extends BaseService {
    */
   async getAllProcedures(pagination, lastDoc) {
     try {
-      const proceduresCollection = (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION);
-      let proceduresQuery = (0, import_firestore37.query)(proceduresCollection);
+      const proceduresCollection = (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION);
+      let proceduresQuery = (0, import_firestore45.query)(proceduresCollection);
       if (pagination && pagination > 0) {
         const { limit: limit16, startAfter: startAfter14 } = await import("firebase/firestore");
         if (lastDoc) {
-          proceduresQuery = (0, import_firestore37.query)(
+          proceduresQuery = (0, import_firestore45.query)(
             proceduresCollection,
-            (0, import_firestore37.orderBy)("name"),
+            (0, import_firestore45.orderBy)("name"),
             // Use imported orderBy
             startAfter14(lastDoc),
             limit16(pagination)
           );
         } else {
-          proceduresQuery = (0, import_firestore37.query)(
+          proceduresQuery = (0, import_firestore45.query)(
             proceduresCollection,
-            (0, import_firestore37.orderBy)("name"),
+            (0, import_firestore45.orderBy)("name"),
             limit16(pagination)
           );
         }
       } else {
-        proceduresQuery = (0, import_firestore37.query)(proceduresCollection, (0, import_firestore37.orderBy)("name"));
+        proceduresQuery = (0, import_firestore45.query)(proceduresCollection, (0, import_firestore45.orderBy)("name"));
       }
-      const proceduresSnapshot = await (0, import_firestore37.getDocs)(proceduresQuery);
+      const proceduresSnapshot = await (0, import_firestore45.getDocs)(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
-      const procedures = proceduresSnapshot.docs.map((doc26) => {
-        const data = doc26.data();
+      const procedures = proceduresSnapshot.docs.map((doc32) => {
+        const data = doc32.data();
         return {
           ...data,
-          id: doc26.id
+          id: doc32.id
           // Ensure ID is present
         };
       });
@@ -12730,19 +15170,19 @@ var ProcedureService = class extends BaseService {
       const isGeoQuery = filters.location && filters.radiusInKm && filters.radiusInKm > 0;
       const constraints = [];
       if (filters.isActive !== void 0) {
-        constraints.push((0, import_firestore37.where)("isActive", "==", filters.isActive));
+        constraints.push((0, import_firestore45.where)("isActive", "==", filters.isActive));
       } else {
-        constraints.push((0, import_firestore37.where)("isActive", "==", true));
+        constraints.push((0, import_firestore45.where)("isActive", "==", true));
       }
       if (filters.procedureFamily) {
-        constraints.push((0, import_firestore37.where)("family", "==", filters.procedureFamily));
+        constraints.push((0, import_firestore45.where)("family", "==", filters.procedureFamily));
       }
-      constraints.push((0, import_firestore37.orderBy)("clinicInfo.location.geohash"));
+      constraints.push((0, import_firestore45.orderBy)("clinicInfo.location.geohash"));
       if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
-        constraints.push((0, import_firestore37.startAfter)(filters.lastDoc));
-        constraints.push((0, import_firestore37.limit)(filters.pagination));
+        constraints.push((0, import_firestore45.startAfter)(filters.lastDoc));
+        constraints.push((0, import_firestore45.limit)(filters.pagination));
       } else if (filters.pagination && filters.pagination > 0) {
-        constraints.push((0, import_firestore37.limit)(filters.pagination));
+        constraints.push((0, import_firestore45.limit)(filters.pagination));
       }
       let proceduresResult = [];
       let lastVisibleDoc = null;
@@ -12758,19 +15198,19 @@ var ProcedureService = class extends BaseService {
         for (const bound of bounds) {
           const geoConstraints = [
             ...constraints,
-            (0, import_firestore37.where)("clinicInfo.location.geohash", ">=", bound[0]),
-            (0, import_firestore37.where)("clinicInfo.location.geohash", "<=", bound[1])
+            (0, import_firestore45.where)("clinicInfo.location.geohash", ">=", bound[0]),
+            (0, import_firestore45.where)("clinicInfo.location.geohash", "<=", bound[1])
           ];
-          const q = (0, import_firestore37.query)(
-            (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION),
+          const q = (0, import_firestore45.query)(
+            (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION),
             ...geoConstraints
           );
-          const querySnapshot = await (0, import_firestore37.getDocs)(q);
+          const querySnapshot = await (0, import_firestore45.getDocs)(q);
           console.log(
             `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures in geo bound`
           );
-          for (const doc26 of querySnapshot.docs) {
-            const procedure = { ...doc26.data(), id: doc26.id };
+          for (const doc32 of querySnapshot.docs) {
+            const procedure = { ...doc32.data(), id: doc32.id };
             const distance = (0, import_geofire_common8.distanceBetween)(
               [center.latitude, center.longitude],
               [
@@ -12813,16 +15253,16 @@ var ProcedureService = class extends BaseService {
           proceduresResult = filteredProcedures;
         }
       } else {
-        const q = (0, import_firestore37.query)(
-          (0, import_firestore37.collection)(this.db, PROCEDURES_COLLECTION),
+        const q = (0, import_firestore45.query)(
+          (0, import_firestore45.collection)(this.db, PROCEDURES_COLLECTION),
           ...constraints
         );
-        const querySnapshot = await (0, import_firestore37.getDocs)(q);
+        const querySnapshot = await (0, import_firestore45.getDocs)(q);
         console.log(
           `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures with regular query`
         );
-        const procedures = querySnapshot.docs.map((doc26) => {
-          return { ...doc26.data(), id: doc26.id };
+        const procedures = querySnapshot.docs.map((doc32) => {
+          return { ...doc32.data(), id: doc32.id };
         });
         if (filters.location) {
           const center = filters.location;
@@ -12943,18 +15383,18 @@ var ProcedureService = class extends BaseService {
     if (!category || !subcategory || !technology) {
       throw new Error("One or more required base entities not found");
     }
-    const clinicRef = (0, import_firestore37.doc)(this.db, CLINICS_COLLECTION, data.clinicBranchId);
-    const clinicSnapshot = await (0, import_firestore37.getDoc)(clinicRef);
+    const clinicRef = (0, import_firestore45.doc)(this.db, CLINICS_COLLECTION, data.clinicBranchId);
+    const clinicSnapshot = await (0, import_firestore45.getDoc)(clinicRef);
     if (!clinicSnapshot.exists()) {
       throw new Error(`Clinic with ID ${data.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data();
-    const practitionerRef = (0, import_firestore37.doc)(
+    const practitionerRef = (0, import_firestore45.doc)(
       this.db,
       PRACTITIONERS_COLLECTION,
       data.practitionerId
     );
-    const practitionerSnapshot = await (0, import_firestore37.getDoc)(practitionerRef);
+    const practitionerSnapshot = await (0, import_firestore45.getDoc)(practitionerRef);
     if (!practitionerSnapshot.exists()) {
       throw new Error(`Practitioner with ID ${data.practitionerId} not found`);
     }
@@ -13025,19 +15465,19 @@ var ProcedureService = class extends BaseService {
       },
       isActive: true
     };
-    const procedureRef = (0, import_firestore37.doc)(this.db, PROCEDURES_COLLECTION, procedureId);
-    await (0, import_firestore37.setDoc)(procedureRef, {
+    const procedureRef = (0, import_firestore45.doc)(this.db, PROCEDURES_COLLECTION, procedureId);
+    await (0, import_firestore45.setDoc)(procedureRef, {
       ...newProcedure,
-      createdAt: (0, import_firestore37.serverTimestamp)(),
-      updatedAt: (0, import_firestore37.serverTimestamp)()
+      createdAt: (0, import_firestore45.serverTimestamp)(),
+      updatedAt: (0, import_firestore45.serverTimestamp)()
     });
-    const savedDoc = await (0, import_firestore37.getDoc)(procedureRef);
+    const savedDoc = await (0, import_firestore45.getDoc)(procedureRef);
     return savedDoc.data();
   }
 };
 
 // src/services/reviews/reviews.service.ts
-var import_firestore38 = require("firebase/firestore");
+var import_firestore46 = require("firebase/firestore");
 var import_zod25 = require("zod");
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
@@ -13117,11 +15557,11 @@ var ReviewService = class extends BaseService {
         updatedAt: now
       };
       reviewSchema.parse(review);
-      const docRef = (0, import_firestore38.doc)(this.db, REVIEWS_COLLECTION, reviewId);
-      await (0, import_firestore38.setDoc)(docRef, {
+      const docRef = (0, import_firestore46.doc)(this.db, REVIEWS_COLLECTION, reviewId);
+      await (0, import_firestore46.setDoc)(docRef, {
         ...review,
-        createdAt: (0, import_firestore38.serverTimestamp)(),
-        updatedAt: (0, import_firestore38.serverTimestamp)()
+        createdAt: (0, import_firestore46.serverTimestamp)(),
+        updatedAt: (0, import_firestore46.serverTimestamp)()
       });
       return review;
     } catch (error) {
@@ -13137,8 +15577,8 @@ var ReviewService = class extends BaseService {
    * @returns The review if found, null otherwise
    */
   async getReview(reviewId) {
-    const docRef = (0, import_firestore38.doc)(this.db, REVIEWS_COLLECTION, reviewId);
-    const docSnap = await (0, import_firestore38.getDoc)(docRef);
+    const docRef = (0, import_firestore46.doc)(this.db, REVIEWS_COLLECTION, reviewId);
+    const docSnap = await (0, import_firestore46.getDoc)(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -13150,12 +15590,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews for the patient
    */
   async getReviewsByPatient(patientId) {
-    const q = (0, import_firestore38.query)(
-      (0, import_firestore38.collection)(this.db, REVIEWS_COLLECTION),
-      (0, import_firestore38.where)("patientId", "==", patientId)
+    const q = (0, import_firestore46.query)(
+      (0, import_firestore46.collection)(this.db, REVIEWS_COLLECTION),
+      (0, import_firestore46.where)("patientId", "==", patientId)
     );
-    const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore46.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific clinic
@@ -13163,12 +15603,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews containing clinic reviews
    */
   async getReviewsByClinic(clinicId) {
-    const q = (0, import_firestore38.query)(
-      (0, import_firestore38.collection)(this.db, REVIEWS_COLLECTION),
-      (0, import_firestore38.where)("clinicReview.clinicId", "==", clinicId)
+    const q = (0, import_firestore46.query)(
+      (0, import_firestore46.collection)(this.db, REVIEWS_COLLECTION),
+      (0, import_firestore46.where)("clinicReview.clinicId", "==", clinicId)
     );
-    const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore46.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific practitioner
@@ -13176,12 +15616,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews containing practitioner reviews
    */
   async getReviewsByPractitioner(practitionerId) {
-    const q = (0, import_firestore38.query)(
-      (0, import_firestore38.collection)(this.db, REVIEWS_COLLECTION),
-      (0, import_firestore38.where)("practitionerReview.practitionerId", "==", practitionerId)
+    const q = (0, import_firestore46.query)(
+      (0, import_firestore46.collection)(this.db, REVIEWS_COLLECTION),
+      (0, import_firestore46.where)("practitionerReview.practitionerId", "==", practitionerId)
     );
-    const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore46.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific procedure
@@ -13189,12 +15629,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews containing procedure reviews
    */
   async getReviewsByProcedure(procedureId) {
-    const q = (0, import_firestore38.query)(
-      (0, import_firestore38.collection)(this.db, REVIEWS_COLLECTION),
-      (0, import_firestore38.where)("procedureReview.procedureId", "==", procedureId)
+    const q = (0, import_firestore46.query)(
+      (0, import_firestore46.collection)(this.db, REVIEWS_COLLECTION),
+      (0, import_firestore46.where)("procedureReview.procedureId", "==", procedureId)
     );
-    const snapshot = await (0, import_firestore38.getDocs)(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await (0, import_firestore46.getDocs)(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific appointment
@@ -13202,11 +15642,11 @@ var ReviewService = class extends BaseService {
    * @returns The review for the appointment if found, null otherwise
    */
   async getReviewByAppointment(appointmentId) {
-    const q = (0, import_firestore38.query)(
-      (0, import_firestore38.collection)(this.db, REVIEWS_COLLECTION),
-      (0, import_firestore38.where)("appointmentId", "==", appointmentId)
+    const q = (0, import_firestore46.query)(
+      (0, import_firestore46.collection)(this.db, REVIEWS_COLLECTION),
+      (0, import_firestore46.where)("appointmentId", "==", appointmentId)
     );
-    const snapshot = await (0, import_firestore38.getDocs)(q);
+    const snapshot = await (0, import_firestore46.getDocs)(q);
     if (snapshot.empty) {
       return null;
     }
@@ -13221,7 +15661,7 @@ var ReviewService = class extends BaseService {
     if (!review) {
       throw new Error(`Review with ID ${reviewId} not found`);
     }
-    await (0, import_firestore38.deleteDoc)((0, import_firestore38.doc)(this.db, REVIEWS_COLLECTION, reviewId));
+    await (0, import_firestore46.deleteDoc)((0, import_firestore46.doc)(this.db, REVIEWS_COLLECTION, reviewId));
   }
   /**
    * Calculates the average of an array of numbers
@@ -13240,11 +15680,11 @@ var ReviewService = class extends BaseService {
 
 // src/validations/calendar.schema.ts
 var import_zod27 = require("zod");
-var import_firestore40 = require("firebase/firestore");
+var import_firestore48 = require("firebase/firestore");
 
 // src/validations/profile-info.schema.ts
 var import_zod26 = require("zod");
-var import_firestore39 = require("firebase/firestore");
+var import_firestore47 = require("firebase/firestore");
 var clinicBranchInfoSchema = import_zod26.z.object({
   id: import_zod26.z.string(),
   featuredPhoto: import_zod26.z.string(),
@@ -13266,19 +15706,19 @@ var patientProfileInfoSchema = import_zod26.z.object({
   fullName: import_zod26.z.string(),
   email: import_zod26.z.string().email(),
   phone: import_zod26.z.string().nullable(),
-  dateOfBirth: import_zod26.z.instanceof(import_firestore39.Timestamp),
+  dateOfBirth: import_zod26.z.instanceof(import_firestore47.Timestamp),
   gender: import_zod26.z.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
-var MIN_APPOINTMENT_DURATION = 15;
+var MIN_APPOINTMENT_DURATION2 = 15;
 var calendarEventTimeSchema = import_zod27.z.object({
-  start: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore40.Timestamp)),
-  end: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore40.Timestamp))
+  start: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp)),
+  end: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp))
 }).refine(
   (data) => {
-    const startDate = data.start instanceof import_firestore40.Timestamp ? data.start.toDate() : data.start;
-    const endDate = data.end instanceof import_firestore40.Timestamp ? data.end.toDate() : data.end;
+    const startDate = data.start instanceof import_firestore48.Timestamp ? data.start.toDate() : data.start;
+    const endDate = data.end instanceof import_firestore48.Timestamp ? data.end.toDate() : data.end;
     return startDate < endDate;
   },
   {
@@ -13287,7 +15727,7 @@ var calendarEventTimeSchema = import_zod27.z.object({
   }
 ).refine(
   (data) => {
-    const startDate = data.start instanceof import_firestore40.Timestamp ? data.start.toDate() : data.start;
+    const startDate = data.start instanceof import_firestore48.Timestamp ? data.start.toDate() : data.start;
     return startDate > /* @__PURE__ */ new Date();
   },
   {
@@ -13306,12 +15746,12 @@ var timeSlotSchema2 = import_zod27.z.object({
 var syncedCalendarEventSchema = import_zod27.z.object({
   eventId: import_zod27.z.string(),
   syncedCalendarProvider: import_zod27.z.nativeEnum(SyncedCalendarProvider),
-  syncedAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore40.Timestamp))
+  syncedAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp))
 });
 var procedureInfoSchema = import_zod27.z.object({
   name: import_zod27.z.string(),
   description: import_zod27.z.string(),
-  duration: import_zod27.z.number().min(MIN_APPOINTMENT_DURATION),
+  duration: import_zod27.z.number().min(MIN_APPOINTMENT_DURATION2),
   price: import_zod27.z.number().min(0),
   currency: import_zod27.z.nativeEnum(Currency)
 });
@@ -13385,8 +15825,8 @@ var calendarEventSchema = import_zod27.z.object({
   status: import_zod27.z.nativeEnum(CalendarEventStatus),
   syncStatus: import_zod27.z.nativeEnum(CalendarSyncStatus),
   eventType: import_zod27.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore40.Timestamp)),
-  updatedAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore40.Timestamp))
+  createdAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp)),
+  updatedAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp))
 });
 var createBlockingEventSchema = import_zod27.z.object({
   entityType: import_zod27.z.enum(["practitioner", "clinic"]),
@@ -13629,7 +16069,7 @@ var updatePatientInstructionStatusSchema = import_zod30.z.object({
 
 // src/utils/TimestampUtils.ts
 var admin = __toESM(require("firebase-admin"));
-var import_firestore41 = require("firebase/firestore");
+var import_firestore49 = require("firebase/firestore");
 var IS_SERVER_ENV = process.env.NODE_ENV === "production" || process.env.FUNCTIONS_EMULATOR === "true" || process.env.FIREBASE_CONFIG !== void 0;
 var TimestampUtils = class {
   /**
@@ -13659,7 +16099,7 @@ var TimestampUtils = class {
     if (this.serverMode) {
       return adminTimestamp;
     }
-    return new import_firestore41.Timestamp(
+    return new import_firestore49.Timestamp(
       adminTimestamp.seconds,
       adminTimestamp.nanoseconds
     );
@@ -13704,14 +16144,14 @@ var TimestampUtils = class {
     if (this.serverMode) {
       return admin.firestore.Timestamp.fromDate(date);
     }
-    return import_firestore41.Timestamp.fromDate(date);
+    return import_firestore49.Timestamp.fromDate(date);
   }
   /**
    * @deprecated Use dateToTimestamp() instead for better cross-environment compatibility
    */
   static dateToClientTimestamp(date) {
     if (!date) return null;
-    return import_firestore41.Timestamp.fromDate(date);
+    return import_firestore49.Timestamp.fromDate(date);
   }
   /**
    * @deprecated Use dateToTimestamp() instead for better cross-environment compatibility
@@ -13741,7 +16181,7 @@ var TimestampUtils = class {
     if (obj instanceof admin.firestore.Timestamp) {
       return this.serverMode ? obj : this.adminToClient(obj);
     }
-    if (obj instanceof import_firestore41.Timestamp && this.serverMode) {
+    if (obj instanceof import_firestore49.Timestamp && this.serverMode) {
       return this.clientToAdmin(obj);
     }
     if (Array.isArray(obj)) {
@@ -13785,7 +16225,7 @@ var TimestampUtils = class {
     if (!obj || typeof obj !== "object") {
       return obj;
     }
-    if (obj instanceof import_firestore41.Timestamp) {
+    if (obj instanceof import_firestore49.Timestamp) {
       return this.clientToAdmin(obj);
     }
     if (Array.isArray(obj)) {
@@ -13810,7 +16250,7 @@ TimestampUtils.serverMode = IS_SERVER_ENV;
 
 // src/config/firebase.ts
 var import_app = require("firebase/app");
-var import_firestore42 = require("firebase/firestore");
+var import_firestore50 = require("firebase/firestore");
 var import_auth9 = require("firebase/auth");
 var import_analytics = require("firebase/analytics");
 var import_react_native = require("react-native");
@@ -13820,7 +16260,7 @@ var firebaseInstance = null;
 var initializeFirebase = (config) => {
   if (!firebaseInstance) {
     const app = (0, import_app.initializeApp)(config);
-    const db = (0, import_firestore42.getFirestore)(app);
+    const db = (0, import_firestore50.getFirestore)(app);
     const auth = (0, import_auth9.getAuth)(app);
     const storage = (0, import_storage4.getStorage)(app);
     const functions = (0, import_functions2.getFunctions)(app);
@@ -13875,6 +16315,7 @@ var getFirebaseFunctions = async () => {
   CLINIC_GROUPS_COLLECTION,
   CalendarEventStatus,
   CalendarEventType,
+  CalendarServiceV2,
   CalendarServiceV3,
   CalendarSyncStatus,
   ClinicAdminService,
@@ -13943,6 +16384,7 @@ var getFirebaseFunctions = async () => {
   USERS_COLLECTION,
   USER_FORMS_SUBCOLLECTION,
   UserRole,
+  UserService,
   addAllergySchema,
   addBlockingConditionSchema,
   addContraindicationSchema,