@blackcode_sa/metaestetics-api 1.4.17 → 1.5.0

package/dist/index.mjs

@@ -108,6 +108,31 @@ var FilledDocumentStatus = /* @__PURE__ */ ((FilledDocumentStatus2) => {
   return FilledDocumentStatus2;
 })(FilledDocumentStatus || {});
 
+// 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";
+  return CalendarEventStatus3;
+})(CalendarEventStatus || {});
+var CalendarSyncStatus = /* @__PURE__ */ ((CalendarSyncStatus3) => {
+  CalendarSyncStatus3["INTERNAL"] = "internal";
+  CalendarSyncStatus3["EXTERNAL"] = "external";
+  return CalendarSyncStatus3;
+})(CalendarSyncStatus || {});
+var CalendarEventType = /* @__PURE__ */ ((CalendarEventType2) => {
+  CalendarEventType2["APPOINTMENT"] = "appointment";
+  CalendarEventType2["BLOCKING"] = "blocking";
+  CalendarEventType2["BREAK"] = "break";
+  CalendarEventType2["FREE_DAY"] = "free_day";
+  CalendarEventType2["OTHER"] = "other";
+  return CalendarEventType2;
+})(CalendarEventType || {});
+var CALENDAR_COLLECTION = "calendar";
+
 // src/types/index.ts
 var UserRole = /* @__PURE__ */ ((UserRole2) => {
   UserRole2["PATIENT"] = "patient";
@@ -1276,9 +1301,9 @@ var addAllergyUtil = async (db, patientId, data, userRef) => {
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1294,9 +1319,9 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1321,9 +1346,9 @@ var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1339,9 +1364,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1366,9 +1391,9 @@ var addContraindicationUtil = async (db, patientId, data, userRef) => {
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1384,9 +1409,9 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1411,9 +1436,9 @@ var addMedicationUtil = async (db, patientId, data, userRef) => {
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -1429,9 +1454,9 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc14 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc14.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc14.data();
+  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc20.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc20.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -2247,14 +2272,14 @@ var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
 })(TreatmentBenefit || {});
 
 // src/backoffice/types/static/pricing.types.ts
-var PricingMeasure = /* @__PURE__ */ ((PricingMeasure2) => {
-  PricingMeasure2["PER_ML"] = "per_ml";
-  PricingMeasure2["PER_ZONE"] = "per_zone";
-  PricingMeasure2["PER_AREA"] = "per_area";
-  PricingMeasure2["PER_SESSION"] = "per_session";
-  PricingMeasure2["PER_TREATMENT"] = "per_treatment";
-  PricingMeasure2["PER_PACKAGE"] = "per_package";
-  return PricingMeasure2;
+var PricingMeasure = /* @__PURE__ */ ((PricingMeasure3) => {
+  PricingMeasure3["PER_ML"] = "per_ml";
+  PricingMeasure3["PER_ZONE"] = "per_zone";
+  PricingMeasure3["PER_AREA"] = "per_area";
+  PricingMeasure3["PER_SESSION"] = "per_session";
+  PricingMeasure3["PER_TREATMENT"] = "per_treatment";
+  PricingMeasure3["PER_PACKAGE"] = "per_package";
+  return PricingMeasure3;
 })(PricingMeasure || {});
 var Currency = /* @__PURE__ */ ((Currency2) => {
   Currency2["EUR"] = "EUR";
@@ -2434,7 +2459,7 @@ var clinicSchema = z9.object({
   workingHours: workingHoursSchema,
   tags: z9.array(z9.nativeEnum(ClinicTag)),
   featuredPhotos: z9.array(z9.string()),
-  photos: z9.array(z9.string()),
+  coverPhoto: z9.string().nullable(),
   photosWithTags: z9.array(
     z9.object({
       url: z9.string(),
@@ -2493,7 +2518,7 @@ var createClinicSchema = z9.object({
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
   tags: z9.array(z9.nativeEnum(ClinicTag)),
-  photos: z9.array(z9.string()),
+  coverPhoto: z9.string().nullable(),
   photosWithTags: z9.array(
     z9.object({
       url: z9.string(),
@@ -2554,7 +2579,7 @@ var clinicBranchSetupSchema = z9.object({
   workingHours: workingHoursSchema,
   tags: z9.array(z9.nativeEnum(ClinicTag)),
   logo: z9.string().optional(),
-  photos: z9.array(z9.string()),
+  coverPhoto: z9.string().nullable(),
   photosWithTags: z9.array(
     z9.object({
       url: z9.string(),
@@ -2748,7 +2773,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     where2("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await getDocs2(q);
-  return querySnapshot.docs.map((doc14) => doc14.data());
+  return querySnapshot.docs.map((doc20) => doc20.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3096,6 +3121,21 @@ var practitionerWorkingHoursSchema = z10.object({
   createdAt: z10.instanceof(Timestamp7),
   updatedAt: z10.instanceof(Timestamp7)
 });
+var practitionerClinicWorkingHoursSchema = z10.object({
+  clinicId: z10.string().min(1),
+  workingHours: z10.object({
+    monday: timeSlotSchema,
+    tuesday: timeSlotSchema,
+    wednesday: timeSlotSchema,
+    thursday: timeSlotSchema,
+    friday: timeSlotSchema,
+    saturday: timeSlotSchema,
+    sunday: timeSlotSchema
+  }),
+  isActive: z10.boolean(),
+  createdAt: z10.instanceof(Timestamp7),
+  updatedAt: z10.instanceof(Timestamp7)
+});
 var practitionerReviewSchema = z10.object({
   id: z10.string().min(1),
   practitionerId: z10.string().min(1),
@@ -3121,6 +3161,7 @@ var practitionerSchema = z10.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
   clinics: z10.array(z10.string()),
+  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema),
   isActive: z10.boolean(),
   isVerified: z10.boolean(),
   createdAt: z10.instanceof(Timestamp7),
@@ -3131,6 +3172,7 @@ var createPractitionerSchema = z10.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
   clinics: z10.array(z10.string()).optional(),
+  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema).optional(),
   isActive: z10.boolean(),
   isVerified: z10.boolean()
 });
@@ -3180,6 +3222,7 @@ var PractitionerService = class extends BaseService {
         basicInfo: validatedData.basicInfo,
         certification: validatedData.certification,
         clinics: validatedData.clinics || [],
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
         createdAt: serverTimestamp9(),
@@ -3242,7 +3285,7 @@ var PractitionerService = class extends BaseService {
       where3("isActive", "==", true)
     );
     const querySnapshot = await getDocs3(q);
-    return querySnapshot.docs.map((doc14) => doc14.data());
+    return querySnapshot.docs.map((doc20) => doc20.data());
   }
   /**
    * Ažurira profil zdravstvenog radnika
@@ -3522,7 +3565,7 @@ var UserService = class extends BaseService {
     ];
     const q = query4(collection4(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs4(q);
-    const users = querySnapshot.docs.map((doc14) => doc14.data());
+    const users = querySnapshot.docs.map((doc20) => doc20.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
   /**
@@ -3921,7 +3964,7 @@ async function getAllActiveGroups(db) {
     where5("isActive", "==", true)
   );
   const querySnapshot = await getDocs5(q);
-  return querySnapshot.docs.map((doc14) => doc14.data());
+  return querySnapshot.docs.map((doc20) => doc20.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
   console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
@@ -4388,25 +4431,23 @@ async function createClinic(db, data, creatorAdminId, clinicGroupService, clinic
       console.error("[CLINIC] Error processing logo:", logoError);
     }
   }
-  let processedPhotos = [];
-  if (validatedData.photos && validatedData.photos.length > 0) {
-    console.log("[CLINIC] Processing regular photos");
+  let processedCoverPhoto = null;
+  if (validatedData.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo");
     try {
-      processedPhotos = await uploadMultiplePhotos(
-        validatedData.photos,
+      processedCoverPhoto = await uploadPhoto(
+        validatedData.coverPhoto,
         "clinics",
         clinicId,
-        "photo",
+        "cover",
         app
       );
-      console.log("[CLINIC] Regular photos processed", {
-        count: processedPhotos.length
+      console.log("[CLINIC] Cover photo processed", {
+        coverPhoto: processedCoverPhoto
       });
-    } catch (photosError) {
-      console.error("[CLINIC] Error processing regular photos:", photosError);
-      processedPhotos = validatedData.photos.filter(
-        (photo) => !photo.startsWith("data:")
-      );
+    } catch (coverPhotoError) {
+      console.error("[CLINIC] Error processing cover photo:", coverPhotoError);
+      processedCoverPhoto = validatedData.coverPhoto.startsWith("data:") ? null : validatedData.coverPhoto;
     }
   }
   let processedFeaturedPhotos = [];
@@ -4492,7 +4533,7 @@ async function createClinic(db, data, creatorAdminId, clinicGroupService, clinic
     logo: logoUrl || "",
     tags: validatedData.tags || [],
     featuredPhotos: processedFeaturedPhotos || [],
-    photos: processedPhotos || [],
+    coverPhoto: processedCoverPhoto,
     photosWithTags: processedPhotosWithTags,
     doctors: [],
     doctorsInfo: [],
@@ -4593,7 +4634,7 @@ async function getClinicsByGroup(db, groupId) {
     where6("isActive", "==", true)
   );
   const querySnapshot = await getDocs6(q);
-  return querySnapshot.docs.map((doc14) => doc14.data());
+  return querySnapshot.docs.map((doc20) => doc20.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
   console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
@@ -4647,36 +4688,32 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
       console.error("[CLINIC] Error processing logo update:", logoError);
     }
   }
-  if (data.photos && data.photos.length > 0) {
-    console.log("[CLINIC] Processing regular photos update");
+  if (data.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo update");
     try {
-      const dataUrlPhotos = data.photos.filter(
-        (photo) => typeof photo === "string" && photo.startsWith("data:")
-      );
-      const existingPhotos = data.photos.filter(
-        (photo) => typeof photo === "string" && !photo.startsWith("data:")
-      );
-      if (dataUrlPhotos.length > 0) {
-        const uploadedPhotos = await uploadMultiplePhotos(
-          dataUrlPhotos,
+      if (typeof data.coverPhoto === "string" && data.coverPhoto.startsWith("data:")) {
+        const uploadedPhoto = await uploadPhoto(
+          data.coverPhoto,
           "clinics",
           clinicId,
-          "photo",
+          "cover",
           app
         );
-        console.log("[CLINIC] Regular photos update processed", {
-          count: uploadedPhotos.length
-        });
-        updatedData.photos = [...existingPhotos, ...uploadedPhotos];
+        if (uploadedPhoto) {
+          updatedData.coverPhoto = uploadedPhoto;
+        }
+      } else {
+        updatedData.coverPhoto = data.coverPhoto;
       }
-    } catch (photosError) {
+      console.log("[CLINIC] Cover photo update processed");
+    } catch (photoError) {
       console.error(
-        "[CLINIC] Error processing regular photos update:",
-        photosError
-      );
-      updatedData.photos = data.photos.filter(
-        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+        "[CLINIC] Error processing cover photo update:",
+        photoError
       );
+      if (typeof data.coverPhoto === "string" && !data.coverPhoto.startsWith("data:")) {
+        updatedData.coverPhoto = data.coverPhoto;
+      }
     }
   }
   if (data.featuredPhotos && data.featuredPhotos.length > 0) {
@@ -4700,6 +4737,8 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
           count: uploadedPhotos.length
         });
         updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
+      } else {
+        updatedData.featuredPhotos = existingPhotos;
       }
     } catch (featuredError) {
       console.error(
@@ -4807,7 +4846,7 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   }
   const q = query6(collection6(db, CLINICS_COLLECTION), ...constraints);
   const querySnapshot = await getDocs6(q);
-  return querySnapshot.docs.map((doc14) => doc14.data());
+  return querySnapshot.docs.map((doc20) => doc20.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -4960,8 +4999,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = query7(collection8(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs7(q);
-    for (const doc14 of querySnapshot.docs) {
-      const clinic = doc14.data();
+    for (const doc20 of querySnapshot.docs) {
+      const clinic = doc20.data();
       const distance = distanceBetween(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5139,7 +5178,7 @@ var ClinicService = class extends BaseService {
       contactInfo: setupData.contactInfo,
       workingHours: setupData.workingHours,
       tags: setupData.tags,
-      photos: setupData.photos || [],
+      coverPhoto: setupData.coverPhoto || null,
       photosWithTags: setupData.photosWithTags || [],
       doctors: [],
       services: [],
@@ -5152,7 +5191,7 @@ var ClinicService = class extends BaseService {
     console.log("[CLINIC_SERVICE] Creating clinic branch with data", {
       name: createClinicData.name,
       hasLogo: !!createClinicData.logo,
-      photosCount: createClinicData.photos.length,
+      hasCoverPhoto: !!createClinicData.coverPhoto,
       featuredPhotosCount: ((_a = createClinicData.featuredPhotos) == null ? void 0 : _a.length) || 0,
       photosWithTagsCount: ((_b = createClinicData.photosWithTags) == null ? void 0 : _b.length) || 0
     });
@@ -5835,9 +5874,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc14) => ({
-      id: doc14.id,
-      ...doc14.data()
+    return querySnapshot.docs.map((doc20) => ({
+      id: doc20.id,
+      ...doc20.data()
     }));
   }
   /**
@@ -5851,9 +5890,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc14) => ({
-      id: doc14.id,
-      ...doc14.data()
+    return querySnapshot.docs.map((doc20) => ({
+      id: doc20.id,
+      ...doc20.data()
     }));
   }
   /**
@@ -5925,9 +5964,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc14) => ({
-      id: doc14.id,
-      ...doc14.data()
+    return querySnapshot.docs.map((doc20) => ({
+      id: doc20.id,
+      ...doc20.data()
     }));
   }
   /**
@@ -5940,9 +5979,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc14) => ({
-      id: doc14.id,
-      ...doc14.data()
+    return querySnapshot.docs.map((doc20) => ({
+      id: doc20.id,
+      ...doc20.data()
     }));
   }
 };
@@ -6072,9 +6111,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await getDocs10(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      templates.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      templates.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       templates,
@@ -6102,9 +6141,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await getDocs10(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      templates.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      templates.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       templates,
@@ -6131,9 +6170,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await getDocs10(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      templates.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      templates.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       templates,
@@ -6258,9 +6297,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs11(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      documents.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      documents.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       documents,
@@ -6287,9 +6326,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs11(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      documents.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      documents.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       documents,
@@ -6316,9 +6355,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs11(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      documents.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      documents.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       documents,
@@ -6345,9 +6384,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs11(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      documents.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      documents.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       documents,
@@ -6374,9 +6413,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs11(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc14) => {
-      documents.push(doc14.data());
-      lastVisible = doc14;
+    querySnapshot.forEach((doc20) => {
+      documents.push(doc20.data());
+      lastVisible = doc20;
     });
     return {
       documents,
@@ -6385,55 +6424,2654 @@ var FilledDocumentService = class extends BaseService {
   }
 };
 
-// src/validations/notification.schema.ts
+// src/services/calendar/calendar-refactored.service.ts
+import { Timestamp as Timestamp23, serverTimestamp as serverTimestamp18 } from "firebase/firestore";
+
+// src/types/calendar/synced-calendar.types.ts
+var SyncedCalendarProvider = /* @__PURE__ */ ((SyncedCalendarProvider3) => {
+  SyncedCalendarProvider3["GOOGLE"] = "google";
+  SyncedCalendarProvider3["OUTLOOK"] = "outlook";
+  SyncedCalendarProvider3["APPLE"] = "apple";
+  return SyncedCalendarProvider3;
+})(SyncedCalendarProvider || {});
+var SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
+
+// src/services/calendar/calendar-refactored.service.ts
+import {
+  doc as doc19,
+  getDoc as getDoc22,
+  collection as collection17,
+  query as query16,
+  where as where16,
+  getDocs as getDocs16,
+  setDoc as setDoc19,
+  updateDoc as updateDoc20
+} from "firebase/firestore";
+
+// src/validations/calendar.schema.ts
+import { z as z17 } from "zod";
+import { Timestamp as Timestamp17 } from "firebase/firestore";
+
+// src/validations/profile-info.schema.ts
 import { z as z16 } from "zod";
-var baseNotificationSchema = z16.object({
-  id: z16.string().optional(),
-  userId: z16.string(),
-  notificationTime: z16.any(),
+import { Timestamp as Timestamp16 } from "firebase/firestore";
+var clinicInfoSchema2 = z16.object({
+  id: z16.string(),
+  featuredPhoto: z16.string(),
+  name: z16.string(),
+  description: z16.string(),
+  location: clinicLocationSchema,
+  contactInfo: clinicContactInfoSchema
+});
+var practitionerProfileInfoSchema = z16.object({
+  id: z16.string(),
+  practitionerPhoto: z16.string().nullable(),
+  name: z16.string(),
+  email: z16.string().email(),
+  phone: z16.string().nullable(),
+  certification: practitionerCertificationSchema
+});
+var patientProfileInfoSchema = z16.object({
+  id: z16.string(),
+  fullName: z16.string(),
+  email: z16.string().email(),
+  phone: z16.string().nullable(),
+  dateOfBirth: z16.instanceof(Timestamp16),
+  gender: z16.nativeEnum(Gender)
+});
+
+// src/validations/calendar.schema.ts
+var MIN_APPOINTMENT_DURATION = 15;
+var calendarEventTimeSchema = z17.object({
+  start: z17.instanceof(Date).or(z17.instanceof(Timestamp17)),
+  end: z17.instanceof(Date).or(z17.instanceof(Timestamp17))
+}).refine(
+  (data) => {
+    const startDate = data.start instanceof Timestamp17 ? data.start.toDate() : data.start;
+    const endDate = data.end instanceof Timestamp17 ? data.end.toDate() : data.end;
+    return startDate < endDate;
+  },
+  {
+    message: "End time must be after start time",
+    path: ["end"]
+  }
+).refine(
+  (data) => {
+    const startDate = data.start instanceof Timestamp17 ? data.start.toDate() : data.start;
+    return startDate > /* @__PURE__ */ new Date();
+  },
+  {
+    message: "Appointment must be scheduled in the future",
+    path: ["start"]
+  }
+);
+var timeSlotSchema2 = z17.object({
+  start: z17.date(),
+  end: z17.date(),
+  isAvailable: z17.boolean()
+}).refine((data) => data.start < data.end, {
+  message: "End time must be after start time",
+  path: ["end"]
+});
+var syncedCalendarEventSchema = z17.object({
+  eventId: z17.string(),
+  syncedCalendarProvider: z17.nativeEnum(SyncedCalendarProvider),
+  syncedAt: z17.instanceof(Date).or(z17.instanceof(Timestamp17))
+});
+var procedureInfoSchema = z17.object({
+  name: z17.string(),
+  description: z17.string(),
+  duration: z17.number().min(MIN_APPOINTMENT_DURATION),
+  price: z17.number().min(0),
+  currency: z17.nativeEnum(Currency)
+});
+var procedureCategorizationSchema = z17.object({
+  procedureFamily: z17.string(),
+  // Replace with proper enum when available
+  procedureCategory: z17.string(),
+  // Replace with proper enum when available
+  procedureSubcategory: z17.string(),
+  // Replace with proper enum when available
+  procedureTechnology: z17.string(),
+  // Replace with proper enum when available
+  procedureProduct: z17.string()
+  // Replace with proper enum when available
+});
+var createAppointmentSchema = z17.object({
+  clinicId: z17.string().min(1, "Clinic ID is required"),
+  doctorId: z17.string().min(1, "Doctor ID is required"),
+  patientId: z17.string().min(1, "Patient ID is required"),
+  procedureId: z17.string().min(1, "Procedure ID is required"),
+  eventLocation: clinicLocationSchema,
+  eventTime: calendarEventTimeSchema,
+  description: z17.string().optional()
+}).refine(
+  (data) => {
+    return true;
+  },
+  {
+    message: "Invalid appointment parameters"
+  }
+);
+var updateAppointmentSchema = z17.object({
+  appointmentId: z17.string().min(1, "Appointment ID is required"),
+  clinicId: z17.string().min(1, "Clinic ID is required"),
+  doctorId: z17.string().min(1, "Doctor ID is required"),
+  patientId: z17.string().min(1, "Patient ID is required"),
+  eventTime: calendarEventTimeSchema.optional(),
+  description: z17.string().optional(),
+  status: z17.nativeEnum(CalendarEventStatus).optional()
+});
+var createCalendarEventSchema = z17.object({
+  id: z17.string(),
+  clinicBranchId: z17.string().nullable().optional(),
+  clinicBranchInfo: z17.any().nullable().optional(),
+  practitionerProfileId: z17.string().nullable().optional(),
+  practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
+  patientProfileId: z17.string().nullable().optional(),
+  patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
+  procedureId: z17.string().nullable().optional(),
+  appointmentId: z17.string().nullable().optional(),
+  syncedCalendarEventId: z17.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z17.string().min(1, "Event name is required"),
+  eventLocation: clinicLocationSchema.optional(),
+  eventTime: calendarEventTimeSchema,
+  description: z17.string().optional(),
+  status: z17.nativeEnum(CalendarEventStatus),
+  syncStatus: z17.nativeEnum(CalendarSyncStatus),
+  eventType: z17.nativeEnum(CalendarEventType),
+  createdAt: z17.any(),
+  // FieldValue for server timestamp
+  updatedAt: z17.any()
+  // FieldValue for server timestamp
+});
+var updateCalendarEventSchema = z17.object({
+  syncedCalendarEventId: z17.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: z17.string().nullable().optional(),
+  eventName: z17.string().optional(),
+  eventTime: calendarEventTimeSchema.optional(),
+  description: z17.string().optional(),
+  status: z17.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: z17.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: z17.nativeEnum(CalendarEventType).optional(),
+  updatedAt: z17.any()
+  // FieldValue for server timestamp
+});
+var calendarEventSchema = z17.object({
+  id: z17.string(),
+  clinicBranchId: z17.string().nullable().optional(),
+  clinicBranchInfo: z17.any().nullable().optional(),
+  // Will be replaced with proper clinic info schema
+  practitionerProfileId: z17.string().nullable().optional(),
+  practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
+  patientProfileId: z17.string().nullable().optional(),
+  patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
+  procedureId: z17.string().nullable().optional(),
+  procedureInfo: procedureInfoSchema.nullable().optional(),
+  procedureCategorization: procedureCategorizationSchema.nullable().optional(),
+  appointmentId: z17.string().nullable().optional(),
+  syncedCalendarEventId: z17.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z17.string(),
+  eventLocation: clinicLocationSchema.optional(),
+  eventTime: calendarEventTimeSchema,
+  description: z17.string().optional(),
+  status: z17.nativeEnum(CalendarEventStatus),
+  syncStatus: z17.nativeEnum(CalendarSyncStatus),
+  eventType: z17.nativeEnum(CalendarEventType),
+  createdAt: z17.instanceof(Date).or(z17.instanceof(Timestamp17)),
+  updatedAt: z17.instanceof(Date).or(z17.instanceof(Timestamp17))
+});
+
+// src/services/calendar/utils/clinic.utils.ts
+import {
+  collection as collection13,
+  doc as doc15,
+  getDoc as getDoc18,
+  getDocs as getDocs12,
+  setDoc as setDoc15,
+  updateDoc as updateDoc16,
+  deleteDoc as deleteDoc8,
+  query as query12,
+  where as where12,
+  orderBy as orderBy4,
+  Timestamp as Timestamp18,
+  serverTimestamp as serverTimestamp14
+} from "firebase/firestore";
+
+// src/services/calendar/utils/docs.utils.ts
+import { doc as doc14 } from "firebase/firestore";
+function getPractitionerCalendarEventDocRef(db, practitionerId, eventId) {
+  return doc14(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getPatientCalendarEventDocRef(db, patientId, eventId) {
+  return doc14(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getClinicCalendarEventDocRef(db, clinicId, eventId) {
+  return doc14(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+function getPractitionerSyncedCalendarDocRef(db, practitionerId, syncedCalendarId) {
+  return doc14(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+function getPatientSyncedCalendarDocRef(db, patientId, syncedCalendarId) {
+  return doc14(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+function getClinicSyncedCalendarDocRef(db, clinicId, syncedCalendarId) {
+  return doc14(
+    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: serverTimestamp14(),
+    updatedAt: serverTimestamp14()
+  };
+  await setDoc15(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: Timestamp18.now(),
+    updatedAt: Timestamp18.now()
+  };
+}
+async function updateClinicCalendarEventUtil(db, clinicId, eventId, updateData) {
+  const eventRef = getClinicCalendarEventDocRef(db, clinicId, eventId);
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp14()
+  };
+  await updateDoc16(eventRef, updates);
+  const updatedDoc = await getDoc18(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+async function checkAutoConfirmAppointmentsUtil(db, clinicId) {
+  const clinicDoc = await getDoc18(doc15(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 getDoc18(
+    doc15(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 collection14,
+  getDoc as getDoc19,
+  getDocs as getDocs13,
+  setDoc as setDoc16,
+  updateDoc as updateDoc17,
+  deleteDoc as deleteDoc9,
+  query as query13,
+  where as where13,
+  orderBy as orderBy5,
+  Timestamp as Timestamp19,
+  serverTimestamp as serverTimestamp15
+} 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: serverTimestamp15(),
+    updatedAt: serverTimestamp15()
+  };
+  await setDoc16(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: Timestamp19.now(),
+    updatedAt: Timestamp19.now()
+  };
+}
+async function updatePatientCalendarEventUtil(db, patientId, eventId, updateData) {
+  const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp15()
+  };
+  await updateDoc17(eventRef, updates);
+  const updatedDoc = await getDoc19(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 collection15,
+  getDoc as getDoc20,
+  getDocs as getDocs14,
+  setDoc as setDoc17,
+  updateDoc as updateDoc18,
+  deleteDoc as deleteDoc10,
+  query as query14,
+  where as where14,
+  orderBy as orderBy6,
+  Timestamp as Timestamp20,
+  serverTimestamp as serverTimestamp16
+} 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: serverTimestamp16(),
+    updatedAt: serverTimestamp16()
+  };
+  await setDoc17(eventRef, newEvent);
+  return {
+    ...newEvent,
+    createdAt: Timestamp20.now(),
+    updatedAt: Timestamp20.now()
+  };
+}
+async function updatePractitionerCalendarEventUtil(db, practitionerId, eventId, updateData) {
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp16()
+  };
+  await updateDoc18(eventRef, updates);
+  const updatedDoc = await getDoc20(eventRef);
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+  return updatedDoc.data();
+}
+
+// src/services/calendar/utils/appointment.utils.ts
+async function createAppointmentUtil(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 updateAppointmentUtil(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/synced-calendar.utils.ts
+import {
+  collection as collection16,
+  getDoc as getDoc21,
+  getDocs as getDocs15,
+  setDoc as setDoc18,
+  updateDoc as updateDoc19,
+  deleteDoc as deleteDoc11,
+  query as query15,
+  orderBy as orderBy7,
+  Timestamp as Timestamp21,
+  serverTimestamp as serverTimestamp17
+} 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: serverTimestamp17(),
+    updatedAt: serverTimestamp17()
+  };
+  await setDoc18(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: Timestamp21.now(),
+    updatedAt: Timestamp21.now()
+  };
+}
+async function createPatientSyncedCalendarUtil(db, patientId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp17(),
+    updatedAt: serverTimestamp17()
+  };
+  await setDoc18(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: Timestamp21.now(),
+    updatedAt: Timestamp21.now()
+  };
+}
+async function createClinicSyncedCalendarUtil(db, clinicId, calendarData, generateId2) {
+  const calendarId = generateId2();
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const newCalendar = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp17(),
+    updatedAt: serverTimestamp17()
+  };
+  await setDoc18(calendarRef, newCalendar);
+  return {
+    ...newCalendar,
+    createdAt: Timestamp21.now(),
+    updatedAt: Timestamp21.now()
+  };
+}
+async function getPractitionerSyncedCalendarUtil(db, practitionerId, calendarId) {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const calendarDoc = await getDoc21(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
+  const calendarsRef = collection16(
+    db,
+    `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = query15(calendarsRef, orderBy7("createdAt", "desc"));
+  const querySnapshot = await getDocs15(q);
+  return querySnapshot.docs.map((doc20) => doc20.data());
+}
+async function getPatientSyncedCalendarUtil(db, patientId, calendarId) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const calendarDoc = await getDoc21(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getPatientSyncedCalendarsUtil(db, patientId) {
+  const calendarsRef = collection16(
+    db,
+    `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = query15(calendarsRef, orderBy7("createdAt", "desc"));
+  const querySnapshot = await getDocs15(q);
+  return querySnapshot.docs.map((doc20) => doc20.data());
+}
+async function getClinicSyncedCalendarUtil(db, clinicId, calendarId) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const calendarDoc = await getDoc21(calendarRef);
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+  return calendarDoc.data();
+}
+async function getClinicSyncedCalendarsUtil(db, clinicId) {
+  const calendarsRef = collection16(
+    db,
+    `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+  const q = query15(calendarsRef, orderBy7("createdAt", "desc"));
+  const querySnapshot = await getDocs15(q);
+  return querySnapshot.docs.map((doc20) => doc20.data());
+}
+async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendarId, updateData) {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const updates = {
+    ...updateData,
+    updatedAt: serverTimestamp17()
+  };
+  await updateDoc19(calendarRef, updates);
+  const updatedDoc = await getDoc21(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: serverTimestamp17()
+  };
+  await updateDoc19(calendarRef, updates);
+  const updatedDoc = await getDoc21(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: serverTimestamp17()
+  };
+  await updateDoc19(calendarRef, updates);
+  const updatedDoc = await getDoc21(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 deleteDoc11(calendarRef);
+}
+async function deletePatientSyncedCalendarUtil(db, patientId, calendarId) {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  await deleteDoc11(calendarRef);
+}
+async function deleteClinicSyncedCalendarUtil(db, clinicId, calendarId) {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  await deleteDoc11(calendarRef);
+}
+async function updateLastSyncedTimestampUtil(db, entityType, entityId, calendarId) {
+  const updateData = {
+    lastSyncedAt: Timestamp21.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 Timestamp22 } 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: Timestamp22.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: Timestamp22.fromDate(start),
+      end: Timestamp22.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: Timestamp22.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-refactored.service.ts
+var MIN_APPOINTMENT_DURATION2 = 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 createAppointmentUtil(
+      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 updateAppointmentUtil(
+      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 = Timestamp23.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 = doc19(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      const newEvent = {
+        id: eventId,
+        ...eventData,
+        createdAt: serverTimestamp18(),
+        updatedAt: serverTimestamp18()
+      };
+      await setDoc19(eventRef, newEvent);
+      return {
+        ...newEvent,
+        createdAt: Timestamp23.now(),
+        updatedAt: Timestamp23.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 = collection17(this.db, PRACTITIONERS_COLLECTION);
+      const practitionersSnapshot = await getDocs16(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 = collection17(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION
+      );
+      const q = query16(
+        eventsRef,
+        where16("syncStatus", "==", "external" /* EXTERNAL */),
+        where16("eventTime.start", ">=", Timestamp23.fromDate(startDate)),
+        where16("eventTime.start", "<=", Timestamp23.fromDate(endDate))
+      );
+      const eventsSnapshot = await getDocs16(q);
+      const events = eventsSnapshot.docs.map((doc20) => ({
+        id: doc20.id,
+        ...doc20.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 = doc19(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      await updateDoc20(eventRef, {
+        eventName: externalEvent.summary || "External Event",
+        eventTime: {
+          start: Timestamp23.fromDate(startTime),
+          end: Timestamp23.fromDate(endTime)
+        },
+        description: externalEvent.description || "",
+        updatedAt: serverTimestamp18()
+      });
+      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 = doc19(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        doctorId,
+        CALENDAR_COLLECTION,
+        eventId
+      );
+      await updateDoc20(eventRef, {
+        status,
+        updatedAt: serverTimestamp18()
+      });
+      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`
+    );
+  }
+  // #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 = doc19(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await getDoc22(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 appointmentRef = doc19(this.db, CALENDAR_COLLECTION, appointmentId);
+    const appointmentDoc = await getDoc22(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,
+      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 */
+      ],
+      ["rejected" /* REJECTED */]: [],
+      ["canceled" /* CANCELED */]: [],
+      ["rescheduled" /* RESCHEDULED */]: [
+        "confirmed" /* CONFIRMED */,
+        "canceled" /* CANCELED */
+      ],
+      ["completed" /* COMPLETED */]: []
+    };
+    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;
+      }
+      if (appointment.status === "confirmed" /* CONFIRMED */ && activeDoctorCalendars.length > 0) {
+        await Promise.all(
+          activeDoctorCalendars.map(
+            (calendar) => this.syncEventToExternalCalendar(appointment, calendar, "doctor")
+          )
+        );
+      }
+      if (appointment.status !== "canceled" /* CANCELED */ && appointment.status !== "rejected" /* REJECTED */ && activePatientCalendars.length > 0) {
+        await Promise.all(
+          activePatientCalendars.map(
+            (calendar) => this.syncEventToExternalCalendar(appointment, calendar, "patient")
+          )
+        );
+      }
+    } 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}`;
+      }
+      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
+        );
+        if (result.success && ((_e = result.eventIds) == null ? void 0 : _e.length) && !existingSyncId) {
+          const newSyncEvent = {
+            eventId: result.eventIds[0],
+            syncedCalendarProvider: calendar.provider,
+            syncedAt: Timestamp23.now()
+          };
+          await this.updateEventWithSyncId(
+            entityType === "doctor" ? appointment.practitionerProfileId : appointment.patientProfileId,
+            entityType,
+            appointment.id,
+            newSyncEvent
+          );
+        }
+      }
+    } catch (error) {
+      console.error(`Error syncing with ${entityType}'s calendar:`, error);
+    }
+  }
+  /**
+   * 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 = doc19(this.db, collectionPath, eventId);
+      const eventDoc = await getDoc22(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 updateDoc20(eventRef, {
+          syncedCalendarEventId: syncIds,
+          updatedAt: serverTimestamp18()
+        });
+        console.log(
+          `Updated event ${eventId} with sync ID ${syncEvent.eventId}`
+        );
+      }
+    } catch (error) {
+      console.error("Error updating event with sync ID:", error);
+    }
+  }
+  /**
+   * Validates update permissions and parameters
+   * @param params - Update parameters to validate
+   */
+  async validateUpdatePermissions(params) {
+    await updateAppointmentSchema.parseAsync(params);
+  }
+  /**
+   * 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 = doc19(this.db, CLINICS_COLLECTION, clinicId);
+    const clinicDoc = await getDoc22(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;
+  }
+  /**
+   * 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 = doc19(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await getDoc22(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;
+  }
+  /**
+   * 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 = collection17(this.db, CALENDAR_COLLECTION);
+    const q = query16(
+      appointmentsRef,
+      where16("practitionerProfileId", "==", doctorId),
+      where16("eventTime.start", ">=", Timestamp23.fromDate(startOfDay)),
+      where16("eventTime.start", "<=", Timestamp23.fromDate(endOfDay)),
+      where16("status", "in", [
+        "confirmed" /* CONFIRMED */,
+        "pending" /* PENDING */
+      ])
+    );
+    const querySnapshot = await getDocs16(q);
+    return querySnapshot.docs.map((doc20) => doc20.data());
+  }
+  /**
+   * 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_DURATION2 * 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_DURATION2 * 60 * 1e3
+            );
+          }
+        }
+      }
+    }
+    return availableSlots;
+  }
+  /**
+   * 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([
+        getDoc22(doc19(this.db, CLINICS_COLLECTION, clinicId)),
+        getDoc22(doc19(this.db, PRACTITIONERS_COLLECTION, doctorId)),
+        getDoc22(doc19(this.db, PATIENTS_COLLECTION, patientId)),
+        getDoc22(
+          doc19(
+            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 || Timestamp23.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 || Timestamp23.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/validations/notification.schema.ts
+import { z as z18 } from "zod";
+var baseNotificationSchema = z18.object({
+  id: z18.string().optional(),
+  userId: z18.string(),
+  notificationTime: z18.any(),
   // Timestamp
-  notificationType: z16.nativeEnum(NotificationType),
-  notificationTokens: z16.array(z16.string()),
-  status: z16.nativeEnum(NotificationStatus),
-  createdAt: z16.any().optional(),
+  notificationType: z18.nativeEnum(NotificationType),
+  notificationTokens: z18.array(z18.string()),
+  status: z18.nativeEnum(NotificationStatus),
+  createdAt: z18.any().optional(),
   // Timestamp
-  updatedAt: z16.any().optional(),
+  updatedAt: z18.any().optional(),
   // Timestamp
-  title: z16.string(),
-  body: z16.string(),
-  isRead: z16.boolean(),
-  userRole: z16.nativeEnum(UserRole)
+  title: z18.string(),
+  body: z18.string(),
+  isRead: z18.boolean(),
+  userRole: z18.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z16.literal("preRequirement" /* PRE_REQUIREMENT */),
-  treatmentId: z16.string(),
-  requirements: z16.array(z16.string()),
-  deadline: z16.any()
+  notificationType: z18.literal("preRequirement" /* PRE_REQUIREMENT */),
+  treatmentId: z18.string(),
+  requirements: z18.array(z18.string()),
+  deadline: z18.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z16.literal("postRequirement" /* POST_REQUIREMENT */),
-  treatmentId: z16.string(),
-  requirements: z16.array(z16.string()),
-  deadline: z16.any()
+  notificationType: z18.literal("postRequirement" /* POST_REQUIREMENT */),
+  treatmentId: z18.string(),
+  requirements: z18.array(z18.string()),
+  deadline: z18.any()
   // Timestamp
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z16.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: z16.string(),
-  appointmentTime: z16.any(),
+  notificationType: z18.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: z18.string(),
+  appointmentTime: z18.any(),
   // Timestamp
-  treatmentType: z16.string(),
-  doctorName: z16.string()
+  treatmentType: z18.string(),
+  doctorName: z18.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z16.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
-  appointmentId: z16.string(),
-  appointmentStatus: z16.string(),
-  previousStatus: z16.string(),
-  reason: z16.string().optional()
+  notificationType: z18.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  appointmentId: z18.string(),
+  appointmentStatus: z18.string(),
+  previousStatus: z18.string(),
+  reason: z18.string().optional()
 });
-var notificationSchema = z16.discriminatedUnion("notificationType", [
+var notificationSchema = z18.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   appointmentReminderNotificationSchema,
@@ -6445,9 +9083,14 @@ export {
   AllergyType,
   AuthService,
   BlockingCondition,
+  CALENDAR_COLLECTION,
   CLINICS_COLLECTION,
   CLINIC_ADMINS_COLLECTION,
   CLINIC_GROUPS_COLLECTION,
+  CalendarEventStatus,
+  CalendarEventType,
+  CalendarServiceV2,
+  CalendarSyncStatus,
   CertificationLevel,
   CertificationSpecialty,
   ClinicAdminService,
@@ -6488,7 +9131,10 @@ export {
   PractitionerService,
   PricingMeasure,
   ProcedureFamily,
+  SYNCED_CALENDARS_COLLECTION,
   SubscriptionModel,
+  SyncedCalendarProvider,
+  SyncedCalendarsService,
   TreatmentBenefit,
   USER_ERRORS,
   UserService,
@@ -6505,6 +9151,8 @@ export {
   appointmentReminderNotificationSchema,
   baseNotificationSchema,
   blockingConditionSchema,
+  calendarEventSchema,
+  calendarEventTimeSchema,
   clinicAdminOptionsSchema,
   clinicAdminSchema,
   clinicAdminSignupSchema,
@@ -6520,6 +9168,8 @@ export {
   contactPersonSchema,
   contraindicationSchema,
   createAdminTokenSchema,
+  createAppointmentSchema,
+  createCalendarEventSchema,
   createClinicAdminSchema,
   createClinicGroupSchema,
   createClinicSchema,
@@ -6551,21 +9201,30 @@ export {
   patientDoctorSchema,
   patientLocationInfoSchema,
   patientMedicalInfoSchema,
+  patientProfileInfoSchema,
   patientProfileSchema,
   patientSensitiveInfoSchema,
   postRequirementNotificationSchema,
   practitionerBasicInfoSchema,
   practitionerCertificationSchema,
   practitionerClinicProceduresSchema,
+  practitionerClinicWorkingHoursSchema,
+  practitionerProfileInfoSchema,
   practitionerReviewSchema,
   practitionerSchema,
   practitionerWorkingHoursSchema,
   preRequirementNotificationSchema,
+  procedureCategorizationSchema,
+  procedureInfoSchema,
   reviewInfoSchema,
   serviceInfoSchema,
+  syncedCalendarEventSchema,
+  timeSlotSchema2 as timeSlotSchema,
   timestampSchema,
   updateAllergySchema,
+  updateAppointmentSchema,
   updateBlockingConditionSchema,
+  updateCalendarEventSchema,
   updateClinicAdminSchema,
   updateClinicGroupSchema,
   updateClinicSchema,