@blackcode_sa/metaestetics-api 1.8.1 → 1.8.3

package/dist/index.mjs

@@ -593,20 +593,20 @@ import {
 } from "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";
@@ -978,7 +978,7 @@ async function searchAppointmentsUtil(db, params) {
     const q = query(collection(db, APPOINTMENTS_COLLECTION), ...constraints);
     const querySnapshot = await 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 };
@@ -1785,7 +1785,7 @@ var AppointmentService = class extends BaseService {
       );
       const querySnapshot = await getDocs2(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(
@@ -1858,7 +1858,7 @@ var AppointmentService = class extends BaseService {
       );
       const querySnapshot = await getDocs2(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(
@@ -2589,11 +2589,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";
 
@@ -3167,7 +3167,7 @@ var MediaService = class extends BaseService {
     try {
       const querySnapshot = await getDocs3(finalQuery);
       const mediaList = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       console.log(`[MediaService] Found ${mediaList.length} media items.`);
       return mediaList;
@@ -3230,8 +3230,8 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
     }
     const patientsSnapshot = await getDocs4(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}`
@@ -3605,8 +3605,8 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
     }
     const patientsSnapshot = await getDocs5(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}`
@@ -4186,7 +4186,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     where6("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await getDocs6(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);
@@ -4867,9 +4867,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -4896,9 +4896,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -4915,9 +4915,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -4944,9 +4944,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -4963,9 +4963,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -4992,9 +4992,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -5011,9 +5011,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 getDoc10(getMedicalInfoDocRef(db, patientId));
-  if (!doc26.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc26.data();
+  const doc32 = await getDoc10(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");
   }
@@ -5316,7 +5316,7 @@ var searchPatientsUtil = async (db, params, requester) => {
     const finalQuery = query8(patientsCollectionRef, ...constraints);
     const querySnapshot = await getDocs8(finalQuery);
     const patients = querySnapshot.docs.map(
-      (doc26) => doc26.data()
+      (doc32) => doc32.data()
     );
     console.log(
       `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
@@ -5348,8 +5348,8 @@ var getAllPatientsUtil = async (db, options) => {
     }
     const patientsSnapshot = await getDocs8(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;
@@ -5482,7 +5482,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 = collection9(
@@ -5500,7 +5500,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
@@ -6623,7 +6623,7 @@ var PractitionerService = class extends BaseService {
       where10("expiresAt", ">", Timestamp14.now())
     );
     const querySnapshot = await getDocs10(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
@@ -6733,7 +6733,7 @@ var PractitionerService = class extends BaseService {
       where10("status", "==", "active" /* ACTIVE */)
     );
     const querySnapshot = await getDocs10(q);
-    return querySnapshot.docs.map((doc26) => doc26.data());
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
@@ -6745,7 +6745,7 @@ var PractitionerService = class extends BaseService {
       where10("isActive", "==", true)
     );
     const querySnapshot = await getDocs10(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
@@ -6757,7 +6757,7 @@ var PractitionerService = class extends BaseService {
       where10("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await getDocs10(q);
-    return querySnapshot.docs.map((doc26) => doc26.data());
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Updates a practitioner
@@ -6971,7 +6971,7 @@ var PractitionerService = class extends BaseService {
       );
       const querySnapshot = await getDocs10(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 {
@@ -7042,8 +7042,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() !== "") {
@@ -7527,7 +7527,7 @@ var UserService = class extends BaseService {
     ];
     const q = query11(collection11(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs11(q);
-    const users = querySnapshot.docs.map((doc26) => doc26.data());
+    const users = querySnapshot.docs.map((doc32) => doc32.data());
     return users.map((userData) => userSchema.parse(userData));
   }
   /**
@@ -7907,7 +7907,7 @@ async function getAllActiveGroups(db) {
     where12("isActive", "==", true)
   );
   const querySnapshot = await getDocs12(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 });
@@ -8372,7 +8372,7 @@ async function getClinicsByGroup(db, groupId) {
     where13("isActive", "==", true)
   );
   const querySnapshot = await getDocs13(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 });
@@ -8566,7 +8566,7 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   }
   const q = query13(collection13(db, CLINICS_COLLECTION), ...constraints);
   const querySnapshot = await getDocs13(q);
-  return querySnapshot.docs.map((doc26) => doc26.data());
+  return querySnapshot.docs.map((doc32) => doc32.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -8611,11 +8611,11 @@ async function getAllClinics(db, pagination, lastDoc) {
     }
     const clinicsSnapshot = await getDocs13(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 {
@@ -8642,8 +8642,8 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
     ];
     const q = query13(collection13(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs13(q);
-    for (const doc26 of querySnapshot.docs) {
-      const clinic = doc26.data();
+    for (const doc32 of querySnapshot.docs) {
+      const clinic = doc32.data();
       const distance = distanceBetween2(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -8765,8 +8765,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = query14(collection14(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs14(q);
-    for (const doc26 of querySnapshot.docs) {
-      const clinic = doc26.data();
+    for (const doc32 of querySnapshot.docs) {
+      const clinic = doc32.data();
       const distance = distanceBetween3(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -8862,8 +8862,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 = distanceBetween4(
           [center.latitude, center.longitude],
           [clinic.location.latitude, clinic.location.longitude]
@@ -8919,8 +8919,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) {
@@ -10238,14 +10238,23 @@ var AuthService = class extends BaseService {
   }
 };
 
-// src/services/calendar/calendar.v3.service.ts
-import { Timestamp as Timestamp21, serverTimestamp as serverTimestamp16 } from "firebase/firestore";
-import { doc as doc18, getDoc as getDoc21, setDoc as setDoc17, updateDoc as updateDoc18, deleteDoc as deleteDoc10 } from "firebase/firestore";
+// src/services/calendar/calendar.v2.service.ts
+import { Timestamp as Timestamp26, serverTimestamp as serverTimestamp20 } from "firebase/firestore";
+import {
+  doc as doc23,
+  getDoc as getDoc25,
+  collection as collection23,
+  query as query23,
+  where as where23,
+  getDocs as getDocs23,
+  setDoc as setDoc21,
+  updateDoc as updateDoc22
+} from "firebase/firestore";
 
-// src/services/calendar/utils/calendar-event.utils.ts
+// src/services/calendar/utils/clinic.utils.ts
 import {
   collection as collection18,
-  doc as doc17,
+  doc as doc18,
   getDoc as getDoc20,
   getDocs as getDocs18,
   setDoc as setDoc16,
@@ -10257,6 +10266,257 @@ import {
   Timestamp as Timestamp20,
   serverTimestamp as serverTimestamp15
 } from "firebase/firestore";
+
+// src/services/calendar/utils/docs.utils.ts
+import { doc as doc17 } from "firebase/firestore";
+function getPractitionerCalendarEventDocRef(db, practitionerId, eventId) {
+  return doc17(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getPatientCalendarEventDocRef(db, patientId, eventId) {
+  return doc17(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getClinicCalendarEventDocRef(db, clinicId, eventId) {
+  return doc17(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getPractitionerSyncedCalendarDocRef(db, practitionerId, syncedCalendarId) {
+  return doc17(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+function getPatientSyncedCalendarDocRef(db, patientId, syncedCalendarId) {
+  return doc17(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+function getClinicSyncedCalendarDocRef(db, clinicId, syncedCalendarId) {
+  return doc17(
+    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: serverTimestamp15(),
+    updatedAt: serverTimestamp15()
+  };
+  await setDoc16(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: Timestamp20.now(),
+    updatedAt: Timestamp20.now()
+  };
+}
+async function updateClinicCalendarEventUtil(db, clinicId, eventId, updateData) {
+  const eventRef = getClinicCalendarEventDocRef(db, clinicId, eventId);
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp15()
+  };
+  await updateDoc17(eventRef, updates);
+  const updatedDoc = await getDoc20(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+async function checkAutoConfirmAppointmentsUtil(db, clinicId) {
+  const clinicDoc = await getDoc20(doc18(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 getDoc20(
+    doc18(db, `${CLINIC_GROUPS_COLLECTION}/${clinicGroupId}`)
+  );
+  if (!clinicGroupDoc.exists()) {
+    return false;
+  }
+  const clinicGroupData = clinicGroupDoc.data();
+  return !!clinicGroupData.autoConfirmAppointments;
+}
+
+// src/services/calendar/utils/patient.utils.ts
+import {
+  collection as collection19,
+  getDoc as getDoc21,
+  getDocs as getDocs19,
+  setDoc as setDoc17,
+  updateDoc as updateDoc18,
+  deleteDoc as deleteDoc10,
+  query as query19,
+  where as where19,
+  orderBy as orderBy8,
+  Timestamp as Timestamp21,
+  serverTimestamp as serverTimestamp16
+} from "firebase/firestore";
+async function createPatientCalendarEventUtil(db, patientId, eventData, generateId2) {
+  const eventId = generateId2();
+  const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
+  const newEvent = {
+    id: eventId,
+    ...eventData,
+    createdAt: serverTimestamp16(),
+    updatedAt: serverTimestamp16()
+  };
+  await setDoc17(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: Timestamp21.now(),
+    updatedAt: Timestamp21.now()
+  };
+}
+async function updatePatientCalendarEventUtil(db, patientId, eventId, updateData) {
+  const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp16()
+  };
+  await updateDoc18(eventRef, updates);
+  const updatedDoc = await getDoc21(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+
+// src/services/calendar/utils/practitioner.utils.ts
+import {
+  collection as collection20,
+  getDoc as getDoc22,
+  getDocs as getDocs20,
+  setDoc as setDoc18,
+  updateDoc as updateDoc19,
+  deleteDoc as deleteDoc11,
+  query as query20,
+  where as where20,
+  orderBy as orderBy9,
+  Timestamp as Timestamp22,
+  serverTimestamp as serverTimestamp17
+} from "firebase/firestore";
+async function createPractitionerCalendarEventUtil(db, practitionerId, eventData, generateId2) {
+  const eventId = generateId2();
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  const newEvent = {
+    id: eventId,
+    ...eventData,
+    createdAt: serverTimestamp17(),
+    updatedAt: serverTimestamp17()
+  };
+  await setDoc18(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: Timestamp22.now(),
+    updatedAt: Timestamp22.now()
+  };
+}
+async function updatePractitionerCalendarEventUtil(db, practitionerId, eventId, updateData) {
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp17()
+  };
+  await updateDoc19(eventRef, updates);
+  const updatedDoc = await getDoc22(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
+import {
+  collection as collection21,
+  doc as doc21,
+  getDoc as getDoc23,
+  getDocs as getDocs21,
+  setDoc as setDoc19,
+  updateDoc as updateDoc20,
+  deleteDoc as deleteDoc12,
+  query as query21,
+  where as where21,
+  orderBy as orderBy10,
+  Timestamp as Timestamp23,
+  serverTimestamp as serverTimestamp18
+} from "firebase/firestore";
 async function searchCalendarEventsUtil(db, params) {
   const { searchLocation, entityId, ...filters } = params;
   let baseCollectionPath;
@@ -10268,88 +10528,2323 @@ 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(where21("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 = collection21(db, baseCollectionPath);
+  if (filters.clinicId) {
+    constraints.push(where21("clinicBranchId", "==", filters.clinicId));
+  }
+  if (filters.practitionerId) {
+    constraints.push(
+      where21("practitionerProfileId", "==", filters.practitionerId)
+    );
+  }
+  if (filters.patientId) {
+    constraints.push(where21("patientProfileId", "==", filters.patientId));
+  }
+  if (filters.procedureId) {
+    constraints.push(where21("procedureId", "==", filters.procedureId));
+  }
+  if (filters.eventStatus) {
+    constraints.push(where21("status", "==", filters.eventStatus));
+  }
+  if (filters.eventType) {
+    constraints.push(where21("eventType", "==", filters.eventType));
+  }
+  if (filters.dateRange) {
+    constraints.push(where21("eventTime.start", ">=", filters.dateRange.start));
+    constraints.push(where21("eventTime.start", "<=", filters.dateRange.end));
+  }
+  try {
+    const finalQuery = query21(collectionRef, ...constraints);
+    const querySnapshot = await getDocs21(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
+import {
+  collection as collection22,
+  getDoc as getDoc24,
+  getDocs as getDocs22,
+  setDoc as setDoc20,
+  updateDoc as updateDoc21,
+  deleteDoc as deleteDoc13,
+  query as query22,
+  orderBy as orderBy11,
+  Timestamp as Timestamp24,
+  serverTimestamp as serverTimestamp19
+} from "firebase/firestore";
+async function createPractitionerSyncedCalendarUtil(db, practitionerId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp19(),
+    updatedAt: serverTimestamp19()
+  };
+  await setDoc20(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: Timestamp24.now(),
+    updatedAt: Timestamp24.now()
+  };
+}
+async function createPatientSyncedCalendarUtil(db, patientId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp19(),
+    updatedAt: serverTimestamp19()
+  };
+  await setDoc20(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: Timestamp24.now(),
+    updatedAt: Timestamp24.now()
+  };
+}
+async function createClinicSyncedCalendarUtil(db, clinicId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp19(),
+    updatedAt: serverTimestamp19()
+  };
+  await setDoc20(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: Timestamp24.now(),
+    updatedAt: Timestamp24.now()
+  };
+}
+async function getPractitionerSyncedCalendarUtil(db, practitionerId, calendarId) {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const calendarDoc = await getDoc24(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
+  const calendarsRef = collection22(
+    db,
+    `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = query22(calendarsRef, orderBy11("createdAt", "desc"));
+  const querySnapshot = await getDocs22(q);
+  return querySnapshot.docs.map((doc32) => doc32.data());
+}
+async function getPatientSyncedCalendarUtil(db, patientId, calendarId) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const calendarDoc = await getDoc24(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getPatientSyncedCalendarsUtil(db, patientId) {
+  const calendarsRef = collection22(
+    db,
+    `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = query22(calendarsRef, orderBy11("createdAt", "desc"));
+  const querySnapshot = await getDocs22(q);
+  return querySnapshot.docs.map((doc32) => doc32.data());
+}
+async function getClinicSyncedCalendarUtil(db, clinicId, calendarId) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const calendarDoc = await getDoc24(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getClinicSyncedCalendarsUtil(db, clinicId) {
+  const calendarsRef = collection22(
+    db,
+    `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = query22(calendarsRef, orderBy11("createdAt", "desc"));
+  const querySnapshot = await getDocs22(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: serverTimestamp19()
+  };
+  await updateDoc21(calendarRef, updates);
+  const updatedDoc = await getDoc24(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: serverTimestamp19()
+  };
+  await updateDoc21(calendarRef, updates);
+  const updatedDoc = await getDoc24(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: serverTimestamp19()
+  };
+  await updateDoc21(calendarRef, updates);
+  const updatedDoc = await getDoc24(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 deleteDoc13(calendarRef);
+}
+async function deletePatientSyncedCalendarUtil(db, patientId, calendarId) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  await deleteDoc13(calendarRef);
+}
+async function deleteClinicSyncedCalendarUtil(db, clinicId, calendarId) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  await deleteDoc13(calendarRef);
+}
+async function updateLastSyncedTimestampUtil(db, entityType, entityId, calendarId) {
+  const updateData = {
+    lastSyncedAt: Timestamp24.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
+import { Timestamp as Timestamp25 } from "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: Timestamp25.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: Timestamp25.fromDate(start),
+      end: Timestamp25.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: Timestamp25.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 = Timestamp26.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 = doc23(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      const newEvent = {
+        id: eventId,
+        ...eventData,
+        createdAt: serverTimestamp20(),
+        updatedAt: serverTimestamp20()
+      };
+      await setDoc21(eventRef, newEvent);
+      return {
+        ...newEvent,
+        createdAt: Timestamp26.now(),
+        updatedAt: Timestamp26.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 = collection23(this.db, PRACTITIONERS_COLLECTION);
+      const practitionersSnapshot = await getDocs23(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 = collection23(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION
+      );
+      const q = query23(
+        eventsRef,
+        where23("syncStatus", "==", "external" /* EXTERNAL */),
+        where23("eventTime.start", ">=", Timestamp26.fromDate(startDate)),
+        where23("eventTime.start", "<=", Timestamp26.fromDate(endDate))
+      );
+      const eventsSnapshot = await getDocs23(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 = doc23(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      await updateDoc22(eventRef, {
+        eventName: externalEvent.summary || "External Event",
+        eventTime: {
+          start: Timestamp26.fromDate(startTime),
+          end: Timestamp26.fromDate(endTime)
+        },
+        description: externalEvent.description || "",
+        updatedAt: serverTimestamp20()
+      });
+      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 = doc23(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      await updateDoc22(eventRef, {
+        status,
+        updatedAt: serverTimestamp20()
+      });
+      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: Timestamp26.fromDate(startDate),
+      end: Timestamp26.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: Timestamp26.fromDate(startDate),
+      end: Timestamp26.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: Timestamp26.fromDate(startDate),
+      end: Timestamp26.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 = doc23(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await getDoc25(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 = doc23(this.db, baseCollectionPath, appointmentId);
+    const appointmentDoc = await getDoc25(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(where18("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: Timestamp26.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 = collection18(db, baseCollectionPath);
-  if (filters.clinicId) {
-    constraints.push(where18("clinicBranchId", "==", filters.clinicId));
+    } catch (error) {
+      console.error(`Error syncing with ${entityType}'s calendar:`, error);
+    }
   }
-  if (filters.practitionerId) {
-    constraints.push(
-      where18("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 = doc23(this.db, collectionPath, eventId);
+      const eventDoc = await getDoc25(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 updateDoc22(eventRef, {
+          syncedCalendarEventId: syncIds,
+          updatedAt: serverTimestamp20()
+        });
+        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(where18("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(where18("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 = doc23(this.db, CLINICS_COLLECTION, clinicId);
+    const clinicDoc = await getDoc25(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(where18("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 = doc23(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await getDoc25(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(where18("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 = collection23(this.db, CALENDAR_COLLECTION);
+    const q = query23(
+      appointmentsRef,
+      where23("practitionerProfileId", "==", doctorId),
+      where23("eventTime.start", ">=", Timestamp26.fromDate(startOfDay)),
+      where23("eventTime.start", "<=", Timestamp26.fromDate(endOfDay)),
+      where23("status", "in", [
+        "confirmed" /* CONFIRMED */,
+        "pending" /* PENDING */
+      ])
+    );
+    const querySnapshot = await getDocs23(q);
+    return querySnapshot.docs.map((doc32) => doc32.data());
   }
-  if (filters.dateRange) {
-    constraints.push(where18("eventTime.start", ">=", filters.dateRange.start));
-    constraints.push(where18("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 = query18(collectionRef, ...constraints);
-    const querySnapshot = await getDocs18(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([
+        getDoc25(doc23(this.db, CLINICS_COLLECTION, clinicId)),
+        getDoc25(doc23(this.db, PRACTITIONERS_COLLECTION, doctorId)),
+        getDoc25(doc23(this.db, PATIENTS_COLLECTION, patientId)),
+        getDoc25(
+          doc23(
+            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 || Timestamp26.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 || Timestamp26.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
+import { Timestamp as Timestamp27, serverTimestamp as serverTimestamp21 } from "firebase/firestore";
+import { doc as doc24, getDoc as getDoc26, setDoc as setDoc22, updateDoc as updateDoc23, deleteDoc as deleteDoc14 } from "firebase/firestore";
 var CalendarServiceV3 = class extends BaseService {
   /**
    * Creates a new CalendarServiceV3 instance
@@ -10373,7 +12868,7 @@ var CalendarServiceV3 = class extends BaseService {
       params.entityType,
       params.entityId
     );
-    const eventRef = doc18(this.db, collectionPath, eventId);
+    const eventRef = doc24(this.db, collectionPath, eventId);
     const eventData = {
       id: eventId,
       eventName: params.eventName,
@@ -10383,19 +12878,19 @@ var CalendarServiceV3 = class extends BaseService {
       status: "confirmed" /* CONFIRMED */,
       // Blocking events are always confirmed
       syncStatus: "internal" /* INTERNAL */,
-      createdAt: serverTimestamp16(),
-      updatedAt: serverTimestamp16()
+      createdAt: serverTimestamp21(),
+      updatedAt: serverTimestamp21()
     };
     if (params.entityType === "practitioner") {
       eventData.practitionerProfileId = params.entityId;
     } else {
       eventData.clinicBranchId = params.entityId;
     }
-    await setDoc17(eventRef, eventData);
+    await setDoc22(eventRef, eventData);
     return {
       ...eventData,
-      createdAt: Timestamp21.now(),
-      updatedAt: Timestamp21.now()
+      createdAt: Timestamp27.now(),
+      updatedAt: Timestamp27.now()
     };
   }
   /**
@@ -10408,13 +12903,13 @@ var CalendarServiceV3 = class extends BaseService {
       params.entityType,
       params.entityId
     );
-    const eventRef = doc18(this.db, collectionPath, params.eventId);
-    const eventDoc = await getDoc21(eventRef);
+    const eventRef = doc24(this.db, collectionPath, params.eventId);
+    const eventDoc = await getDoc26(eventRef);
     if (!eventDoc.exists()) {
       throw new Error(`Blocking event with ID ${params.eventId} not found`);
     }
     const updateData = {
-      updatedAt: serverTimestamp16()
+      updatedAt: serverTimestamp21()
     };
     if (params.eventName !== void 0) {
       updateData.eventName = params.eventName;
@@ -10428,8 +12923,8 @@ var CalendarServiceV3 = class extends BaseService {
     if (params.status !== void 0) {
       updateData.status = params.status;
     }
-    await updateDoc18(eventRef, updateData);
-    const updatedEventDoc = await getDoc21(eventRef);
+    await updateDoc23(eventRef, updateData);
+    const updatedEventDoc = await getDoc26(eventRef);
     return updatedEventDoc.data();
   }
   /**
@@ -10440,12 +12935,12 @@ var CalendarServiceV3 = class extends BaseService {
    */
   async deleteBlockingEvent(entityType, entityId, eventId) {
     const collectionPath = this.getEntityCalendarPath(entityType, entityId);
-    const eventRef = doc18(this.db, collectionPath, eventId);
-    const eventDoc = await getDoc21(eventRef);
+    const eventRef = doc24(this.db, collectionPath, eventId);
+    const eventDoc = await getDoc26(eventRef);
     if (!eventDoc.exists()) {
       throw new Error(`Blocking event with ID ${eventId} not found`);
     }
-    await deleteDoc10(eventRef);
+    await deleteDoc14(eventRef);
   }
   /**
    * Gets a specific blocking event
@@ -10456,8 +12951,8 @@ var CalendarServiceV3 = class extends BaseService {
    */
   async getBlockingEvent(entityType, entityId, eventId) {
     const collectionPath = this.getEntityCalendarPath(entityType, entityId);
-    const eventRef = doc18(this.db, collectionPath, eventId);
-    const eventDoc = await getDoc21(eventRef);
+    const eventRef = doc24(this.db, collectionPath, eventId);
+    const eventDoc = await getDoc26(eventRef);
     if (!eventDoc.exists()) {
       return null;
     }
@@ -10651,18 +13146,18 @@ var ExternalCalendarService = class extends BaseService {
 
 // src/services/clinic/practitioner-invite.service.ts
 import {
-  collection as collection19,
-  doc as doc19,
-  getDoc as getDoc22,
-  getDocs as getDocs19,
-  query as query19,
-  where as where19,
-  updateDoc as updateDoc19,
-  setDoc as setDoc18,
-  deleteDoc as deleteDoc11,
-  Timestamp as Timestamp22,
-  serverTimestamp as serverTimestamp17,
-  orderBy as orderBy8,
+  collection as collection24,
+  doc as doc25,
+  getDoc as getDoc27,
+  getDocs as getDocs24,
+  query as query24,
+  where as where24,
+  updateDoc as updateDoc24,
+  setDoc as setDoc23,
+  deleteDoc as deleteDoc15,
+  Timestamp as Timestamp28,
+  serverTimestamp as serverTimestamp22,
+  orderBy as orderBy12,
   limit as limit11
 } from "firebase/firestore";
 var PractitionerInviteService = class extends BaseService {
@@ -10726,7 +13221,7 @@ var PractitionerInviteService = class extends BaseService {
         message: message || null,
         status: "pending" /* PENDING */
       };
-      const now = Timestamp22.now();
+      const now = Timestamp28.now();
       const invite = {
         id: inviteId,
         ...inviteData,
@@ -10737,8 +13232,8 @@ var PractitionerInviteService = class extends BaseService {
         rejectedAt: null,
         cancelledAt: null
       };
-      const docRef = doc19(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await setDoc18(docRef, invite);
+      const docRef = doc25(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await setDoc23(docRef, invite);
       return invite;
     } catch (error) {
       console.error(
@@ -10757,18 +13252,18 @@ var PractitionerInviteService = class extends BaseService {
   async getAllInvitesDoctor(practitionerId, statusFilter) {
     try {
       const constraints = [
-        where19("practitionerId", "==", practitionerId),
-        orderBy8("createdAt", "desc")
+        where24("practitionerId", "==", practitionerId),
+        orderBy12("createdAt", "desc")
       ];
       if (statusFilter && statusFilter.length > 0) {
-        constraints.push(where19("status", "in", statusFilter));
+        constraints.push(where24("status", "in", statusFilter));
       }
-      const q = query19(
-        collection19(this.db, PRACTITIONER_INVITES_COLLECTION),
+      const q = query24(
+        collection24(this.db, PRACTITIONER_INVITES_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await getDocs19(q);
-      return querySnapshot.docs.map((doc26) => doc26.data());
+      const querySnapshot = await getDocs24(q);
+      return querySnapshot.docs.map((doc32) => doc32.data());
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error getting doctor invites:",
@@ -10786,18 +13281,18 @@ var PractitionerInviteService = class extends BaseService {
   async getAllInvitesClinic(clinicId, statusFilter) {
     try {
       const constraints = [
-        where19("clinicId", "==", clinicId),
-        orderBy8("createdAt", "desc")
+        where24("clinicId", "==", clinicId),
+        orderBy12("createdAt", "desc")
       ];
       if (statusFilter && statusFilter.length > 0) {
-        constraints.push(where19("status", "in", statusFilter));
+        constraints.push(where24("status", "in", statusFilter));
       }
-      const q = query19(
-        collection19(this.db, PRACTITIONER_INVITES_COLLECTION),
+      const q = query24(
+        collection24(this.db, PRACTITIONER_INVITES_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await getDocs19(q);
-      return querySnapshot.docs.map((doc26) => doc26.data());
+      const querySnapshot = await getDocs24(q);
+      return querySnapshot.docs.map((doc32) => doc32.data());
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error getting clinic invites:",
@@ -10822,11 +13317,11 @@ var PractitionerInviteService = class extends BaseService {
       }
       const updateData = {
         status: "accepted" /* ACCEPTED */,
-        acceptedAt: Timestamp22.now(),
-        updatedAt: serverTimestamp17()
+        acceptedAt: Timestamp28.now(),
+        updatedAt: serverTimestamp22()
       };
-      const docRef = doc19(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await updateDoc19(docRef, updateData);
+      const docRef = doc25(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await updateDoc24(docRef, updateData);
       return await this.getInviteById(inviteId);
     } catch (error) {
       console.error(
@@ -10854,11 +13349,11 @@ var PractitionerInviteService = class extends BaseService {
       const updateData = {
         status: "rejected" /* REJECTED */,
         rejectionReason: rejectionReason || null,
-        rejectedAt: Timestamp22.now(),
-        updatedAt: serverTimestamp17()
+        rejectedAt: Timestamp28.now(),
+        updatedAt: serverTimestamp22()
       };
-      const docRef = doc19(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await updateDoc19(docRef, updateData);
+      const docRef = doc25(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await updateDoc24(docRef, updateData);
       return await this.getInviteById(inviteId);
     } catch (error) {
       console.error(
@@ -10886,11 +13381,11 @@ var PractitionerInviteService = class extends BaseService {
       const updateData = {
         status: "cancelled" /* CANCELLED */,
         cancelReason: cancelReason || null,
-        cancelledAt: Timestamp22.now(),
-        updatedAt: serverTimestamp17()
+        cancelledAt: Timestamp28.now(),
+        updatedAt: serverTimestamp22()
       };
-      const docRef = doc19(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await updateDoc19(docRef, updateData);
+      const docRef = doc25(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await updateDoc24(docRef, updateData);
       return await this.getInviteById(inviteId);
     } catch (error) {
       console.error(
@@ -10907,8 +13402,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async getInviteById(inviteId) {
     try {
-      const docRef = doc19(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      const docSnap = await getDoc22(docRef);
+      const docRef = doc25(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      const docSnap = await getDoc27(docRef);
       if (docSnap.exists()) {
         return docSnap.data();
       }
@@ -10930,30 +13425,30 @@ var PractitionerInviteService = class extends BaseService {
     try {
       const constraints = [];
       if (filters.practitionerId) {
-        constraints.push(where19("practitionerId", "==", filters.practitionerId));
+        constraints.push(where24("practitionerId", "==", filters.practitionerId));
       }
       if (filters.clinicId) {
-        constraints.push(where19("clinicId", "==", filters.clinicId));
+        constraints.push(where24("clinicId", "==", filters.clinicId));
       }
       if (filters.invitedBy) {
-        constraints.push(where19("invitedBy", "==", filters.invitedBy));
+        constraints.push(where24("invitedBy", "==", filters.invitedBy));
       }
       if (filters.status && filters.status.length > 0) {
-        constraints.push(where19("status", "in", filters.status));
+        constraints.push(where24("status", "in", filters.status));
       }
       const orderField = filters.orderBy || "createdAt";
       const orderDirection = filters.orderDirection || "desc";
-      constraints.push(orderBy8(orderField, orderDirection));
+      constraints.push(orderBy12(orderField, orderDirection));
       if (filters.limit) {
         constraints.push(limit11(filters.limit));
       }
-      const q = query19(
-        collection19(this.db, PRACTITIONER_INVITES_COLLECTION),
+      const q = query24(
+        collection24(this.db, PRACTITIONER_INVITES_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await getDocs19(q);
+      const querySnapshot = await getDocs24(q);
       let invites = querySnapshot.docs.map(
-        (doc26) => doc26.data()
+        (doc32) => doc32.data()
       );
       if (filters.fromDate) {
         invites = invites.filter(
@@ -10980,8 +13475,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async deleteInvite(inviteId) {
     try {
-      const docRef = doc19(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await deleteDoc11(docRef);
+      const docRef = doc25(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await deleteDoc15(docRef);
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error deleting invite:",
@@ -10998,8 +13493,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async getPractitionerById(practitionerId) {
     try {
-      const docRef = doc19(this.db, PRACTITIONERS_COLLECTION, practitionerId);
-      const docSnap = await getDoc22(docRef);
+      const docRef = doc25(this.db, PRACTITIONERS_COLLECTION, practitionerId);
+      const docSnap = await getDoc27(docRef);
       return docSnap.exists() ? docSnap.data() : null;
     } catch (error) {
       console.error(
@@ -11016,8 +13511,8 @@ var PractitionerInviteService = class extends BaseService {
    */
   async getClinicById(clinicId) {
     try {
-      const docRef = doc19(this.db, CLINICS_COLLECTION, clinicId);
-      const docSnap = await getDoc22(docRef);
+      const docRef = doc25(this.db, CLINICS_COLLECTION, clinicId);
+      const docSnap = await getDoc27(docRef);
       return docSnap.exists() ? docSnap.data() : null;
     } catch (error) {
       console.error("[PractitionerInviteService] Error getting clinic:", error);
@@ -11032,14 +13527,14 @@ var PractitionerInviteService = class extends BaseService {
    */
   async findExistingInvite(practitionerId, clinicId) {
     try {
-      const q = query19(
-        collection19(this.db, PRACTITIONER_INVITES_COLLECTION),
-        where19("practitionerId", "==", practitionerId),
-        where19("clinicId", "==", clinicId),
-        orderBy8("createdAt", "desc"),
+      const q = query24(
+        collection24(this.db, PRACTITIONER_INVITES_COLLECTION),
+        where24("practitionerId", "==", practitionerId),
+        where24("clinicId", "==", clinicId),
+        orderBy12("createdAt", "desc"),
         limit11(1)
       );
-      const querySnapshot = await getDocs19(q);
+      const querySnapshot = await getDocs24(q);
       if (querySnapshot.empty) {
         return null;
       }
@@ -11056,23 +13551,23 @@ var PractitionerInviteService = class extends BaseService {
 
 // src/services/documentation-templates/documentation-template.service.ts
 import {
-  collection as collection20,
-  doc as doc20,
-  getDoc as getDoc23,
-  getDocs as getDocs20,
-  setDoc as setDoc19,
-  updateDoc as updateDoc20,
-  deleteDoc as deleteDoc12,
-  query as query20,
-  where as where20,
-  orderBy as orderBy9,
+  collection as collection25,
+  doc as doc26,
+  getDoc as getDoc28,
+  getDocs as getDocs25,
+  setDoc as setDoc24,
+  updateDoc as updateDoc25,
+  deleteDoc as deleteDoc16,
+  query as query25,
+  where as where25,
+  orderBy as orderBy13,
   limit as limit12,
   startAfter as startAfter10
 } from "firebase/firestore";
 var DocumentationTemplateService = class extends BaseService {
   constructor() {
     super(...arguments);
-    this.collectionRef = collection20(
+    this.collectionRef = collection25(
       this.db,
       DOCUMENTATION_TEMPLATES_COLLECTION
     );
@@ -11106,8 +13601,8 @@ var DocumentationTemplateService = class extends BaseService {
       isRequired: validatedData.isRequired || false,
       sortingOrder: validatedData.sortingOrder || 0
     };
-    const docRef = doc20(this.collectionRef, templateId);
-    await setDoc19(docRef, template);
+    const docRef = doc26(this.collectionRef, templateId);
+    await setDoc24(docRef, template);
     return template;
   }
   /**
@@ -11117,8 +13612,8 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns The template or null if not found
    */
   async getTemplateById(templateId, version) {
-    const docRef = doc20(this.collectionRef, templateId);
-    const docSnap = await getDoc23(docRef);
+    const docRef = doc26(this.collectionRef, templateId);
+    const docSnap = await getDoc28(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -11156,15 +13651,15 @@ var DocumentationTemplateService = class extends BaseService {
     if (!template) {
       throw new Error(`Template with ID ${templateId} not found`);
     }
-    const versionsCollectionRef = collection20(
+    const versionsCollectionRef = collection25(
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
     );
-    const versionDocRef = doc20(
+    const versionDocRef = doc26(
       versionsCollectionRef,
       template.version.toString()
     );
-    await setDoc19(versionDocRef, template);
+    await setDoc24(versionDocRef, template);
     let updatedElements = template.elements;
     if (validatedData.elements) {
       updatedElements = validatedData.elements.map((element) => ({
@@ -11188,9 +13683,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 = doc20(this.collectionRef, templateId);
+    const docRef = doc26(this.collectionRef, templateId);
     console.log("Update payload", updatePayload);
-    await updateDoc20(docRef, updatePayload);
+    await updateDoc25(docRef, updatePayload);
     return { ...template, ...updatePayload };
   }
   /**
@@ -11200,11 +13695,11 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns The template version or null if not found
    */
   async getTemplateVersion(templateId, versionNumber) {
-    const versionDocRef = doc20(
+    const versionDocRef = doc26(
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions/${versionNumber}`
     );
-    const versionDocSnap = await getDoc23(versionDocRef);
+    const versionDocSnap = await getDoc28(versionDocRef);
     if (!versionDocSnap.exists()) {
       return null;
     }
@@ -11216,15 +13711,15 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of template versions
    */
   async getTemplateOldVersions(templateId) {
-    const versionsCollectionRef = collection20(
+    const versionsCollectionRef = collection25(
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
     );
-    const q = query20(versionsCollectionRef, orderBy9("version", "desc"));
-    const querySnapshot = await getDocs20(q);
+    const q = query25(versionsCollectionRef, orderBy13("version", "desc"));
+    const querySnapshot = await getDocs25(q);
     const versions = [];
-    querySnapshot.forEach((doc26) => {
-      versions.push(doc26.data());
+    querySnapshot.forEach((doc32) => {
+      versions.push(doc32.data());
     });
     return versions;
   }
@@ -11233,8 +13728,8 @@ var DocumentationTemplateService = class extends BaseService {
    * @param templateId - ID of the template to delete
    */
   async deleteTemplate(templateId) {
-    const docRef = doc20(this.collectionRef, templateId);
-    await deleteDoc12(docRef);
+    const docRef = doc26(this.collectionRef, templateId);
+    await deleteDoc16(docRef);
   }
   /**
    * Get all active templates
@@ -11243,21 +13738,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getActiveTemplates(pageSize = 20, lastDoc) {
-    let q = query20(
+    let q = query25(
       this.collectionRef,
-      where20("isActive", "==", true),
-      orderBy9("updatedAt", "desc"),
+      where25("isActive", "==", true),
+      orderBy13("updatedAt", "desc"),
       limit12(pageSize)
     );
     if (lastDoc) {
-      q = query20(q, startAfter10(lastDoc));
+      q = query25(q, startAfter10(lastDoc));
     }
-    const querySnapshot = await getDocs20(q);
+    const querySnapshot = await getDocs25(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,
@@ -11272,22 +13767,22 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
-    let q = query20(
+    let q = query25(
       this.collectionRef,
-      where20("isActive", "==", true),
-      where20("tags", "array-contains-any", tags),
-      orderBy9("updatedAt", "desc"),
+      where25("isActive", "==", true),
+      where25("tags", "array-contains-any", tags),
+      orderBy13("updatedAt", "desc"),
       limit12(pageSize)
     );
     if (lastDoc) {
-      q = query20(q, startAfter10(lastDoc));
+      q = query25(q, startAfter10(lastDoc));
     }
-    const querySnapshot = await getDocs20(q);
+    const querySnapshot = await getDocs25(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,
@@ -11302,21 +13797,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
-    let q = query20(
+    let q = query25(
       this.collectionRef,
-      where20("createdBy", "==", userId),
-      orderBy9("updatedAt", "desc"),
+      where25("createdBy", "==", userId),
+      orderBy13("updatedAt", "desc"),
       limit12(pageSize)
     );
     if (lastDoc) {
-      q = query20(q, startAfter10(lastDoc));
+      q = query25(q, startAfter10(lastDoc));
     }
-    const querySnapshot = await getDocs20(q);
+    const querySnapshot = await getDocs25(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,
@@ -11329,21 +13824,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates
    */
   async getAllTemplatesForSelection(options) {
-    let q = query20(
+    let q = query25(
       this.collectionRef,
-      where20("isActive", "==", true),
-      orderBy9("updatedAt", "desc")
+      where25("isActive", "==", true),
+      orderBy13("updatedAt", "desc")
     );
     if ((options == null ? void 0 : options.isUserForm) !== void 0) {
-      q = query20(q, where20("isUserForm", "==", options.isUserForm));
+      q = query25(q, where25("isUserForm", "==", options.isUserForm));
     }
     if ((options == null ? void 0 : options.isRequired) !== void 0) {
-      q = query20(q, where20("isRequired", "==", options.isRequired));
+      q = query25(q, where25("isRequired", "==", options.isRequired));
     }
-    const querySnapshot = await getDocs20(q);
+    const querySnapshot = await getDocs25(q);
     const templates = [];
-    querySnapshot.forEach((doc26) => {
-      templates.push(doc26.data());
+    querySnapshot.forEach((doc32) => {
+      templates.push(doc32.data());
     });
     return templates;
   }
@@ -11351,14 +13846,14 @@ var DocumentationTemplateService = class extends BaseService {
 
 // src/services/documentation-templates/filled-document.service.ts
 import {
-  collection as collection21,
-  doc as doc21,
-  getDoc as getDoc24,
-  getDocs as getDocs21,
-  setDoc as setDoc20,
-  updateDoc as updateDoc21,
-  query as query21,
-  orderBy as orderBy10,
+  collection as collection26,
+  doc as doc27,
+  getDoc as getDoc29,
+  getDocs as getDocs26,
+  setDoc as setDoc25,
+  updateDoc as updateDoc26,
+  query as query26,
+  orderBy as orderBy14,
   limit as limit13,
   startAfter as startAfter11
 } from "firebase/firestore";
@@ -11416,7 +13911,7 @@ var FilledDocumentService = class extends BaseService {
       values: initialValues,
       status: initialStatus
     };
-    const docRef = doc21(
+    const docRef = doc27(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
@@ -11424,7 +13919,7 @@ var FilledDocumentService = class extends BaseService {
       formSubcollection,
       documentId3
     );
-    await setDoc20(docRef, filledDocument);
+    await setDoc25(docRef, filledDocument);
     return filledDocument;
   }
   /**
@@ -11436,7 +13931,7 @@ var FilledDocumentService = class extends BaseService {
    */
   async getFilledDocumentFromAppointmentById(appointmentId, formId, isUserForm) {
     const formSubcollection = this.getFormSubcollectionPath(isUserForm);
-    const docRef = doc21(
+    const docRef = doc27(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
@@ -11444,7 +13939,7 @@ var FilledDocumentService = class extends BaseService {
       formSubcollection,
       formId
     );
-    const docSnap = await getDoc24(docRef);
+    const docSnap = await getDoc29(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -11461,7 +13956,7 @@ var FilledDocumentService = class extends BaseService {
    */
   async updateFilledDocumentInAppointment(appointmentId, formId, isUserForm, values, status) {
     const formSubcollection = this.getFormSubcollectionPath(isUserForm);
-    const docRef = doc21(
+    const docRef = doc27(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
@@ -11493,7 +13988,7 @@ var FilledDocumentService = class extends BaseService {
     }
     if (Object.keys(updatePayload).length === 1 && "updatedAt" in updatePayload) {
     }
-    await updateDoc21(docRef, updatePayload);
+    await updateDoc26(docRef, updatePayload);
     return { ...existingDoc, ...updatePayload };
   }
   /**
@@ -11503,20 +13998,20 @@ var FilledDocumentService = class extends BaseService {
    * @param lastDoc Last document from previous page for pagination.
    */
   async getFilledUserFormsForAppointment(appointmentId, pageSize = 20, lastDoc) {
-    const subcollectionRef = collection21(
+    const subcollectionRef = collection26(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
       appointmentId,
       USER_FORMS_SUBCOLLECTION
     );
-    let q = query21(
+    let q = query26(
       subcollectionRef,
-      orderBy10("updatedAt", "desc"),
+      orderBy14("updatedAt", "desc"),
       limit13(pageSize)
     );
     if (lastDoc) {
-      q = query21(q, startAfter11(lastDoc));
+      q = query26(q, startAfter11(lastDoc));
     }
     return this.executeQuery(q);
   }
@@ -11527,31 +14022,31 @@ var FilledDocumentService = class extends BaseService {
    * @param lastDoc Last document from previous page for pagination.
    */
   async getFilledDoctorFormsForAppointment(appointmentId, pageSize = 20, lastDoc) {
-    const subcollectionRef = collection21(
+    const subcollectionRef = collection26(
       this.db,
       APPOINTMENTS_COLLECTION,
       // Replaced "appointments"
       appointmentId,
       DOCTOR_FORMS_SUBCOLLECTION
     );
-    let q = query21(
+    let q = query26(
       subcollectionRef,
-      orderBy10("updatedAt", "desc"),
+      orderBy14("updatedAt", "desc"),
       limit13(pageSize)
     );
     if (lastDoc) {
-      q = query21(q, startAfter11(lastDoc));
+      q = query26(q, startAfter11(lastDoc));
     }
     return this.executeQuery(q);
   }
   // Helper to execute query and return documents + lastDoc
   async executeQuery(q) {
-    const querySnapshot = await getDocs21(q);
+    const querySnapshot = await getDocs26(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,
@@ -11711,16 +14206,16 @@ var FilledDocumentService = class extends BaseService {
 
 // src/services/notifications/notification.service.ts
 import {
-  collection as collection22,
-  doc as doc22,
-  getDoc as getDoc25,
-  getDocs as getDocs22,
-  query as query22,
-  where as where22,
-  updateDoc as updateDoc22,
-  deleteDoc as deleteDoc13,
-  orderBy as orderBy11,
-  Timestamp as Timestamp24,
+  collection as collection27,
+  doc as doc28,
+  getDoc as getDoc30,
+  getDocs as getDocs27,
+  query as query27,
+  where as where27,
+  updateDoc as updateDoc27,
+  deleteDoc as deleteDoc17,
+  orderBy as orderBy15,
+  Timestamp as Timestamp30,
   addDoc as addDoc2,
   writeBatch as writeBatch5
 } from "firebase/firestore";
@@ -11729,8 +14224,8 @@ var NotificationService = class extends BaseService {
    * Kreira novu notifikaciju
    */
   async createNotification(notification) {
-    const notificationsRef = collection22(this.db, NOTIFICATIONS_COLLECTION);
-    const now = Timestamp24.now();
+    const notificationsRef = collection27(this.db, NOTIFICATIONS_COLLECTION);
+    const now = Timestamp30.now();
     const notificationData = {
       ...notification,
       createdAt: now,
@@ -11749,12 +14244,12 @@ var NotificationService = class extends BaseService {
    * Dohvata notifikaciju po ID-u
    */
   async getNotification(notificationId) {
-    const notificationRef = doc22(
+    const notificationRef = doc28(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    const notificationDoc = await getDoc25(notificationRef);
+    const notificationDoc = await getDoc30(notificationRef);
     if (!notificationDoc.exists()) {
       return null;
     }
@@ -11767,45 +14262,45 @@ var NotificationService = class extends BaseService {
    * Dohvata sve notifikacije za korisnika
    */
   async getUserNotifications(userId) {
-    const q = query22(
-      collection22(this.db, NOTIFICATIONS_COLLECTION),
-      where22("userId", "==", userId),
-      orderBy11("notificationTime", "desc")
-    );
-    const querySnapshot = await getDocs22(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = query27(
+      collection27(this.db, NOTIFICATIONS_COLLECTION),
+      where27("userId", "==", userId),
+      orderBy15("notificationTime", "desc")
+    );
+    const querySnapshot = await getDocs27(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
   /**
    * Dohvata nepročitane notifikacije za korisnika
    */
   async getUnreadNotifications(userId) {
-    const q = query22(
-      collection22(this.db, NOTIFICATIONS_COLLECTION),
-      where22("userId", "==", userId),
-      where22("isRead", "==", false),
-      orderBy11("notificationTime", "desc")
-    );
-    const querySnapshot = await getDocs22(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = query27(
+      collection27(this.db, NOTIFICATIONS_COLLECTION),
+      where27("userId", "==", userId),
+      where27("isRead", "==", false),
+      orderBy15("notificationTime", "desc")
+    );
+    const querySnapshot = await getDocs27(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
   /**
    * Označava notifikaciju kao pročitanu
    */
   async markAsRead(notificationId) {
-    const notificationRef = doc22(
+    const notificationRef = doc28(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await updateDoc22(notificationRef, {
+    await updateDoc27(notificationRef, {
       isRead: true,
-      updatedAt: Timestamp24.now()
+      updatedAt: Timestamp30.now()
     });
   }
   /**
@@ -11815,14 +14310,14 @@ var NotificationService = class extends BaseService {
     const notifications = await this.getUnreadNotifications(userId);
     const batch = writeBatch5(this.db);
     notifications.forEach((notification) => {
-      const notificationRef = doc22(
+      const notificationRef = doc28(
         this.db,
         NOTIFICATIONS_COLLECTION,
         notification.id
       );
       batch.update(notificationRef, {
         isRead: true,
-        updatedAt: Timestamp24.now()
+        updatedAt: Timestamp30.now()
       });
     });
     await batch.commit();
@@ -11831,86 +14326,86 @@ var NotificationService = class extends BaseService {
    * Ažurira status notifikacije
    */
   async updateNotificationStatus(notificationId, status) {
-    const notificationRef = doc22(
+    const notificationRef = doc28(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await updateDoc22(notificationRef, {
+    await updateDoc27(notificationRef, {
       status,
-      updatedAt: Timestamp24.now()
+      updatedAt: Timestamp30.now()
     });
   }
   /**
    * Briše notifikaciju
    */
   async deleteNotification(notificationId) {
-    const notificationRef = doc22(
+    const notificationRef = doc28(
       this.db,
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await deleteDoc13(notificationRef);
+    await deleteDoc17(notificationRef);
   }
   /**
    * Dohvata notifikacije po tipu
    */
   async getNotificationsByType(userId, type) {
-    const q = query22(
-      collection22(this.db, NOTIFICATIONS_COLLECTION),
-      where22("userId", "==", userId),
-      where22("notificationType", "==", type),
-      orderBy11("notificationTime", "desc")
-    );
-    const querySnapshot = await getDocs22(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = query27(
+      collection27(this.db, NOTIFICATIONS_COLLECTION),
+      where27("userId", "==", userId),
+      where27("notificationType", "==", type),
+      orderBy15("notificationTime", "desc")
+    );
+    const querySnapshot = await getDocs27(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
   /**
    * Dohvata notifikacije za određeni termin
    */
   async getAppointmentNotifications(appointmentId) {
-    const q = query22(
-      collection22(this.db, NOTIFICATIONS_COLLECTION),
-      where22("appointmentId", "==", appointmentId),
-      orderBy11("notificationTime", "desc")
-    );
-    const querySnapshot = await getDocs22(q);
-    return querySnapshot.docs.map((doc26) => ({
-      id: doc26.id,
-      ...doc26.data()
+    const q = query27(
+      collection27(this.db, NOTIFICATIONS_COLLECTION),
+      where27("appointmentId", "==", appointmentId),
+      orderBy15("notificationTime", "desc")
+    );
+    const querySnapshot = await getDocs27(q);
+    return querySnapshot.docs.map((doc32) => ({
+      id: doc32.id,
+      ...doc32.data()
     }));
   }
 };
 
 // src/services/patient/patientRequirements.service.ts
 import {
-  collection as collection23,
-  getDocs as getDocs23,
-  query as query23,
-  where as where23,
-  doc as doc23,
-  updateDoc as updateDoc23,
-  Timestamp as Timestamp25,
-  orderBy as orderBy12,
+  collection as collection28,
+  getDocs as getDocs28,
+  query as query28,
+  where as where28,
+  doc as doc29,
+  updateDoc as updateDoc28,
+  Timestamp as Timestamp31,
+  orderBy as orderBy16,
   limit as limit14,
   startAfter as startAfter12,
-  getDoc as getDoc26
+  getDoc as getDoc31
 } from "firebase/firestore";
 var PatientRequirementsService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
   }
   getPatientRequirementsCollectionRef(patientId) {
-    return collection23(
+    return collection28(
       this.db,
       `patients/${patientId}/${PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME}`
     );
   }
   getPatientRequirementDocRef(patientId, instanceId) {
-    return doc23(
+    return doc29(
       this.getPatientRequirementsCollectionRef(patientId),
       instanceId
     );
@@ -11923,7 +14418,7 @@ var PatientRequirementsService = class extends BaseService {
    */
   async getPatientRequirementInstance(patientId, instanceId) {
     const docRef = this.getPatientRequirementDocRef(patientId, instanceId);
-    const docSnap = await getDoc26(docRef);
+    const docSnap = await getDoc31(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -11942,22 +14437,22 @@ var PatientRequirementsService = class extends BaseService {
    */
   async getAllPatientRequirementInstances(patientId, filters, pageLimit = 20, lastVisible) {
     const collRef = this.getPatientRequirementsCollectionRef(patientId);
-    let q = query23(collRef, orderBy12("createdAt", "desc"));
+    let q = query28(collRef, orderBy16("createdAt", "desc"));
     const queryConstraints = [];
     if ((filters == null ? void 0 : filters.appointmentId) && filters.appointmentId !== "all") {
       queryConstraints.push(
-        where23("appointmentId", "==", filters.appointmentId)
+        where28("appointmentId", "==", filters.appointmentId)
       );
     }
     if ((filters == null ? void 0 : filters.statuses) && filters.statuses.length > 0) {
-      queryConstraints.push(where23("overallStatus", "in", filters.statuses));
+      queryConstraints.push(where28("overallStatus", "in", filters.statuses));
     }
     if (lastVisible) {
       queryConstraints.push(startAfter12(lastVisible));
     }
     queryConstraints.push(limit14(pageLimit));
-    q = query23(collRef, ...queryConstraints);
-    const snapshot = await getDocs23(q);
+    q = query28(collRef, ...queryConstraints);
+    const snapshot = await getDocs28(q);
     let requirements = snapshot.docs.map((docSnap) => {
       const data = docSnap.data();
       return { id: docSnap.id, ...data };
@@ -12000,7 +14495,7 @@ var PatientRequirementsService = class extends BaseService {
    */
   async completeInstruction(patientId, instanceId, instructionId) {
     const instanceRef = this.getPatientRequirementDocRef(patientId, instanceId);
-    const instanceSnap = await getDoc26(instanceRef);
+    const instanceSnap = await getDoc31(instanceRef);
     if (!instanceSnap.exists()) {
       throw new Error(
         `PatientRequirementInstance ${instanceId} not found for patient ${patientId}.`
@@ -12028,7 +14523,7 @@ var PatientRequirementsService = class extends BaseService {
         `Instruction ${instructionId} is in status ${instructionToUpdate.status} and cannot be marked as completed.`
       );
     }
-    const now = Timestamp25.now();
+    const now = Timestamp31.now();
     const updatedInstructions = [...instance.instructions];
     updatedInstructions[instructionIndex] = {
       ...instructionToUpdate,
@@ -12055,7 +14550,7 @@ var PatientRequirementsService = class extends BaseService {
     if (newOverallStatus !== instance.overallStatus) {
       updatePayload.overallStatus = newOverallStatus;
     }
-    await updateDoc23(instanceRef, updatePayload);
+    await updateDoc28(instanceRef, updatePayload);
     return {
       ...instance,
       instructions: updatedInstructions,
@@ -12069,18 +14564,18 @@ var PatientRequirementsService = class extends BaseService {
 
 // src/services/procedure/procedure.service.ts
 import {
-  collection as collection24,
-  doc as doc24,
-  getDoc as getDoc27,
-  getDocs as getDocs24,
-  query as query24,
-  where as where24,
-  updateDoc as updateDoc24,
-  setDoc as setDoc21,
-  deleteDoc as deleteDoc14,
-  serverTimestamp as serverTimestamp20,
+  collection as collection29,
+  doc as doc30,
+  getDoc as getDoc32,
+  getDocs as getDocs29,
+  query as query29,
+  where as where29,
+  updateDoc as updateDoc29,
+  setDoc as setDoc26,
+  deleteDoc as deleteDoc18,
+  serverTimestamp as serverTimestamp25,
   writeBatch as writeBatch6,
-  orderBy as orderBy13,
+  orderBy as orderBy17,
   limit as limit15,
   startAfter as startAfter13,
   documentId as documentId2
@@ -12239,24 +14734,24 @@ var ProcedureService = class extends BaseService {
     if (!category || !subcategory || !technology || !product) {
       throw new Error("One or more required base entities not found");
     }
-    const clinicRef = doc24(
+    const clinicRef = doc30(
       this.db,
       CLINICS_COLLECTION,
       validatedData.clinicBranchId
     );
-    const clinicSnapshot = await getDoc27(clinicRef);
+    const clinicSnapshot = await getDoc32(clinicRef);
     if (!clinicSnapshot.exists()) {
       throw new Error(
         `Clinic with ID ${validatedData.clinicBranchId} not found`
       );
     }
     const clinic = clinicSnapshot.data();
-    const practitionerRef = doc24(
+    const practitionerRef = doc30(
       this.db,
       PRACTITIONERS_COLLECTION,
       validatedData.practitionerId
     );
-    const practitionerSnapshot = await getDoc27(practitionerRef);
+    const practitionerSnapshot = await getDoc32(practitionerRef);
     if (!practitionerSnapshot.exists()) {
       throw new Error(
         `Practitioner with ID ${validatedData.practitionerId} not found`
@@ -12322,13 +14817,13 @@ var ProcedureService = class extends BaseService {
       isActive: true
       // Default to active
     };
-    const procedureRef = doc24(this.db, PROCEDURES_COLLECTION, procedureId);
-    await setDoc21(procedureRef, {
+    const procedureRef = doc30(this.db, PROCEDURES_COLLECTION, procedureId);
+    await setDoc26(procedureRef, {
       ...newProcedure,
-      createdAt: serverTimestamp20(),
-      updatedAt: serverTimestamp20()
+      createdAt: serverTimestamp25(),
+      updatedAt: serverTimestamp25()
     });
-    const savedDoc = await getDoc27(procedureRef);
+    const savedDoc = await getDoc32(procedureRef);
     return savedDoc.data();
   }
   /**
@@ -12357,7 +14852,7 @@ var ProcedureService = class extends BaseService {
         validatedData.technologyId,
         validatedData.productId
       ),
-      getDoc27(doc24(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId))
+      getDoc32(doc30(this.db, CLINICS_COLLECTION, validatedData.clinicBranchId))
     ]);
     if (!category || !subcategory || !technology || !product) {
       throw new Error("One or more required base entities not found");
@@ -12380,13 +14875,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 = query24(
-        collection24(this.db, PRACTITIONERS_COLLECTION),
-        where24(documentId2(), "in", chunk)
+      const practitionersQuery = query29(
+        collection29(this.db, PRACTITIONERS_COLLECTION),
+        where29(documentId2(), "in", chunk)
       );
-      const practitionersSnapshot = await getDocs24(practitionersQuery);
-      practitionersSnapshot.docs.forEach((doc26) => {
-        practitionersMap.set(doc26.id, doc26.data());
+      const practitionersSnapshot = await getDocs29(practitionersQuery);
+      practitionersSnapshot.docs.forEach((doc32) => {
+        practitionersMap.set(doc32.id, doc32.data());
       });
     }
     if (practitionersMap.size !== practitionerIds.length) {
@@ -12420,7 +14915,7 @@ var ProcedureService = class extends BaseService {
       };
       const procedureId = this.generateId();
       createdProcedureIds.push(procedureId);
-      const procedureRef = doc24(this.db, PROCEDURES_COLLECTION, procedureId);
+      const procedureRef = doc30(this.db, PROCEDURES_COLLECTION, procedureId);
       const newProcedure = {
         id: procedureId,
         ...validatedData,
@@ -12455,21 +14950,21 @@ var ProcedureService = class extends BaseService {
       };
       batch.set(procedureRef, {
         ...newProcedure,
-        createdAt: serverTimestamp20(),
-        updatedAt: serverTimestamp20()
+        createdAt: serverTimestamp25(),
+        updatedAt: serverTimestamp25()
       });
     }
     await batch.commit();
     const fetchedProcedures = [];
     for (let i = 0; i < createdProcedureIds.length; i += 30) {
       const chunk = createdProcedureIds.slice(i, i + 30);
-      const q = query24(
-        collection24(this.db, PROCEDURES_COLLECTION),
-        where24(documentId2(), "in", chunk)
+      const q = query29(
+        collection29(this.db, PROCEDURES_COLLECTION),
+        where29(documentId2(), "in", chunk)
       );
-      const snapshot = await getDocs24(q);
-      snapshot.forEach((doc26) => {
-        fetchedProcedures.push(doc26.data());
+      const snapshot = await getDocs29(q);
+      snapshot.forEach((doc32) => {
+        fetchedProcedures.push(doc32.data());
       });
     }
     return fetchedProcedures;
@@ -12480,8 +14975,8 @@ var ProcedureService = class extends BaseService {
    * @returns The procedure if found, null otherwise
    */
   async getProcedure(id) {
-    const docRef = doc24(this.db, PROCEDURES_COLLECTION, id);
-    const docSnap = await getDoc27(docRef);
+    const docRef = doc30(this.db, PROCEDURES_COLLECTION, id);
+    const docSnap = await getDoc32(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -12493,13 +14988,13 @@ var ProcedureService = class extends BaseService {
    * @returns List of procedures
    */
   async getProceduresByClinicBranch(clinicBranchId) {
-    const q = query24(
-      collection24(this.db, PROCEDURES_COLLECTION),
-      where24("clinicBranchId", "==", clinicBranchId),
-      where24("isActive", "==", true)
+    const q = query29(
+      collection29(this.db, PROCEDURES_COLLECTION),
+      where29("clinicBranchId", "==", clinicBranchId),
+      where29("isActive", "==", true)
     );
-    const snapshot = await getDocs24(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs29(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all procedures for a practitioner
@@ -12507,13 +15002,13 @@ var ProcedureService = class extends BaseService {
    * @returns List of procedures
    */
   async getProceduresByPractitioner(practitionerId) {
-    const q = query24(
-      collection24(this.db, PROCEDURES_COLLECTION),
-      where24("practitionerId", "==", practitionerId),
-      where24("isActive", "==", true)
+    const q = query29(
+      collection29(this.db, PROCEDURES_COLLECTION),
+      where29("practitionerId", "==", practitionerId),
+      where29("isActive", "==", true)
     );
-    const snapshot = await getDocs24(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs29(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all inactive procedures for a practitioner
@@ -12521,13 +15016,13 @@ var ProcedureService = class extends BaseService {
    * @returns List of inactive procedures
    */
   async getInactiveProceduresByPractitioner(practitionerId) {
-    const q = query24(
-      collection24(this.db, PROCEDURES_COLLECTION),
-      where24("practitionerId", "==", practitionerId),
-      where24("isActive", "==", false)
+    const q = query29(
+      collection29(this.db, PROCEDURES_COLLECTION),
+      where29("practitionerId", "==", practitionerId),
+      where29("isActive", "==", false)
     );
-    const snapshot = await getDocs24(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs29(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Updates a procedure
@@ -12538,8 +15033,8 @@ var ProcedureService = class extends BaseService {
   async updateProcedure(id, data) {
     var _a;
     const validatedData = updateProcedureSchema.parse(data);
-    const procedureRef = doc24(this.db, PROCEDURES_COLLECTION, id);
-    const procedureSnapshot = await getDoc27(procedureRef);
+    const procedureRef = doc30(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await getDoc32(procedureRef);
     if (!procedureSnapshot.exists()) {
       throw new Error(`Procedure with ID ${id} not found`);
     }
@@ -12560,12 +15055,12 @@ var ProcedureService = class extends BaseService {
     }
     if (validatedData.practitionerId && validatedData.practitionerId !== oldPractitionerId) {
       practitionerChanged = true;
-      const newPractitionerRef = doc24(
+      const newPractitionerRef = doc30(
         this.db,
         PRACTITIONERS_COLLECTION,
         validatedData.practitionerId
       );
-      const newPractitionerSnap = await getDoc27(newPractitionerRef);
+      const newPractitionerSnap = await getDoc32(newPractitionerRef);
       if (!newPractitionerSnap.exists())
         throw new Error(
           `New Practitioner ${validatedData.practitionerId} not found`
@@ -12583,12 +15078,12 @@ var ProcedureService = class extends BaseService {
     }
     if (validatedData.clinicBranchId && validatedData.clinicBranchId !== oldClinicId) {
       clinicChanged = true;
-      const newClinicRef = doc24(
+      const newClinicRef = doc30(
         this.db,
         CLINICS_COLLECTION,
         validatedData.clinicBranchId
       );
-      const newClinicSnap = await getDoc27(newClinicRef);
+      const newClinicSnap = await getDoc32(newClinicRef);
       if (!newClinicSnap.exists())
         throw new Error(`New Clinic ${validatedData.clinicBranchId} not found`);
       newClinic = newClinicSnap.data();
@@ -12655,11 +15150,11 @@ var ProcedureService = class extends BaseService {
     } else if (validatedData.productId) {
       console.warn("Attempted to update product without a valid technologyId");
     }
-    await updateDoc24(procedureRef, {
+    await updateDoc29(procedureRef, {
       ...updatedProcedureData,
-      updatedAt: serverTimestamp20()
+      updatedAt: serverTimestamp25()
     });
-    const updatedSnapshot = await getDoc27(procedureRef);
+    const updatedSnapshot = await getDoc32(procedureRef);
     return updatedSnapshot.data();
   }
   /**
@@ -12667,15 +15162,15 @@ var ProcedureService = class extends BaseService {
    * @param id - The ID of the procedure to deactivate
    */
   async deactivateProcedure(id) {
-    const procedureRef = doc24(this.db, PROCEDURES_COLLECTION, id);
-    const procedureSnap = await getDoc27(procedureRef);
+    const procedureRef = doc30(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnap = await getDoc32(procedureRef);
     if (!procedureSnap.exists()) {
       console.warn(`Procedure ${id} not found for deactivation.`);
       return;
     }
-    await updateDoc24(procedureRef, {
+    await updateDoc29(procedureRef, {
       isActive: false,
-      updatedAt: serverTimestamp20()
+      updatedAt: serverTimestamp25()
     });
   }
   /**
@@ -12684,12 +15179,12 @@ var ProcedureService = class extends BaseService {
    * @returns A boolean indicating if the deletion was successful
    */
   async deleteProcedure(id) {
-    const procedureRef = doc24(this.db, PROCEDURES_COLLECTION, id);
-    const procedureSnapshot = await getDoc27(procedureRef);
+    const procedureRef = doc30(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await getDoc32(procedureRef);
     if (!procedureSnapshot.exists()) {
       return false;
     }
-    await deleteDoc14(procedureRef);
+    await deleteDoc18(procedureRef);
     return true;
   }
   /**
@@ -12715,35 +15210,35 @@ var ProcedureService = class extends BaseService {
    */
   async getAllProcedures(pagination, lastDoc) {
     try {
-      const proceduresCollection = collection24(this.db, PROCEDURES_COLLECTION);
-      let proceduresQuery = query24(proceduresCollection);
+      const proceduresCollection = collection29(this.db, PROCEDURES_COLLECTION);
+      let proceduresQuery = query29(proceduresCollection);
       if (pagination && pagination > 0) {
         const { limit: limit16, startAfter: startAfter14 } = await import("firebase/firestore");
         if (lastDoc) {
-          proceduresQuery = query24(
+          proceduresQuery = query29(
             proceduresCollection,
-            orderBy13("name"),
+            orderBy17("name"),
             // Use imported orderBy
             startAfter14(lastDoc),
             limit16(pagination)
           );
         } else {
-          proceduresQuery = query24(
+          proceduresQuery = query29(
             proceduresCollection,
-            orderBy13("name"),
+            orderBy17("name"),
             limit16(pagination)
           );
         }
       } else {
-        proceduresQuery = query24(proceduresCollection, orderBy13("name"));
+        proceduresQuery = query29(proceduresCollection, orderBy17("name"));
       }
-      const proceduresSnapshot = await getDocs24(proceduresQuery);
+      const proceduresSnapshot = await getDocs29(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
         };
       });
@@ -12786,14 +15281,14 @@ var ProcedureService = class extends BaseService {
       const isGeoQuery = filters.location && filters.radiusInKm && filters.radiusInKm > 0;
       const constraints = [];
       if (filters.isActive !== void 0) {
-        constraints.push(where24("isActive", "==", filters.isActive));
+        constraints.push(where29("isActive", "==", filters.isActive));
       } else {
-        constraints.push(where24("isActive", "==", true));
+        constraints.push(where29("isActive", "==", true));
       }
       if (filters.procedureFamily) {
-        constraints.push(where24("family", "==", filters.procedureFamily));
+        constraints.push(where29("family", "==", filters.procedureFamily));
       }
-      constraints.push(orderBy13("clinicInfo.location.geohash"));
+      constraints.push(orderBy17("clinicInfo.location.geohash"));
       if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
         constraints.push(startAfter13(filters.lastDoc));
         constraints.push(limit15(filters.pagination));
@@ -12814,19 +15309,19 @@ var ProcedureService = class extends BaseService {
         for (const bound of bounds) {
           const geoConstraints = [
             ...constraints,
-            where24("clinicInfo.location.geohash", ">=", bound[0]),
-            where24("clinicInfo.location.geohash", "<=", bound[1])
+            where29("clinicInfo.location.geohash", ">=", bound[0]),
+            where29("clinicInfo.location.geohash", "<=", bound[1])
           ];
-          const q = query24(
-            collection24(this.db, PROCEDURES_COLLECTION),
+          const q = query29(
+            collection29(this.db, PROCEDURES_COLLECTION),
             ...geoConstraints
           );
-          const querySnapshot = await getDocs24(q);
+          const querySnapshot = await getDocs29(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 = distanceBetween6(
               [center.latitude, center.longitude],
               [
@@ -12869,16 +15364,16 @@ var ProcedureService = class extends BaseService {
           proceduresResult = filteredProcedures;
         }
       } else {
-        const q = query24(
-          collection24(this.db, PROCEDURES_COLLECTION),
+        const q = query29(
+          collection29(this.db, PROCEDURES_COLLECTION),
           ...constraints
         );
-        const querySnapshot = await getDocs24(q);
+        const querySnapshot = await getDocs29(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;
@@ -12999,18 +15494,18 @@ var ProcedureService = class extends BaseService {
     if (!category || !subcategory || !technology) {
       throw new Error("One or more required base entities not found");
     }
-    const clinicRef = doc24(this.db, CLINICS_COLLECTION, data.clinicBranchId);
-    const clinicSnapshot = await getDoc27(clinicRef);
+    const clinicRef = doc30(this.db, CLINICS_COLLECTION, data.clinicBranchId);
+    const clinicSnapshot = await getDoc32(clinicRef);
     if (!clinicSnapshot.exists()) {
       throw new Error(`Clinic with ID ${data.clinicBranchId} not found`);
     }
     const clinic = clinicSnapshot.data();
-    const practitionerRef = doc24(
+    const practitionerRef = doc30(
       this.db,
       PRACTITIONERS_COLLECTION,
       data.practitionerId
     );
-    const practitionerSnapshot = await getDoc27(practitionerRef);
+    const practitionerSnapshot = await getDoc32(practitionerRef);
     if (!practitionerSnapshot.exists()) {
       throw new Error(`Practitioner with ID ${data.practitionerId} not found`);
     }
@@ -13081,28 +15576,28 @@ var ProcedureService = class extends BaseService {
       },
       isActive: true
     };
-    const procedureRef = doc24(this.db, PROCEDURES_COLLECTION, procedureId);
-    await setDoc21(procedureRef, {
+    const procedureRef = doc30(this.db, PROCEDURES_COLLECTION, procedureId);
+    await setDoc26(procedureRef, {
       ...newProcedure,
-      createdAt: serverTimestamp20(),
-      updatedAt: serverTimestamp20()
+      createdAt: serverTimestamp25(),
+      updatedAt: serverTimestamp25()
     });
-    const savedDoc = await getDoc27(procedureRef);
+    const savedDoc = await getDoc32(procedureRef);
     return savedDoc.data();
   }
 };
 
 // src/services/reviews/reviews.service.ts
 import {
-  collection as collection25,
-  doc as doc25,
-  getDoc as getDoc28,
-  getDocs as getDocs25,
-  query as query25,
-  where as where25,
-  setDoc as setDoc22,
-  deleteDoc as deleteDoc15,
-  serverTimestamp as serverTimestamp21
+  collection as collection30,
+  doc as doc31,
+  getDoc as getDoc33,
+  getDocs as getDocs30,
+  query as query30,
+  where as where30,
+  setDoc as setDoc27,
+  deleteDoc as deleteDoc19,
+  serverTimestamp as serverTimestamp26
 } from "firebase/firestore";
 import { z as z25 } from "zod";
 var ReviewService = class extends BaseService {
@@ -13183,11 +15678,11 @@ var ReviewService = class extends BaseService {
         updatedAt: now
       };
       reviewSchema.parse(review);
-      const docRef = doc25(this.db, REVIEWS_COLLECTION, reviewId);
-      await setDoc22(docRef, {
+      const docRef = doc31(this.db, REVIEWS_COLLECTION, reviewId);
+      await setDoc27(docRef, {
         ...review,
-        createdAt: serverTimestamp21(),
-        updatedAt: serverTimestamp21()
+        createdAt: serverTimestamp26(),
+        updatedAt: serverTimestamp26()
       });
       return review;
     } catch (error) {
@@ -13203,8 +15698,8 @@ var ReviewService = class extends BaseService {
    * @returns The review if found, null otherwise
    */
   async getReview(reviewId) {
-    const docRef = doc25(this.db, REVIEWS_COLLECTION, reviewId);
-    const docSnap = await getDoc28(docRef);
+    const docRef = doc31(this.db, REVIEWS_COLLECTION, reviewId);
+    const docSnap = await getDoc33(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -13216,12 +15711,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews for the patient
    */
   async getReviewsByPatient(patientId) {
-    const q = query25(
-      collection25(this.db, REVIEWS_COLLECTION),
-      where25("patientId", "==", patientId)
+    const q = query30(
+      collection30(this.db, REVIEWS_COLLECTION),
+      where30("patientId", "==", patientId)
     );
-    const snapshot = await getDocs25(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs30(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific clinic
@@ -13229,12 +15724,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews containing clinic reviews
    */
   async getReviewsByClinic(clinicId) {
-    const q = query25(
-      collection25(this.db, REVIEWS_COLLECTION),
-      where25("clinicReview.clinicId", "==", clinicId)
+    const q = query30(
+      collection30(this.db, REVIEWS_COLLECTION),
+      where30("clinicReview.clinicId", "==", clinicId)
     );
-    const snapshot = await getDocs25(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs30(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific practitioner
@@ -13242,12 +15737,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews containing practitioner reviews
    */
   async getReviewsByPractitioner(practitionerId) {
-    const q = query25(
-      collection25(this.db, REVIEWS_COLLECTION),
-      where25("practitionerReview.practitionerId", "==", practitionerId)
+    const q = query30(
+      collection30(this.db, REVIEWS_COLLECTION),
+      where30("practitionerReview.practitionerId", "==", practitionerId)
     );
-    const snapshot = await getDocs25(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs30(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific procedure
@@ -13255,12 +15750,12 @@ var ReviewService = class extends BaseService {
    * @returns Array of reviews containing procedure reviews
    */
   async getReviewsByProcedure(procedureId) {
-    const q = query25(
-      collection25(this.db, REVIEWS_COLLECTION),
-      where25("procedureReview.procedureId", "==", procedureId)
+    const q = query30(
+      collection30(this.db, REVIEWS_COLLECTION),
+      where30("procedureReview.procedureId", "==", procedureId)
     );
-    const snapshot = await getDocs25(q);
-    return snapshot.docs.map((doc26) => doc26.data());
+    const snapshot = await getDocs30(q);
+    return snapshot.docs.map((doc32) => doc32.data());
   }
   /**
    * Gets all reviews for a specific appointment
@@ -13268,11 +15763,11 @@ var ReviewService = class extends BaseService {
    * @returns The review for the appointment if found, null otherwise
    */
   async getReviewByAppointment(appointmentId) {
-    const q = query25(
-      collection25(this.db, REVIEWS_COLLECTION),
-      where25("appointmentId", "==", appointmentId)
+    const q = query30(
+      collection30(this.db, REVIEWS_COLLECTION),
+      where30("appointmentId", "==", appointmentId)
     );
-    const snapshot = await getDocs25(q);
+    const snapshot = await getDocs30(q);
     if (snapshot.empty) {
       return null;
     }
@@ -13287,7 +15782,7 @@ var ReviewService = class extends BaseService {
     if (!review) {
       throw new Error(`Review with ID ${reviewId} not found`);
     }
-    await deleteDoc15(doc25(this.db, REVIEWS_COLLECTION, reviewId));
+    await deleteDoc19(doc31(this.db, REVIEWS_COLLECTION, reviewId));
   }
   /**
    * Calculates the average of an array of numbers
@@ -13306,11 +15801,11 @@ var ReviewService = class extends BaseService {
 
 // src/validations/calendar.schema.ts
 import { z as z27 } from "zod";
-import { Timestamp as Timestamp28 } from "firebase/firestore";
+import { Timestamp as Timestamp34 } from "firebase/firestore";
 
 // src/validations/profile-info.schema.ts
 import { z as z26 } from "zod";
-import { Timestamp as Timestamp27 } from "firebase/firestore";
+import { Timestamp as Timestamp33 } from "firebase/firestore";
 var clinicBranchInfoSchema = z26.object({
   id: z26.string(),
   featuredPhoto: z26.string(),
@@ -13332,19 +15827,19 @@ var patientProfileInfoSchema = z26.object({
   fullName: z26.string(),
   email: z26.string().email(),
   phone: z26.string().nullable(),
-  dateOfBirth: z26.instanceof(Timestamp27),
+  dateOfBirth: z26.instanceof(Timestamp33),
   gender: z26.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
-var MIN_APPOINTMENT_DURATION = 15;
+var MIN_APPOINTMENT_DURATION2 = 15;
 var calendarEventTimeSchema = z27.object({
-  start: z27.instanceof(Date).or(z27.instanceof(Timestamp28)),
-  end: z27.instanceof(Date).or(z27.instanceof(Timestamp28))
+  start: z27.instanceof(Date).or(z27.instanceof(Timestamp34)),
+  end: z27.instanceof(Date).or(z27.instanceof(Timestamp34))
 }).refine(
   (data) => {
-    const startDate = data.start instanceof Timestamp28 ? data.start.toDate() : data.start;
-    const endDate = data.end instanceof Timestamp28 ? data.end.toDate() : data.end;
+    const startDate = data.start instanceof Timestamp34 ? data.start.toDate() : data.start;
+    const endDate = data.end instanceof Timestamp34 ? data.end.toDate() : data.end;
     return startDate < endDate;
   },
   {
@@ -13353,7 +15848,7 @@ var calendarEventTimeSchema = z27.object({
   }
 ).refine(
   (data) => {
-    const startDate = data.start instanceof Timestamp28 ? data.start.toDate() : data.start;
+    const startDate = data.start instanceof Timestamp34 ? data.start.toDate() : data.start;
     return startDate > /* @__PURE__ */ new Date();
   },
   {
@@ -13372,12 +15867,12 @@ var timeSlotSchema2 = z27.object({
 var syncedCalendarEventSchema = z27.object({
   eventId: z27.string(),
   syncedCalendarProvider: z27.nativeEnum(SyncedCalendarProvider),
-  syncedAt: z27.instanceof(Date).or(z27.instanceof(Timestamp28))
+  syncedAt: z27.instanceof(Date).or(z27.instanceof(Timestamp34))
 });
 var procedureInfoSchema = z27.object({
   name: z27.string(),
   description: z27.string(),
-  duration: z27.number().min(MIN_APPOINTMENT_DURATION),
+  duration: z27.number().min(MIN_APPOINTMENT_DURATION2),
   price: z27.number().min(0),
   currency: z27.nativeEnum(Currency)
 });
@@ -13451,8 +15946,8 @@ var calendarEventSchema = z27.object({
   status: z27.nativeEnum(CalendarEventStatus),
   syncStatus: z27.nativeEnum(CalendarSyncStatus),
   eventType: z27.nativeEnum(CalendarEventType),
-  createdAt: z27.instanceof(Date).or(z27.instanceof(Timestamp28)),
-  updatedAt: z27.instanceof(Date).or(z27.instanceof(Timestamp28))
+  createdAt: z27.instanceof(Date).or(z27.instanceof(Timestamp34)),
+  updatedAt: z27.instanceof(Date).or(z27.instanceof(Timestamp34))
 });
 var createBlockingEventSchema = z27.object({
   entityType: z27.enum(["practitioner", "clinic"]),
@@ -13580,11 +16075,11 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
 })(RequirementType || {});
 
 // src/backoffice/validations/schemas.ts
-var blockingConditionSchema2 = z29.nativeEnum(BlockingCondition);
-var contraindicationSchema2 = z29.nativeEnum(Contraindication);
-var treatmentBenefitSchema = z29.nativeEnum(TreatmentBenefit);
-var procedureFamilySchema = z29.nativeEnum(ProcedureFamily);
-var timeUnitSchema = z29.nativeEnum(TimeUnit);
+var blockingConditionSchemaBackoffice = z29.nativeEnum(BlockingCondition);
+var contraindicationSchemaBackoffice = z29.nativeEnum(Contraindication);
+var treatmentBenefitSchemaBackoffice = z29.nativeEnum(TreatmentBenefit);
+var procedureFamilySchemaBackoffice = z29.nativeEnum(ProcedureFamily);
+var timeUnitSchemaBackoffice = z29.nativeEnum(TimeUnit);
 var requirementTypeSchema = z29.nativeEnum(RequirementType);
 var certificationLevelSchema = z29.nativeEnum(CertificationLevel);
 var certificationSpecialtySchema = z29.nativeEnum(
@@ -13596,7 +16091,7 @@ var certificationRequirementSchema = z29.object({
 });
 var timeframeSchema = z29.object({
   duration: z29.number().min(1, "Duration must be positive"),
-  unit: timeUnitSchema,
+  unit: timeUnitSchemaBackoffice,
   notifyAt: z29.array(z29.number()).min(1, "At least one notification point is required")
 });
 var requirementSchema = z29.object({
@@ -13615,24 +16110,24 @@ var technologySchema = z29.object({
   name: z29.string().min(1, "Name is required").max(100, "Name is too long"),
   description: z29.string().max(1e3, "Description is too long").optional(),
   technicalDetails: z29.string().max(2e3, "Technical details are too long").optional(),
-  family: procedureFamilySchema,
+  family: procedureFamilySchemaBackoffice,
   categoryId: z29.string().min(1, "Category ID is required"),
   subcategoryId: z29.string().min(1, "Subcategory ID is required"),
   requirements: technologyRequirementsSchema.default({
     pre: [],
     post: []
   }),
-  blockingConditions: z29.array(blockingConditionSchema2),
-  contraindications: z29.array(contraindicationSchema2),
+  blockingConditions: z29.array(blockingConditionSchemaBackoffice),
+  contraindications: z29.array(contraindicationSchemaBackoffice),
   documentationTemplates: z29.array(documentTemplateSchema),
-  benefits: z29.array(treatmentBenefitSchema),
+  benefits: z29.array(treatmentBenefitSchemaBackoffice),
   certificationRequirement: certificationRequirementSchema,
   isActive: z29.boolean().default(true)
 });
 var categorySchema = z29.object({
   name: z29.string().min(1, "Name is required").max(100, "Name is too long"),
   description: z29.string().optional(),
-  family: procedureFamilySchema,
+  family: procedureFamilySchemaBackoffice,
   isActive: z29.boolean().default(true)
 });
 var subcategorySchema = z29.object({
@@ -13658,7 +16153,7 @@ var patientRequirementInstructionSchema = z30.object({
   actionableWindow: z30.number().default(1),
   status: patientInstructionStatusSchema,
   originalNotifyAtValue: z30.number(),
-  originalTimeframeUnit: timeUnitSchema,
+  originalTimeframeUnit: timeUnitSchemaBackoffice,
   // Use the correctly imported timeUnitSchema
   notificationId: z30.string().optional(),
   actionTakenAt: z30.any().optional().nullable(),
@@ -13940,6 +16435,7 @@ export {
   CLINIC_GROUPS_COLLECTION,
   CalendarEventStatus,
   CalendarEventType,
+  CalendarServiceV2,
   CalendarServiceV3,
   CalendarSyncStatus,
   ClinicAdminService,
@@ -14008,6 +16504,7 @@ export {
   USERS_COLLECTION,
   USER_FORMS_SUBCOLLECTION,
   UserRole,
+  UserService,
   addAllergySchema,
   addBlockingConditionSchema,
   addContraindicationSchema,