@blackcode_sa/metaestetics-api 1.4.18 → 1.5.1

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";
@@ -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);
@@ -3028,6 +3053,19 @@ import {
 
 // src/types/practitioner/index.ts
 var PRACTITIONERS_COLLECTION = "practitioners";
+var REGISTER_TOKENS_COLLECTION = "register_tokens";
+var PractitionerStatus = /* @__PURE__ */ ((PractitionerStatus2) => {
+  PractitionerStatus2["DRAFT"] = "draft";
+  PractitionerStatus2["ACTIVE"] = "active";
+  return PractitionerStatus2;
+})(PractitionerStatus || {});
+var PractitionerTokenStatus = /* @__PURE__ */ ((PractitionerTokenStatus2) => {
+  PractitionerTokenStatus2["ACTIVE"] = "active";
+  PractitionerTokenStatus2["USED"] = "used";
+  PractitionerTokenStatus2["EXPIRED"] = "expired";
+  PractitionerTokenStatus2["REVOKED"] = "revoked";
+  return PractitionerTokenStatus2;
+})(PractitionerTokenStatus || {});
 
 // src/validations/practitioner.schema.ts
 import { z as z10 } from "zod";
@@ -3096,6 +3134,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,8 +3174,10 @@ var practitionerSchema = z10.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
   clinics: z10.array(z10.string()),
+  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema),
   isActive: z10.boolean(),
   isVerified: z10.boolean(),
+  status: z10.nativeEnum(PractitionerStatus),
   createdAt: z10.instanceof(Timestamp7),
   updatedAt: z10.instanceof(Timestamp7)
 });
@@ -3131,8 +3186,37 @@ 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()
+  isVerified: z10.boolean(),
+  status: z10.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = z10.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z10.array(z10.string()).optional(),
+  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema).optional(),
+  isActive: z10.boolean().optional().default(false),
+  isVerified: z10.boolean().optional().default(false)
+});
+var practitionerTokenSchema = z10.object({
+  id: z10.string().min(1),
+  token: z10.string().min(6),
+  practitionerId: z10.string().min(1),
+  email: z10.string().email(),
+  clinicId: z10.string().min(1),
+  status: z10.nativeEnum(PractitionerTokenStatus),
+  createdBy: z10.string().min(1),
+  createdAt: z10.instanceof(Timestamp7),
+  expiresAt: z10.instanceof(Timestamp7),
+  usedBy: z10.string().optional(),
+  usedAt: z10.instanceof(Timestamp7).optional()
+});
+var createPractitionerTokenSchema = z10.object({
+  practitionerId: z10.string().min(1),
+  email: z10.string().email(),
+  clinicId: z10.string().min(1),
+  expiresAt: z10.date().optional()
 });
 
 // src/services/practitioner/practitioner.service.ts
@@ -3180,8 +3264,10 @@ var PractitionerService = class extends BaseService {
         basicInfo: validatedData.basicInfo,
         certification: validatedData.certification,
         clinics: validatedData.clinics || [],
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
+        status: validatedData.status || "active" /* ACTIVE */,
         createdAt: serverTimestamp9(),
         updatedAt: serverTimestamp9()
       };
@@ -3206,6 +3292,200 @@ var PractitionerService = class extends BaseService {
       throw error;
     }
   }
+  /**
+   * Kreira novi draft profil zdravstvenog radnika bez povezanog korisnika
+   * Koristi se od strane administratora klinike za kreiranje profila i kasnije pozivanje
+   * @param data Podaci za kreiranje draft profila
+   * @param createdBy ID administratora koji kreira profil
+   * @param clinicId ID klinike za koju se kreira profil
+   * @returns Objekt koji sadrži kreirani draft profil i token za registraciju
+   */
+  async createDraftPractitioner(data, createdBy, clinicId) {
+    try {
+      const validatedData = createDraftPractitionerSchema.parse(data);
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+      const clinics = data.clinics || [clinicId];
+      if (data.clinics) {
+        for (const cId of data.clinics) {
+          if (cId !== clinicId) {
+            const otherClinic = await this.getClinicService().getClinic(cId);
+            if (!otherClinic) {
+              throw new Error(`Clinic ${cId} not found`);
+            }
+          }
+        }
+      }
+      const practitionerId = this.generateId();
+      const practitionerData = {
+        id: practitionerId,
+        userRef: "",
+        // Prazno - biće popunjeno kada korisnik kreira nalog
+        basicInfo: validatedData.basicInfo,
+        certification: validatedData.certification,
+        clinics,
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
+        isActive: validatedData.isActive !== void 0 ? validatedData.isActive : false,
+        isVerified: validatedData.isVerified !== void 0 ? validatedData.isVerified : false,
+        status: "draft" /* DRAFT */,
+        createdAt: serverTimestamp9(),
+        updatedAt: serverTimestamp9()
+      };
+      practitionerSchema.parse({
+        ...practitionerData,
+        userRef: "temp-for-validation",
+        createdAt: Timestamp8.now(),
+        updatedAt: Timestamp8.now()
+      });
+      await setDoc7(
+        doc5(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
+        practitionerData
+      );
+      const savedPractitioner = await this.getPractitioner(practitionerData.id);
+      if (!savedPractitioner) {
+        throw new Error("Failed to create draft practitioner profile");
+      }
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+      const expiration = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+      const token = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId,
+        email: practitionerData.basicInfo.email,
+        clinicId,
+        status: "active" /* ACTIVE */,
+        createdBy,
+        createdAt: Timestamp8.now(),
+        expiresAt: Timestamp8.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await setDoc7(doc5(this.db, tokenPath), token);
+      return { practitioner: savedPractitioner, token };
+    } catch (error) {
+      if (error instanceof z11.ZodError) {
+        throw new Error("Invalid practitioner data: " + error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Creates a token for inviting practitioner to claim their profile
+   * @param data Data for creating token
+   * @param createdBy ID of the user creating the token
+   * @returns Created token
+   */
+  async createPractitionerToken(data, createdBy) {
+    try {
+      const validatedData = createPractitionerTokenSchema.parse(data);
+      const practitioner = await this.getPractitioner(
+        validatedData.practitionerId
+      );
+      if (!practitioner) {
+        throw new Error("Practitioner not found");
+      }
+      if (practitioner.status !== "draft" /* DRAFT */) {
+        throw new Error(
+          "Can only create tokens for practitioners in DRAFT status"
+        );
+      }
+      const clinic = await this.getClinicService().getClinic(
+        validatedData.clinicId
+      );
+      if (!clinic) {
+        throw new Error(`Clinic ${validatedData.clinicId} not found`);
+      }
+      if (!practitioner.clinics.includes(validatedData.clinicId)) {
+        throw new Error("Practitioner is not associated with this clinic");
+      }
+      const expiration = validatedData.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+      const token = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId: validatedData.practitionerId,
+        email: validatedData.email,
+        clinicId: validatedData.clinicId,
+        status: "active" /* ACTIVE */,
+        createdBy,
+        createdAt: Timestamp8.now(),
+        expiresAt: Timestamp8.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await setDoc7(doc5(this.db, tokenPath), token);
+      return token;
+    } catch (error) {
+      if (error instanceof z11.ZodError) {
+        throw new Error("Invalid token data: " + error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets active tokens for a practitioner
+   * @param practitionerId ID of the practitioner
+   * @returns Array of active tokens
+   */
+  async getPractitionerActiveTokens(practitionerId) {
+    const tokensRef = collection3(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+    );
+    const q = query3(
+      tokensRef,
+      where3("status", "==", "active" /* ACTIVE */),
+      where3("expiresAt", ">", Timestamp8.now())
+    );
+    const querySnapshot = await getDocs3(q);
+    return querySnapshot.docs.map((doc20) => doc20.data());
+  }
+  /**
+   * Gets a token by its string value and validates it
+   * @param tokenString The token string to find
+   * @returns The token if found and valid, null otherwise
+   */
+  async validateToken(tokenString) {
+    const practitionersRef = collection3(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await getDocs3(practitionersRef);
+    for (const practitionerDoc of practitionersSnapshot.docs) {
+      const practitionerId = practitionerDoc.id;
+      const tokensRef = collection3(
+        this.db,
+        `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+      );
+      const q = query3(
+        tokensRef,
+        where3("token", "==", tokenString),
+        where3("status", "==", "active" /* ACTIVE */),
+        where3("expiresAt", ">", Timestamp8.now())
+      );
+      const tokenSnapshot = await getDocs3(q);
+      if (!tokenSnapshot.empty) {
+        return tokenSnapshot.docs[0].data();
+      }
+    }
+    return null;
+  }
+  /**
+   * Marks a token as used
+   * @param tokenId ID of the token
+   * @param practitionerId ID of the practitioner
+   * @param userId ID of the user using the token
+   */
+  async markTokenAsUsed(tokenId, practitionerId, userId) {
+    const tokenRef = doc5(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
+    );
+    await updateDoc8(tokenRef, {
+      status: "used" /* USED */,
+      usedBy: userId,
+      usedAt: Timestamp8.now()
+    });
+  }
   /**
    * Dohvata zdravstvenog radnika po ID-u
    */
@@ -3239,10 +3519,23 @@ var PractitionerService = class extends BaseService {
     const q = query3(
       collection3(this.db, PRACTITIONERS_COLLECTION),
       where3("clinics", "array-contains", clinicId),
-      where3("isActive", "==", true)
+      where3("isActive", "==", true),
+      where3("status", "==", "active" /* ACTIVE */)
+    );
+    const querySnapshot = await getDocs3(q);
+    return querySnapshot.docs.map((doc20) => doc20.data());
+  }
+  /**
+   * Dohvata sve draft zdravstvene radnike za određenu kliniku
+   */
+  async getDraftPractitionersByClinic(clinicId) {
+    const q = query3(
+      collection3(this.db, PRACTITIONERS_COLLECTION),
+      where3("clinics", "array-contains", clinicId),
+      where3("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await getDocs3(q);
-    return querySnapshot.docs.map((doc14) => doc14.data());
+    return querySnapshot.docs.map((doc20) => doc20.data());
   }
   /**
    * Ažurira profil zdravstvenog radnika
@@ -3348,6 +3641,35 @@ var PractitionerService = class extends BaseService {
     }
     await deleteDoc2(doc5(this.db, PRACTITIONERS_COLLECTION, practitionerId));
   }
+  /**
+   * Validates a registration token and claims the associated draft practitioner profile
+   * @param tokenString The token provided by the practitioner
+   * @param userId The ID of the user claiming the profile
+   * @returns The claimed practitioner profile or null if token is invalid
+   */
+  async validateTokenAndClaimProfile(tokenString, userId) {
+    const token = await this.validateToken(tokenString);
+    if (!token) {
+      return null;
+    }
+    const practitioner = await this.getPractitioner(token.practitionerId);
+    if (!practitioner) {
+      return null;
+    }
+    if (practitioner.status !== "draft" /* DRAFT */) {
+      throw new Error("This practitioner profile has already been claimed");
+    }
+    const existingPractitioner = await this.getPractitionerByUserRef(userId);
+    if (existingPractitioner) {
+      throw new Error("User already has a practitioner profile");
+    }
+    const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
+      userRef: userId,
+      status: "active" /* ACTIVE */
+    });
+    await this.markTokenAsUsed(token.id, token.practitionerId, userId);
+    return updatedPractitioner;
+  }
 };
 
 // src/services/user.service.ts
@@ -3522,7 +3844,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 +4243,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 });
@@ -4591,7 +4913,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 });
@@ -4803,7 +5125,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(
@@ -4956,8 +5278,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]
@@ -5831,9 +6153,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()
     }));
   }
   /**
@@ -5847,9 +6169,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()
     }));
   }
   /**
@@ -5921,9 +6243,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()
     }));
   }
   /**
@@ -5936,9 +6258,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()
     }));
   }
 };
@@ -6068,9 +6390,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,
@@ -6098,9 +6420,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,
@@ -6127,9 +6449,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,
@@ -6254,9 +6576,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,
@@ -6283,9 +6605,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,
@@ -6312,9 +6634,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,
@@ -6341,9 +6663,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,
@@ -6370,9 +6692,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,
@@ -6381,55 +6703,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,
@@ -6441,9 +9362,14 @@ export {
   AllergyType,
   AuthService,
   BlockingCondition,
+  CALENDAR_COLLECTION,
   CLINICS_COLLECTION,
   CLINIC_ADMINS_COLLECTION,
   CLINIC_GROUPS_COLLECTION,
+  CalendarEventStatus,
+  CalendarEventType,
+  CalendarServiceV2,
+  CalendarSyncStatus,
   CertificationLevel,
   CertificationSpecialty,
   ClinicAdminService,
@@ -6482,9 +9408,15 @@ export {
   PatientService,
   PracticeType,
   PractitionerService,
+  PractitionerStatus,
+  PractitionerTokenStatus,
   PricingMeasure,
   ProcedureFamily,
+  REGISTER_TOKENS_COLLECTION,
+  SYNCED_CALENDARS_COLLECTION,
   SubscriptionModel,
+  SyncedCalendarProvider,
+  SyncedCalendarsService,
   TreatmentBenefit,
   USER_ERRORS,
   UserService,
@@ -6501,6 +9433,8 @@ export {
   appointmentReminderNotificationSchema,
   baseNotificationSchema,
   blockingConditionSchema,
+  calendarEventSchema,
+  calendarEventTimeSchema,
   clinicAdminOptionsSchema,
   clinicAdminSchema,
   clinicAdminSignupSchema,
@@ -6516,16 +9450,20 @@ export {
   contactPersonSchema,
   contraindicationSchema,
   createAdminTokenSchema,
+  createAppointmentSchema,
+  createCalendarEventSchema,
   createClinicAdminSchema,
   createClinicGroupSchema,
   createClinicSchema,
   createDefaultClinicGroupSchema,
   createDocumentTemplateSchema,
+  createDraftPractitionerSchema,
   createPatientLocationInfoSchema,
   createPatientMedicalInfoSchema,
   createPatientProfileSchema,
   createPatientSensitiveInfoSchema,
   createPractitionerSchema,
+  createPractitionerTokenSchema,
   createUserOptionsSchema,
   doctorInfoSchema,
   documentElementSchema,
@@ -6547,21 +9485,31 @@ export {
   patientDoctorSchema,
   patientLocationInfoSchema,
   patientMedicalInfoSchema,
+  patientProfileInfoSchema,
   patientProfileSchema,
   patientSensitiveInfoSchema,
   postRequirementNotificationSchema,
   practitionerBasicInfoSchema,
   practitionerCertificationSchema,
   practitionerClinicProceduresSchema,
+  practitionerClinicWorkingHoursSchema,
+  practitionerProfileInfoSchema,
   practitionerReviewSchema,
   practitionerSchema,
+  practitionerTokenSchema,
   practitionerWorkingHoursSchema,
   preRequirementNotificationSchema,
+  procedureCategorizationSchema,
+  procedureInfoSchema,
   reviewInfoSchema,
   serviceInfoSchema,
+  syncedCalendarEventSchema,
+  timeSlotSchema2 as timeSlotSchema,
   timestampSchema,
   updateAllergySchema,
+  updateAppointmentSchema,
   updateBlockingConditionSchema,
+  updateCalendarEventSchema,
   updateClinicAdminSchema,
   updateClinicGroupSchema,
   updateClinicSchema,