@blackcode_sa/metaestetics-api 1.5.4 → 1.5.7

package/dist/index.mjs

@@ -63,6 +63,8 @@ import {
 } from "firebase/firestore";
 
 // src/types/documentation-templates/index.ts
+var DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
+var FILLED_DOCUMENTS_COLLECTION = "filled-documents";
 var DocumentElementType = /* @__PURE__ */ ((DocumentElementType2) => {
   DocumentElementType2["HEADING"] = "heading";
   DocumentElementType2["PARAGRAPH"] = "paragraph";
@@ -142,8 +144,6 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
   return UserRole2;
 })(UserRole || {});
 var USERS_COLLECTION = "users";
-var DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
-var FILLED_DOCUMENTS_COLLECTION = "filled-documents";
 
 // src/services/auth.service.ts
 import { z as z15 } from "zod";
@@ -1310,9 +1310,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 doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1328,9 +1328,9 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1355,9 +1355,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 doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1373,9 +1373,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1400,9 +1400,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 doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1418,9 +1418,9 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1445,9 +1445,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 doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -1463,9 +1463,9 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc20 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc20.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc20.data();
+  const doc21 = await getDoc3(getMedicalInfoDocRef(db, patientId));
+  if (!doc21.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc21.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -2782,7 +2782,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     where2("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await getDocs2(q);
-  return querySnapshot.docs.map((doc20) => doc20.data());
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3449,7 +3449,7 @@ var PractitionerService = class extends BaseService {
       where3("expiresAt", ">", Timestamp8.now())
     );
     const querySnapshot = await getDocs3(q);
-    return querySnapshot.docs.map((doc20) => doc20.data());
+    return querySnapshot.docs.map((doc21) => doc21.data());
   }
   /**
    * Gets a token by its string value and validates it
@@ -3532,7 +3532,7 @@ var PractitionerService = class extends BaseService {
       where3("status", "==", "active" /* ACTIVE */)
     );
     const querySnapshot = await getDocs3(q);
-    return querySnapshot.docs.map((doc20) => doc20.data());
+    return querySnapshot.docs.map((doc21) => doc21.data());
   }
   /**
    * Dohvata sve draft zdravstvene radnike za određenu kliniku
@@ -3544,7 +3544,7 @@ var PractitionerService = class extends BaseService {
       where3("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await getDocs3(q);
-    return querySnapshot.docs.map((doc20) => doc20.data());
+    return querySnapshot.docs.map((doc21) => doc21.data());
   }
   /**
    * Ažurira profil zdravstvenog radnika
@@ -3853,7 +3853,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((doc20) => doc20.data());
+    const users = querySnapshot.docs.map((doc21) => doc21.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
   /**
@@ -4233,7 +4233,7 @@ async function getAllActiveGroups(db) {
     where5("isActive", "==", true)
   );
   const querySnapshot = await getDocs5(q);
-  return querySnapshot.docs.map((doc20) => doc20.data());
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
   console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
@@ -4903,7 +4903,7 @@ async function getClinicsByGroup(db, groupId) {
     where6("isActive", "==", true)
   );
   const querySnapshot = await getDocs6(q);
-  return querySnapshot.docs.map((doc20) => doc20.data());
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
   console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
@@ -5115,7 +5115,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((doc20) => doc20.data());
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -5268,8 +5268,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = query7(collection8(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs7(q);
-    for (const doc20 of querySnapshot.docs) {
-      const clinic = doc20.data();
+    for (const doc21 of querySnapshot.docs) {
+      const clinic = doc21.data();
       const distance = distanceBetween(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -6214,9 +6214,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc20) => ({
-      id: doc20.id,
-      ...doc20.data()
+    return querySnapshot.docs.map((doc21) => ({
+      id: doc21.id,
+      ...doc21.data()
     }));
   }
   /**
@@ -6230,9 +6230,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc20) => ({
-      id: doc20.id,
-      ...doc20.data()
+    return querySnapshot.docs.map((doc21) => ({
+      id: doc21.id,
+      ...doc21.data()
     }));
   }
   /**
@@ -6304,9 +6304,9 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc20) => ({
-      id: doc20.id,
-      ...doc20.data()
+    return querySnapshot.docs.map((doc21) => ({
+      id: doc21.id,
+      ...doc21.data()
     }));
   }
   /**
@@ -6319,24 +6319,267 @@ var NotificationService = class extends BaseService {
       orderBy("notificationTime", "desc")
     );
     const querySnapshot = await getDocs9(q);
-    return querySnapshot.docs.map((doc20) => ({
-      id: doc20.id,
-      ...doc20.data()
+    return querySnapshot.docs.map((doc21) => ({
+      id: doc21.id,
+      ...doc21.data()
     }));
   }
 };
 
-// src/services/documentation-templates/documentation-template.service.ts
+// src/services/procedure/procedure.service.ts
 import {
   collection as collection11,
   doc as doc12,
   getDoc as getDoc16,
   getDocs as getDocs10,
-  setDoc as setDoc13,
-  updateDoc as updateDoc14,
-  deleteDoc as deleteDoc7,
   query as query10,
   where as where10,
+  updateDoc as updateDoc14,
+  setDoc as setDoc13,
+  serverTimestamp as serverTimestamp13
+} from "firebase/firestore";
+
+// src/types/procedure/index.ts
+var PROCEDURES_COLLECTION = "procedures";
+
+// src/validations/procedure.schema.ts
+import { z as z16 } from "zod";
+var createProcedureSchema = z16.object({
+  name: z16.string().min(1).max(200),
+  description: z16.string().min(1).max(2e3),
+  family: z16.nativeEnum(ProcedureFamily),
+  categoryId: z16.string().min(1),
+  subcategoryId: z16.string().min(1),
+  technologyId: z16.string().min(1),
+  productId: z16.string().min(1),
+  price: z16.number().min(0),
+  currency: z16.nativeEnum(Currency),
+  pricingMeasure: z16.nativeEnum(PricingMeasure),
+  duration: z16.number().min(1).max(480),
+  // Max 8 hours
+  practitionerId: z16.string().min(1),
+  clinicBranchId: z16.string().min(1)
+});
+var updateProcedureSchema = z16.object({
+  name: z16.string().min(1).max(200).optional(),
+  description: z16.string().min(1).max(2e3).optional(),
+  price: z16.number().min(0).optional(),
+  currency: z16.nativeEnum(Currency).optional(),
+  pricingMeasure: z16.nativeEnum(PricingMeasure).optional(),
+  duration: z16.number().min(1).max(480).optional(),
+  // Max 8 hours
+  isActive: z16.boolean().optional()
+});
+var procedureSchema = createProcedureSchema.extend({
+  id: z16.string().min(1),
+  category: z16.any(),
+  // We'll validate the full category object separately
+  subcategory: z16.any(),
+  // We'll validate the full subcategory object separately
+  technology: z16.any(),
+  // We'll validate the full technology object separately
+  product: z16.any(),
+  // We'll validate the full product object separately
+  blockingConditions: z16.array(z16.any()),
+  // We'll validate blocking conditions separately
+  treatmentBenefits: z16.array(z16.any()),
+  // We'll validate treatment benefits separately
+  preRequirements: z16.array(z16.any()),
+  // We'll validate requirements separately
+  postRequirements: z16.array(z16.any()),
+  // We'll validate requirements separately
+  certificationRequirement: z16.any(),
+  // We'll validate certification requirement separately
+  documentationTemplates: z16.array(z16.any()),
+  // We'll validate documentation templates separately
+  isActive: z16.boolean(),
+  createdAt: z16.date(),
+  updatedAt: z16.date()
+});
+
+// src/backoffice/types/category.types.ts
+var CATEGORIES_COLLECTION = "backoffice_categories";
+
+// src/backoffice/types/subcategory.types.ts
+var SUBCATEGORIES_COLLECTION = "subcategories";
+
+// src/backoffice/types/technology.types.ts
+var TECHNOLOGIES_COLLECTION = "technologies";
+
+// src/backoffice/types/product.types.ts
+var PRODUCTS_COLLECTION = "products";
+
+// src/services/procedure/procedure.service.ts
+var ProcedureService = class extends BaseService {
+  constructor(db, auth, app) {
+    super(db, auth, app);
+  }
+  /**
+   * Creates a new procedure
+   * @param data - The data for creating a new procedure
+   * @returns The created procedure
+   */
+  async createProcedure(data) {
+    const validatedData = createProcedureSchema.parse(data);
+    const [category, subcategory, technology, product] = await Promise.all([
+      this.getCategory(validatedData.categoryId),
+      this.getSubcategory(validatedData.subcategoryId),
+      this.getTechnology(validatedData.technologyId),
+      this.getProduct(validatedData.productId)
+    ]);
+    if (!category || !subcategory || !technology || !product) {
+      throw new Error("One or more required entities not found");
+    }
+    const procedure = {
+      ...validatedData,
+      category,
+      subcategory,
+      technology,
+      product,
+      blockingConditions: technology.blockingConditions,
+      treatmentBenefits: technology.benefits,
+      preRequirements: technology.requirements.pre,
+      postRequirements: technology.requirements.post,
+      certificationRequirement: technology.certificationRequirement,
+      documentationTemplates: technology.documentationTemplates || [],
+      isActive: true,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const id = this.generateId();
+    const docRef = doc12(this.db, PROCEDURES_COLLECTION, id);
+    await setDoc13(docRef, {
+      ...procedure,
+      id,
+      createdAt: serverTimestamp13(),
+      updatedAt: serverTimestamp13()
+    });
+    return { ...procedure, id };
+  }
+  /**
+   * Gets a procedure by ID
+   * @param id - The ID of the procedure to get
+   * @returns The procedure if found, null otherwise
+   */
+  async getProcedure(id) {
+    const docRef = doc12(this.db, PROCEDURES_COLLECTION, id);
+    const docSnap = await getDoc16(docRef);
+    if (!docSnap.exists()) {
+      return null;
+    }
+    return docSnap.data();
+  }
+  /**
+   * Gets all procedures for a clinic branch
+   * @param clinicBranchId - The ID of the clinic branch
+   * @returns List of procedures
+   */
+  async getProceduresByClinicBranch(clinicBranchId) {
+    const q = query10(
+      collection11(this.db, PROCEDURES_COLLECTION),
+      where10("clinicBranchId", "==", clinicBranchId),
+      where10("isActive", "==", true)
+    );
+    const snapshot = await getDocs10(q);
+    return snapshot.docs.map((doc21) => doc21.data());
+  }
+  /**
+   * Gets all procedures for a practitioner
+   * @param practitionerId - The ID of the practitioner
+   * @returns List of procedures
+   */
+  async getProceduresByPractitioner(practitionerId) {
+    const q = query10(
+      collection11(this.db, PROCEDURES_COLLECTION),
+      where10("practitionerId", "==", practitionerId),
+      where10("isActive", "==", true)
+    );
+    const snapshot = await getDocs10(q);
+    return snapshot.docs.map((doc21) => doc21.data());
+  }
+  /**
+   * Updates a procedure
+   * @param id - The ID of the procedure to update
+   * @param data - The data to update
+   * @returns The updated procedure
+   */
+  async updateProcedure(id, data) {
+    const validatedData = updateProcedureSchema.parse(data);
+    const existingProcedure = await this.getProcedure(id);
+    if (!existingProcedure) {
+      throw new Error(`Procedure with ID ${id} not found`);
+    }
+    const docRef = doc12(this.db, PROCEDURES_COLLECTION, id);
+    await updateDoc14(docRef, {
+      ...validatedData,
+      updatedAt: serverTimestamp13()
+    });
+    return {
+      ...existingProcedure,
+      ...validatedData,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Deactivates a procedure
+   * @param id - The ID of the procedure to deactivate
+   */
+  async deactivateProcedure(id) {
+    const docRef = doc12(this.db, PROCEDURES_COLLECTION, id);
+    await updateDoc14(docRef, {
+      isActive: false,
+      updatedAt: serverTimestamp13()
+    });
+  }
+  /**
+   * Gets a category by ID
+   * @private
+   */
+  async getCategory(id) {
+    const docRef = doc12(this.db, CATEGORIES_COLLECTION, id);
+    const docSnap = await getDoc16(docRef);
+    return docSnap.exists() ? docSnap.data() : null;
+  }
+  /**
+   * Gets a subcategory by ID
+   * @private
+   */
+  async getSubcategory(id) {
+    const docRef = doc12(this.db, SUBCATEGORIES_COLLECTION, id);
+    const docSnap = await getDoc16(docRef);
+    return docSnap.exists() ? docSnap.data() : null;
+  }
+  /**
+   * Gets a technology by ID
+   * @private
+   */
+  async getTechnology(id) {
+    const docRef = doc12(this.db, TECHNOLOGIES_COLLECTION, id);
+    const docSnap = await getDoc16(docRef);
+    return docSnap.exists() ? docSnap.data() : null;
+  }
+  /**
+   * Gets a product by ID
+   * @private
+   */
+  async getProduct(id) {
+    const docRef = doc12(this.db, PRODUCTS_COLLECTION, id);
+    const docSnap = await getDoc16(docRef);
+    return docSnap.exists() ? docSnap.data() : null;
+  }
+};
+
+// src/services/documentation-templates/documentation-template.service.ts
+import {
+  collection as collection12,
+  doc as doc13,
+  getDoc as getDoc17,
+  getDocs as getDocs11,
+  setDoc as setDoc14,
+  updateDoc as updateDoc15,
+  deleteDoc as deleteDoc8,
+  query as query11,
+  where as where11,
   orderBy as orderBy2,
   limit,
   startAfter
@@ -6344,7 +6587,7 @@ import {
 var DocumentationTemplateService = class extends BaseService {
   constructor() {
     super(...arguments);
-    this.collectionRef = collection11(
+    this.collectionRef = collection12(
       this.db,
       DOCUMENTATION_TEMPLATES_COLLECTION
     );
@@ -6375,8 +6618,8 @@ var DocumentationTemplateService = class extends BaseService {
       isActive: true,
       tags: validatedData.tags || []
     };
-    const docRef = doc12(this.collectionRef, templateId);
-    await setDoc13(docRef, template);
+    const docRef = doc13(this.collectionRef, templateId);
+    await setDoc14(docRef, template);
     return template;
   }
   /**
@@ -6385,8 +6628,8 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns The template or null if not found
    */
   async getTemplateById(templateId) {
-    const docRef = doc12(this.collectionRef, templateId);
-    const docSnap = await getDoc16(docRef);
+    const docRef = doc13(this.collectionRef, templateId);
+    const docSnap = await getDoc17(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -6417,8 +6660,8 @@ var DocumentationTemplateService = class extends BaseService {
       updatedAt: Date.now(),
       version: template.version + 1
     };
-    const docRef = doc12(this.collectionRef, templateId);
-    await updateDoc14(docRef, updateData);
+    const docRef = doc13(this.collectionRef, templateId);
+    await updateDoc15(docRef, updateData);
     return {
       ...template,
       ...updateData
@@ -6429,8 +6672,8 @@ var DocumentationTemplateService = class extends BaseService {
    * @param templateId - ID of the template to delete
    */
   async deleteTemplate(templateId) {
-    const docRef = doc12(this.collectionRef, templateId);
-    await deleteDoc7(docRef);
+    const docRef = doc13(this.collectionRef, templateId);
+    await deleteDoc8(docRef);
   }
   /**
    * Get all active templates
@@ -6439,21 +6682,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getActiveTemplates(pageSize = 20, lastDoc) {
-    let q = query10(
+    let q = query11(
       this.collectionRef,
-      where10("isActive", "==", true),
+      where11("isActive", "==", true),
       orderBy2("updatedAt", "desc"),
       limit(pageSize)
     );
     if (lastDoc) {
-      q = query10(q, startAfter(lastDoc));
+      q = query11(q, startAfter(lastDoc));
     }
-    const querySnapshot = await getDocs10(q);
+    const querySnapshot = await getDocs11(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      templates.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      templates.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       templates,
@@ -6468,22 +6711,22 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getTemplatesByTags(tags, pageSize = 20, lastDoc) {
-    let q = query10(
+    let q = query11(
       this.collectionRef,
-      where10("isActive", "==", true),
-      where10("tags", "array-contains-any", tags),
+      where11("isActive", "==", true),
+      where11("tags", "array-contains-any", tags),
       orderBy2("updatedAt", "desc"),
       limit(pageSize)
     );
     if (lastDoc) {
-      q = query10(q, startAfter(lastDoc));
+      q = query11(q, startAfter(lastDoc));
     }
-    const querySnapshot = await getDocs10(q);
+    const querySnapshot = await getDocs11(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      templates.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      templates.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       templates,
@@ -6498,21 +6741,21 @@ var DocumentationTemplateService = class extends BaseService {
    * @returns Array of templates and the last document for pagination
    */
   async getTemplatesByCreator(userId, pageSize = 20, lastDoc) {
-    let q = query10(
+    let q = query11(
       this.collectionRef,
-      where10("createdBy", "==", userId),
+      where11("createdBy", "==", userId),
       orderBy2("updatedAt", "desc"),
       limit(pageSize)
     );
     if (lastDoc) {
-      q = query10(q, startAfter(lastDoc));
+      q = query11(q, startAfter(lastDoc));
     }
-    const querySnapshot = await getDocs10(q);
+    const querySnapshot = await getDocs11(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      templates.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      templates.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       templates,
@@ -6523,14 +6766,14 @@ var DocumentationTemplateService = class extends BaseService {
 
 // src/services/documentation-templates/filled-document.service.ts
 import {
-  collection as collection12,
-  doc as doc13,
-  getDoc as getDoc17,
-  getDocs as getDocs11,
-  setDoc as setDoc14,
-  updateDoc as updateDoc15,
-  query as query11,
-  where as where11,
+  collection as collection13,
+  doc as doc14,
+  getDoc as getDoc18,
+  getDocs as getDocs12,
+  setDoc as setDoc15,
+  updateDoc as updateDoc16,
+  query as query12,
+  where as where12,
   orderBy as orderBy3,
   limit as limit2,
   startAfter as startAfter2
@@ -6538,7 +6781,7 @@ import {
 var FilledDocumentService = class extends BaseService {
   constructor(...args) {
     super(...args);
-    this.collectionRef = collection12(
+    this.collectionRef = collection13(
       this.db,
       FILLED_DOCUMENTS_COLLECTION
     );
@@ -6571,8 +6814,8 @@ var FilledDocumentService = class extends BaseService {
       values: {},
       status: "draft" /* DRAFT */
     };
-    const docRef = doc13(this.collectionRef, documentId);
-    await setDoc14(docRef, filledDocument);
+    const docRef = doc14(this.collectionRef, documentId);
+    await setDoc15(docRef, filledDocument);
     return filledDocument;
   }
   /**
@@ -6581,8 +6824,8 @@ var FilledDocumentService = class extends BaseService {
    * @returns The filled document or null if not found
    */
   async getFilledDocumentById(documentId) {
-    const docRef = doc13(this.collectionRef, documentId);
-    const docSnap = await getDoc17(docRef);
+    const docRef = doc14(this.collectionRef, documentId);
+    const docSnap = await getDoc18(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -6610,8 +6853,8 @@ var FilledDocumentService = class extends BaseService {
     if (status) {
       updateData.status = status;
     }
-    const docRef = doc13(this.collectionRef, documentId);
-    await updateDoc15(docRef, updateData);
+    const docRef = doc14(this.collectionRef, documentId);
+    await updateDoc16(docRef, updateData);
     return {
       ...filledDocument,
       ...updateData
@@ -6625,21 +6868,21 @@ var FilledDocumentService = class extends BaseService {
    * @returns Array of filled documents and the last document for pagination
    */
   async getFilledDocumentsByPatient(patientId, pageSize = 20, lastDoc) {
-    let q = query11(
+    let q = query12(
       this.collectionRef,
-      where11("patientId", "==", patientId),
+      where12("patientId", "==", patientId),
       orderBy3("updatedAt", "desc"),
       limit2(pageSize)
     );
     if (lastDoc) {
-      q = query11(q, startAfter2(lastDoc));
+      q = query12(q, startAfter2(lastDoc));
     }
-    const querySnapshot = await getDocs11(q);
+    const querySnapshot = await getDocs12(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      documents.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      documents.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       documents,
@@ -6654,21 +6897,21 @@ var FilledDocumentService = class extends BaseService {
    * @returns Array of filled documents and the last document for pagination
    */
   async getFilledDocumentsByPractitioner(practitionerId, pageSize = 20, lastDoc) {
-    let q = query11(
+    let q = query12(
       this.collectionRef,
-      where11("practitionerId", "==", practitionerId),
+      where12("practitionerId", "==", practitionerId),
       orderBy3("updatedAt", "desc"),
       limit2(pageSize)
     );
     if (lastDoc) {
-      q = query11(q, startAfter2(lastDoc));
+      q = query12(q, startAfter2(lastDoc));
     }
-    const querySnapshot = await getDocs11(q);
+    const querySnapshot = await getDocs12(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      documents.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      documents.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       documents,
@@ -6683,21 +6926,21 @@ var FilledDocumentService = class extends BaseService {
    * @returns Array of filled documents and the last document for pagination
    */
   async getFilledDocumentsByClinic(clinicId, pageSize = 20, lastDoc) {
-    let q = query11(
+    let q = query12(
       this.collectionRef,
-      where11("clinicId", "==", clinicId),
+      where12("clinicId", "==", clinicId),
       orderBy3("updatedAt", "desc"),
       limit2(pageSize)
     );
     if (lastDoc) {
-      q = query11(q, startAfter2(lastDoc));
+      q = query12(q, startAfter2(lastDoc));
     }
-    const querySnapshot = await getDocs11(q);
+    const querySnapshot = await getDocs12(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      documents.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      documents.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       documents,
@@ -6712,21 +6955,21 @@ var FilledDocumentService = class extends BaseService {
    * @returns Array of filled documents and the last document for pagination
    */
   async getFilledDocumentsByTemplate(templateId, pageSize = 20, lastDoc) {
-    let q = query11(
+    let q = query12(
       this.collectionRef,
-      where11("templateId", "==", templateId),
+      where12("templateId", "==", templateId),
       orderBy3("updatedAt", "desc"),
       limit2(pageSize)
     );
     if (lastDoc) {
-      q = query11(q, startAfter2(lastDoc));
+      q = query12(q, startAfter2(lastDoc));
     }
-    const querySnapshot = await getDocs11(q);
+    const querySnapshot = await getDocs12(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      documents.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      documents.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       documents,
@@ -6741,21 +6984,21 @@ var FilledDocumentService = class extends BaseService {
    * @returns Array of filled documents and the last document for pagination
    */
   async getFilledDocumentsByStatus(status, pageSize = 20, lastDoc) {
-    let q = query11(
+    let q = query12(
       this.collectionRef,
-      where11("status", "==", status),
+      where12("status", "==", status),
       orderBy3("updatedAt", "desc"),
       limit2(pageSize)
     );
     if (lastDoc) {
-      q = query11(q, startAfter2(lastDoc));
+      q = query12(q, startAfter2(lastDoc));
     }
-    const querySnapshot = await getDocs11(q);
+    const querySnapshot = await getDocs12(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc20) => {
-      documents.push(doc20.data());
-      lastVisible = doc20;
+    querySnapshot.forEach((doc21) => {
+      documents.push(doc21.data());
+      lastVisible = doc21;
     });
     return {
       documents,
@@ -6765,7 +7008,7 @@ var FilledDocumentService = class extends BaseService {
 };
 
 // src/services/calendar/calendar-refactored.service.ts
-import { Timestamp as Timestamp23, serverTimestamp as serverTimestamp18 } from "firebase/firestore";
+import { Timestamp as Timestamp24, serverTimestamp as serverTimestamp19 } from "firebase/firestore";
 
 // src/types/calendar/synced-calendar.types.ts
 var SyncedCalendarProvider = /* @__PURE__ */ ((SyncedCalendarProvider3) => {
@@ -6778,57 +7021,57 @@ 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
+  doc as doc20,
+  getDoc as getDoc23,
+  collection as collection18,
+  query as query17,
+  where as where17,
+  getDocs as getDocs17,
+  setDoc as setDoc20,
+  updateDoc as updateDoc21
 } from "firebase/firestore";
 
 // src/validations/calendar.schema.ts
-import { z as z17 } from "zod";
-import { Timestamp as Timestamp17 } from "firebase/firestore";
+import { z as z18 } from "zod";
+import { Timestamp as Timestamp18 } from "firebase/firestore";
 
 // src/validations/profile-info.schema.ts
-import { z as z16 } from "zod";
-import { Timestamp as Timestamp16 } from "firebase/firestore";
-var clinicInfoSchema2 = z16.object({
-  id: z16.string(),
-  featuredPhoto: z16.string(),
-  name: z16.string(),
-  description: z16.string(),
+import { z as z17 } from "zod";
+import { Timestamp as Timestamp17 } from "firebase/firestore";
+var clinicInfoSchema2 = z17.object({
+  id: z17.string(),
+  featuredPhoto: z17.string(),
+  name: z17.string(),
+  description: z17.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(),
+var practitionerProfileInfoSchema = z17.object({
+  id: z17.string(),
+  practitionerPhoto: z17.string().nullable(),
+  name: z17.string(),
+  email: z17.string().email(),
+  phone: z17.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)
+var patientProfileInfoSchema = z17.object({
+  id: z17.string(),
+  fullName: z17.string(),
+  email: z17.string().email(),
+  phone: z17.string().nullable(),
+  dateOfBirth: z17.instanceof(Timestamp17),
+  gender: z17.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))
+var calendarEventTimeSchema = z18.object({
+  start: z18.instanceof(Date).or(z18.instanceof(Timestamp18)),
+  end: z18.instanceof(Date).or(z18.instanceof(Timestamp18))
 }).refine(
   (data) => {
-    const startDate = data.start instanceof Timestamp17 ? data.start.toDate() : data.start;
-    const endDate = data.end instanceof Timestamp17 ? data.end.toDate() : data.end;
+    const startDate = data.start instanceof Timestamp18 ? data.start.toDate() : data.start;
+    const endDate = data.end instanceof Timestamp18 ? data.end.toDate() : data.end;
     return startDate < endDate;
   },
   {
@@ -6837,7 +7080,7 @@ var calendarEventTimeSchema = z17.object({
   }
 ).refine(
   (data) => {
-    const startDate = data.start instanceof Timestamp17 ? data.start.toDate() : data.start;
+    const startDate = data.start instanceof Timestamp18 ? data.start.toDate() : data.start;
     return startDate > /* @__PURE__ */ new Date();
   },
   {
@@ -6845,46 +7088,46 @@ var calendarEventTimeSchema = z17.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = z17.object({
-  start: z17.date(),
-  end: z17.date(),
-  isAvailable: z17.boolean()
+var timeSlotSchema2 = z18.object({
+  start: z18.date(),
+  end: z18.date(),
+  isAvailable: z18.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 syncedCalendarEventSchema = z18.object({
+  eventId: z18.string(),
+  syncedCalendarProvider: z18.nativeEnum(SyncedCalendarProvider),
+  syncedAt: z18.instanceof(Date).or(z18.instanceof(Timestamp18))
 });
-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 procedureInfoSchema = z18.object({
+  name: z18.string(),
+  description: z18.string(),
+  duration: z18.number().min(MIN_APPOINTMENT_DURATION),
+  price: z18.number().min(0),
+  currency: z18.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = z17.object({
-  procedureFamily: z17.string(),
+var procedureCategorizationSchema = z18.object({
+  procedureFamily: z18.string(),
   // Replace with proper enum when available
-  procedureCategory: z17.string(),
+  procedureCategory: z18.string(),
   // Replace with proper enum when available
-  procedureSubcategory: z17.string(),
+  procedureSubcategory: z18.string(),
   // Replace with proper enum when available
-  procedureTechnology: z17.string(),
+  procedureTechnology: z18.string(),
   // Replace with proper enum when available
-  procedureProduct: z17.string()
+  procedureProduct: z18.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"),
+var createAppointmentSchema = z18.object({
+  clinicId: z18.string().min(1, "Clinic ID is required"),
+  doctorId: z18.string().min(1, "Doctor ID is required"),
+  patientId: z18.string().min(1, "Patient ID is required"),
+  procedureId: z18.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: z17.string().optional()
+  description: z18.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -6893,125 +7136,125 @@ var createAppointmentSchema = z17.object({
     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"),
+var updateAppointmentSchema = z18.object({
+  appointmentId: z18.string().min(1, "Appointment ID is required"),
+  clinicId: z18.string().min(1, "Clinic ID is required"),
+  doctorId: z18.string().min(1, "Doctor ID is required"),
+  patientId: z18.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z17.string().optional(),
-  status: z17.nativeEnum(CalendarEventStatus).optional()
+  description: z18.string().optional(),
+  status: z18.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(),
+var createCalendarEventSchema = z18.object({
+  id: z18.string(),
+  clinicBranchId: z18.string().nullable().optional(),
+  clinicBranchInfo: z18.any().nullable().optional(),
+  practitionerProfileId: z18.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z17.string().nullable().optional(),
+  patientProfileId: z18.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"),
+  procedureId: z18.string().nullable().optional(),
+  appointmentId: z18.string().nullable().optional(),
+  syncedCalendarEventId: z18.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z18.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(),
+  description: z18.string().optional(),
+  status: z18.nativeEnum(CalendarEventStatus),
+  syncStatus: z18.nativeEnum(CalendarSyncStatus),
+  eventType: z18.nativeEnum(CalendarEventType),
+  createdAt: z18.any(),
   // FieldValue for server timestamp
-  updatedAt: z17.any()
+  updatedAt: z18.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = z17.object({
-  syncedCalendarEventId: z17.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: z17.string().nullable().optional(),
-  eventName: z17.string().optional(),
+var updateCalendarEventSchema = z18.object({
+  syncedCalendarEventId: z18.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: z18.string().nullable().optional(),
+  eventName: z18.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()
+  description: z18.string().optional(),
+  status: z18.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: z18.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: z18.nativeEnum(CalendarEventType).optional(),
+  updatedAt: z18.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = z17.object({
-  id: z17.string(),
-  clinicBranchId: z17.string().nullable().optional(),
-  clinicBranchInfo: z17.any().nullable().optional(),
+var calendarEventSchema = z18.object({
+  id: z18.string(),
+  clinicBranchId: z18.string().nullable().optional(),
+  clinicBranchInfo: z18.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: z17.string().nullable().optional(),
+  practitionerProfileId: z18.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z17.string().nullable().optional(),
+  patientProfileId: z18.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z17.string().nullable().optional(),
+  procedureId: z18.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(),
+  appointmentId: z18.string().nullable().optional(),
+  syncedCalendarEventId: z18.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z18.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))
+  description: z18.string().optional(),
+  status: z18.nativeEnum(CalendarEventStatus),
+  syncStatus: z18.nativeEnum(CalendarSyncStatus),
+  eventType: z18.nativeEnum(CalendarEventType),
+  createdAt: z18.instanceof(Date).or(z18.instanceof(Timestamp18)),
+  updatedAt: z18.instanceof(Date).or(z18.instanceof(Timestamp18))
 });
 
 // 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,
+  collection as collection14,
+  doc as doc16,
+  getDoc as getDoc19,
+  getDocs as getDocs13,
+  setDoc as setDoc16,
+  updateDoc as updateDoc17,
+  deleteDoc as deleteDoc9,
+  query as query13,
+  where as where13,
   orderBy as orderBy4,
-  Timestamp as Timestamp18,
-  serverTimestamp as serverTimestamp14
+  Timestamp as Timestamp19,
+  serverTimestamp as serverTimestamp15
 } from "firebase/firestore";
 
 // src/services/calendar/utils/docs.utils.ts
-import { doc as doc14 } from "firebase/firestore";
+import { doc as doc15 } from "firebase/firestore";
 function getPractitionerCalendarEventDocRef(db, practitionerId, eventId) {
-  return doc14(
+  return doc15(
     db,
     `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
   );
 }
 function getPatientCalendarEventDocRef(db, patientId, eventId) {
-  return doc14(
+  return doc15(
     db,
     `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
   );
 }
 function getClinicCalendarEventDocRef(db, clinicId, eventId) {
-  return doc14(
+  return doc15(
     db,
     `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${eventId}`
   );
 }
 function getPractitionerSyncedCalendarDocRef(db, practitionerId, syncedCalendarId) {
-  return doc14(
+  return doc15(
     db,
     `${PRACTITIONERS_COLLECTION}/${practitionerId}/syncedCalendars/${syncedCalendarId}`
   );
 }
 function getPatientSyncedCalendarDocRef(db, patientId, syncedCalendarId) {
-  return doc14(
+  return doc15(
     db,
     `${PATIENTS_COLLECTION}/${patientId}/syncedCalendars/${syncedCalendarId}`
   );
 }
 function getClinicSyncedCalendarDocRef(db, clinicId, syncedCalendarId) {
-  return doc14(
+  return doc15(
     db,
     `${CLINICS_COLLECTION}/${clinicId}/syncedCalendars/${syncedCalendarId}`
   );
@@ -7024,31 +7267,31 @@ async function createClinicCalendarEventUtil(db, clinicId, eventData, generateId
   const newEvent = {
     id: eventId,
     ...eventData,
-    createdAt: serverTimestamp14(),
-    updatedAt: serverTimestamp14()
+    createdAt: serverTimestamp15(),
+    updatedAt: serverTimestamp15()
   };
-  await setDoc15(eventRef, newEvent);
+  await setDoc16(eventRef, newEvent);
   return {
     ...newEvent,
-    createdAt: Timestamp18.now(),
-    updatedAt: Timestamp18.now()
+    createdAt: Timestamp19.now(),
+    updatedAt: Timestamp19.now()
   };
 }
 async function updateClinicCalendarEventUtil(db, clinicId, eventId, updateData) {
   const eventRef = getClinicCalendarEventDocRef(db, clinicId, eventId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp14()
+    updatedAt: serverTimestamp15()
   };
-  await updateDoc16(eventRef, updates);
-  const updatedDoc = await getDoc18(eventRef);
+  await updateDoc17(eventRef, updates);
+  const updatedDoc = await getDoc19(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}`));
+  const clinicDoc = await getDoc19(doc16(db, `clinics/${clinicId}`));
   if (!clinicDoc.exists()) {
     throw new Error(`Clinic with ID ${clinicId} not found`);
   }
@@ -7057,8 +7300,8 @@ async function checkAutoConfirmAppointmentsUtil(db, clinicId) {
   if (!clinicGroupId) {
     return false;
   }
-  const clinicGroupDoc = await getDoc18(
-    doc15(db, `${CLINIC_GROUPS_COLLECTION}/${clinicGroupId}`)
+  const clinicGroupDoc = await getDoc19(
+    doc16(db, `${CLINIC_GROUPS_COLLECTION}/${clinicGroupId}`)
   );
   if (!clinicGroupDoc.exists()) {
     return false;
@@ -7069,17 +7312,17 @@ async function checkAutoConfirmAppointmentsUtil(db, clinicId) {
 
 // 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,
+  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 orderBy5,
-  Timestamp as Timestamp19,
-  serverTimestamp as serverTimestamp15
+  Timestamp as Timestamp20,
+  serverTimestamp as serverTimestamp16
 } from "firebase/firestore";
 async function createPatientCalendarEventUtil(db, patientId, eventData, generateId2) {
   const eventId = generateId2();
@@ -7087,24 +7330,24 @@ async function createPatientCalendarEventUtil(db, patientId, eventData, generate
   const newEvent = {
     id: eventId,
     ...eventData,
-    createdAt: serverTimestamp15(),
-    updatedAt: serverTimestamp15()
+    createdAt: serverTimestamp16(),
+    updatedAt: serverTimestamp16()
   };
-  await setDoc16(eventRef, newEvent);
+  await setDoc17(eventRef, newEvent);
   return {
     ...newEvent,
-    createdAt: Timestamp19.now(),
-    updatedAt: Timestamp19.now()
+    createdAt: Timestamp20.now(),
+    updatedAt: Timestamp20.now()
   };
 }
 async function updatePatientCalendarEventUtil(db, patientId, eventId, updateData) {
   const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp15()
+    updatedAt: serverTimestamp16()
   };
-  await updateDoc17(eventRef, updates);
-  const updatedDoc = await getDoc19(eventRef);
+  await updateDoc18(eventRef, updates);
+  const updatedDoc = await getDoc20(eventRef);
   if (!updatedDoc.exists()) {
     throw new Error("Event not found after update");
   }
@@ -7113,17 +7356,17 @@ async function updatePatientCalendarEventUtil(db, patientId, eventId, updateData
 
 // 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,
+  collection as collection16,
+  getDoc as getDoc21,
+  getDocs as getDocs15,
+  setDoc as setDoc18,
+  updateDoc as updateDoc19,
+  deleteDoc as deleteDoc11,
+  query as query15,
+  where as where15,
   orderBy as orderBy6,
-  Timestamp as Timestamp20,
-  serverTimestamp as serverTimestamp16
+  Timestamp as Timestamp21,
+  serverTimestamp as serverTimestamp17
 } from "firebase/firestore";
 async function createPractitionerCalendarEventUtil(db, practitionerId, eventData, generateId2) {
   const eventId = generateId2();
@@ -7135,14 +7378,14 @@ async function createPractitionerCalendarEventUtil(db, practitionerId, eventData
   const newEvent = {
     id: eventId,
     ...eventData,
-    createdAt: serverTimestamp16(),
-    updatedAt: serverTimestamp16()
+    createdAt: serverTimestamp17(),
+    updatedAt: serverTimestamp17()
   };
-  await setDoc17(eventRef, newEvent);
+  await setDoc18(eventRef, newEvent);
   return {
     ...newEvent,
-    createdAt: Timestamp20.now(),
-    updatedAt: Timestamp20.now()
+    createdAt: Timestamp21.now(),
+    updatedAt: Timestamp21.now()
   };
 }
 async function updatePractitionerCalendarEventUtil(db, practitionerId, eventId, updateData) {
@@ -7153,10 +7396,10 @@ async function updatePractitionerCalendarEventUtil(db, practitionerId, eventId,
   );
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp16()
+    updatedAt: serverTimestamp17()
   };
-  await updateDoc18(eventRef, updates);
-  const updatedDoc = await getDoc20(eventRef);
+  await updateDoc19(eventRef, updates);
+  const updatedDoc = await getDoc21(eventRef);
   if (!updatedDoc.exists()) {
     throw new Error("Event not found after update");
   }
@@ -7233,16 +7476,16 @@ async function updateAppointmentUtil(db, clinicId, practitionerId, patientId, ev
 
 // 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,
+  collection as collection17,
+  getDoc as getDoc22,
+  getDocs as getDocs16,
+  setDoc as setDoc19,
+  updateDoc as updateDoc20,
+  deleteDoc as deleteDoc12,
+  query as query16,
   orderBy as orderBy7,
-  Timestamp as Timestamp21,
-  serverTimestamp as serverTimestamp17
+  Timestamp as Timestamp22,
+  serverTimestamp as serverTimestamp18
 } from "firebase/firestore";
 async function createPractitionerSyncedCalendarUtil(db, practitionerId, calendarData, generateId2) {
   const calendarId = generateId2();
@@ -7254,14 +7497,14 @@ async function createPractitionerSyncedCalendarUtil(db, practitionerId, calendar
   const newCalendar = {
     id: calendarId,
     ...calendarData,
-    createdAt: serverTimestamp17(),
-    updatedAt: serverTimestamp17()
+    createdAt: serverTimestamp18(),
+    updatedAt: serverTimestamp18()
   };
-  await setDoc18(calendarRef, newCalendar);
+  await setDoc19(calendarRef, newCalendar);
   return {
     ...newCalendar,
-    createdAt: Timestamp21.now(),
-    updatedAt: Timestamp21.now()
+    createdAt: Timestamp22.now(),
+    updatedAt: Timestamp22.now()
   };
 }
 async function createPatientSyncedCalendarUtil(db, patientId, calendarData, generateId2) {
@@ -7270,14 +7513,14 @@ async function createPatientSyncedCalendarUtil(db, patientId, calendarData, gene
   const newCalendar = {
     id: calendarId,
     ...calendarData,
-    createdAt: serverTimestamp17(),
-    updatedAt: serverTimestamp17()
+    createdAt: serverTimestamp18(),
+    updatedAt: serverTimestamp18()
   };
-  await setDoc18(calendarRef, newCalendar);
+  await setDoc19(calendarRef, newCalendar);
   return {
     ...newCalendar,
-    createdAt: Timestamp21.now(),
-    updatedAt: Timestamp21.now()
+    createdAt: Timestamp22.now(),
+    updatedAt: Timestamp22.now()
   };
 }
 async function createClinicSyncedCalendarUtil(db, clinicId, calendarData, generateId2) {
@@ -7286,14 +7529,14 @@ async function createClinicSyncedCalendarUtil(db, clinicId, calendarData, genera
   const newCalendar = {
     id: calendarId,
     ...calendarData,
-    createdAt: serverTimestamp17(),
-    updatedAt: serverTimestamp17()
+    createdAt: serverTimestamp18(),
+    updatedAt: serverTimestamp18()
   };
-  await setDoc18(calendarRef, newCalendar);
+  await setDoc19(calendarRef, newCalendar);
   return {
     ...newCalendar,
-    createdAt: Timestamp21.now(),
-    updatedAt: Timestamp21.now()
+    createdAt: Timestamp22.now(),
+    updatedAt: Timestamp22.now()
   };
 }
 async function getPractitionerSyncedCalendarUtil(db, practitionerId, calendarId) {
@@ -7302,54 +7545,54 @@ async function getPractitionerSyncedCalendarUtil(db, practitionerId, calendarId)
     practitionerId,
     calendarId
   );
-  const calendarDoc = await getDoc21(calendarRef);
+  const calendarDoc = await getDoc22(calendarRef);
   if (!calendarDoc.exists()) {
     return null;
   }
   return calendarDoc.data();
 }
 async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
-  const calendarsRef = collection16(
+  const calendarsRef = collection17(
     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());
+  const q = query16(calendarsRef, orderBy7("createdAt", "desc"));
+  const querySnapshot = await getDocs16(q);
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function getPatientSyncedCalendarUtil(db, patientId, calendarId) {
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-  const calendarDoc = await getDoc21(calendarRef);
+  const calendarDoc = await getDoc22(calendarRef);
   if (!calendarDoc.exists()) {
     return null;
   }
   return calendarDoc.data();
 }
 async function getPatientSyncedCalendarsUtil(db, patientId) {
-  const calendarsRef = collection16(
+  const calendarsRef = collection17(
     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());
+  const q = query16(calendarsRef, orderBy7("createdAt", "desc"));
+  const querySnapshot = await getDocs16(q);
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function getClinicSyncedCalendarUtil(db, clinicId, calendarId) {
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-  const calendarDoc = await getDoc21(calendarRef);
+  const calendarDoc = await getDoc22(calendarRef);
   if (!calendarDoc.exists()) {
     return null;
   }
   return calendarDoc.data();
 }
 async function getClinicSyncedCalendarsUtil(db, clinicId) {
-  const calendarsRef = collection16(
+  const calendarsRef = collection17(
     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());
+  const q = query16(calendarsRef, orderBy7("createdAt", "desc"));
+  const querySnapshot = await getDocs16(q);
+  return querySnapshot.docs.map((doc21) => doc21.data());
 }
 async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendarId, updateData) {
   const calendarRef = getPractitionerSyncedCalendarDocRef(
@@ -7359,10 +7602,10 @@ async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendar
   );
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp17()
+    updatedAt: serverTimestamp18()
   };
-  await updateDoc19(calendarRef, updates);
-  const updatedDoc = await getDoc21(calendarRef);
+  await updateDoc20(calendarRef, updates);
+  const updatedDoc = await getDoc22(calendarRef);
   if (!updatedDoc.exists()) {
     throw new Error("Synced calendar not found after update");
   }
@@ -7372,10 +7615,10 @@ async function updatePatientSyncedCalendarUtil(db, patientId, calendarId, update
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp17()
+    updatedAt: serverTimestamp18()
   };
-  await updateDoc19(calendarRef, updates);
-  const updatedDoc = await getDoc21(calendarRef);
+  await updateDoc20(calendarRef, updates);
+  const updatedDoc = await getDoc22(calendarRef);
   if (!updatedDoc.exists()) {
     throw new Error("Synced calendar not found after update");
   }
@@ -7385,10 +7628,10 @@ async function updateClinicSyncedCalendarUtil(db, clinicId, calendarId, updateDa
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp17()
+    updatedAt: serverTimestamp18()
   };
-  await updateDoc19(calendarRef, updates);
-  const updatedDoc = await getDoc21(calendarRef);
+  await updateDoc20(calendarRef, updates);
+  const updatedDoc = await getDoc22(calendarRef);
   if (!updatedDoc.exists()) {
     throw new Error("Synced calendar not found after update");
   }
@@ -7400,19 +7643,19 @@ async function deletePractitionerSyncedCalendarUtil(db, practitionerId, calendar
     practitionerId,
     calendarId
   );
-  await deleteDoc11(calendarRef);
+  await deleteDoc12(calendarRef);
 }
 async function deletePatientSyncedCalendarUtil(db, patientId, calendarId) {
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-  await deleteDoc11(calendarRef);
+  await deleteDoc12(calendarRef);
 }
 async function deleteClinicSyncedCalendarUtil(db, clinicId, calendarId) {
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-  await deleteDoc11(calendarRef);
+  await deleteDoc12(calendarRef);
 }
 async function updateLastSyncedTimestampUtil(db, entityType, entityId, calendarId) {
   const updateData = {
-    lastSyncedAt: Timestamp21.now()
+    lastSyncedAt: Timestamp22.now()
   };
   switch (entityType) {
     case "practitioner":
@@ -7442,7 +7685,7 @@ async function updateLastSyncedTimestampUtil(db, entityType, entityId, calendarI
 }
 
 // src/services/calendar/utils/google-calendar.utils.ts
-import { Timestamp as Timestamp22 } from "firebase/firestore";
+import { Timestamp as Timestamp23 } 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";
@@ -7562,7 +7805,7 @@ async function ensureValidToken(db, entityType, entityId, syncedCalendar) {
     tokenExpiry.setSeconds(tokenExpiry.getSeconds() + expiresIn);
     const updateData = {
       accessToken,
-      tokenExpiry: Timestamp22.fromDate(tokenExpiry)
+      tokenExpiry: Timestamp23.fromDate(tokenExpiry)
     };
     switch (entityType) {
       case "practitioner":
@@ -7737,8 +7980,8 @@ function convertGoogleEventToCalendarEventUtil(googleEvent, entityId, entityType
     eventName: googleEvent.summary || "External Event",
     eventLocation: googleEvent.location,
     eventTime: {
-      start: Timestamp22.fromDate(start),
-      end: Timestamp22.fromDate(end)
+      start: Timestamp23.fromDate(start),
+      end: Timestamp23.fromDate(end)
     },
     description: googleEvent.description || "",
     // External events are always set as CONFIRMED - status updates will happen externally
@@ -7752,7 +7995,7 @@ function convertGoogleEventToCalendarEventUtil(googleEvent, entityId, entityType
       {
         eventId: googleEvent.id,
         syncedCalendarProvider: "google" /* GOOGLE */,
-        syncedAt: Timestamp22.now()
+        syncedAt: Timestamp23.now()
       }
     ]
   };
@@ -8530,7 +8773,7 @@ var CalendarServiceV2 = class extends BaseService {
       return 0;
     }
     let importedEventsCount = 0;
-    const currentTime = Timestamp23.now();
+    const currentTime = Timestamp24.now();
     for (const calendar of activeCalendars) {
       try {
         let externalEvents = [];
@@ -8597,7 +8840,7 @@ var CalendarServiceV2 = class extends BaseService {
   async createDoctorBlockingEvent(doctorId, eventData) {
     try {
       const eventId = this.generateId();
-      const eventRef = doc19(
+      const eventRef = doc20(
         this.db,
         PRACTITIONERS_COLLECTION,
         doctorId,
@@ -8607,14 +8850,14 @@ var CalendarServiceV2 = class extends BaseService {
       const newEvent = {
         id: eventId,
         ...eventData,
-        createdAt: serverTimestamp18(),
-        updatedAt: serverTimestamp18()
+        createdAt: serverTimestamp19(),
+        updatedAt: serverTimestamp19()
       };
-      await setDoc19(eventRef, newEvent);
+      await setDoc20(eventRef, newEvent);
       return {
         ...newEvent,
-        createdAt: Timestamp23.now(),
-        updatedAt: Timestamp23.now()
+        createdAt: Timestamp24.now(),
+        updatedAt: Timestamp24.now()
       };
     } catch (error) {
       console.error(
@@ -8632,8 +8875,8 @@ var CalendarServiceV2 = class extends BaseService {
    */
   async synchronizeExternalCalendars(lookbackDays = 7, lookforwardDays = 30) {
     try {
-      const practitionersRef = collection17(this.db, PRACTITIONERS_COLLECTION);
-      const practitionersSnapshot = await getDocs16(practitionersRef);
+      const practitionersRef = collection18(this.db, PRACTITIONERS_COLLECTION);
+      const practitionersSnapshot = await getDocs17(practitionersRef);
       const startDate = /* @__PURE__ */ new Date();
       startDate.setDate(startDate.getDate() - lookbackDays);
       const endDate = /* @__PURE__ */ new Date();
@@ -8691,22 +8934,22 @@ var CalendarServiceV2 = class extends BaseService {
   async updateExistingEventsFromExternalCalendars(doctorId, startDate, endDate) {
     var _a;
     try {
-      const eventsRef = collection17(
+      const eventsRef = collection18(
         this.db,
         PRACTITIONERS_COLLECTION,
         doctorId,
         CALENDAR_COLLECTION
       );
-      const q = query16(
+      const q = query17(
         eventsRef,
-        where16("syncStatus", "==", "external" /* EXTERNAL */),
-        where16("eventTime.start", ">=", Timestamp23.fromDate(startDate)),
-        where16("eventTime.start", "<=", Timestamp23.fromDate(endDate))
+        where17("syncStatus", "==", "external" /* EXTERNAL */),
+        where17("eventTime.start", ">=", Timestamp24.fromDate(startDate)),
+        where17("eventTime.start", "<=", Timestamp24.fromDate(endDate))
       );
-      const eventsSnapshot = await getDocs16(q);
-      const events = eventsSnapshot.docs.map((doc20) => ({
-        id: doc20.id,
-        ...doc20.data()
+      const eventsSnapshot = await getDocs17(q);
+      const events = eventsSnapshot.docs.map((doc21) => ({
+        id: doc21.id,
+        ...doc21.data()
       }));
       const calendars = await this.syncedCalendarsService.getPractitionerSyncedCalendars(
         doctorId
@@ -8810,21 +9053,21 @@ var CalendarServiceV2 = class extends BaseService {
       const endTime = new Date(
         externalEvent.end.dateTime || externalEvent.end.date
       );
-      const eventRef = doc19(
+      const eventRef = doc20(
         this.db,
         PRACTITIONERS_COLLECTION,
         doctorId,
         CALENDAR_COLLECTION,
         eventId
       );
-      await updateDoc20(eventRef, {
+      await updateDoc21(eventRef, {
         eventName: externalEvent.summary || "External Event",
         eventTime: {
-          start: Timestamp23.fromDate(startTime),
-          end: Timestamp23.fromDate(endTime)
+          start: Timestamp24.fromDate(startTime),
+          end: Timestamp24.fromDate(endTime)
         },
         description: externalEvent.description || "",
-        updatedAt: serverTimestamp18()
+        updatedAt: serverTimestamp19()
       });
       console.log(`Updated local event ${eventId} from external event`);
     } catch (error) {
@@ -8842,16 +9085,16 @@ var CalendarServiceV2 = class extends BaseService {
    */
   async updateEventStatus(doctorId, eventId, status) {
     try {
-      const eventRef = doc19(
+      const eventRef = doc20(
         this.db,
         PRACTITIONERS_COLLECTION,
         doctorId,
         CALENDAR_COLLECTION,
         eventId
       );
-      await updateDoc20(eventRef, {
+      await updateDoc21(eventRef, {
         status,
-        updatedAt: serverTimestamp18()
+        updatedAt: serverTimestamp19()
       });
       console.log(`Updated event ${eventId} status to ${status}`);
     } catch (error) {
@@ -8912,8 +9155,8 @@ var CalendarServiceV2 = class extends BaseService {
     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);
+    const practitionerRef = doc20(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await getDoc23(practitionerRef);
     if (!practitionerDoc.exists()) {
       throw new Error(`Doctor with ID ${doctorId} not found`);
     }
@@ -8970,8 +9213,8 @@ var CalendarServiceV2 = class extends BaseService {
    * @returns Updated calendar event
    */
   async updateAppointmentStatus(appointmentId, clinicId, status) {
-    const appointmentRef = doc19(this.db, CALENDAR_COLLECTION, appointmentId);
-    const appointmentDoc = await getDoc22(appointmentRef);
+    const appointmentRef = doc20(this.db, CALENDAR_COLLECTION, appointmentId);
+    const appointmentDoc = await getDoc23(appointmentRef);
     if (!appointmentDoc.exists()) {
       throw new Error(`Appointment with ID ${appointmentId} not found`);
     }
@@ -9102,7 +9345,7 @@ var CalendarServiceV2 = class extends BaseService {
           const newSyncEvent = {
             eventId: result.eventIds[0],
             syncedCalendarProvider: calendar.provider,
-            syncedAt: Timestamp23.now()
+            syncedAt: Timestamp24.now()
           };
           await this.updateEventWithSyncId(
             entityType === "doctor" ? appointment.practitionerProfileId : appointment.patientProfileId,
@@ -9126,8 +9369,8 @@ var CalendarServiceV2 = class extends BaseService {
   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);
+      const eventRef = doc20(this.db, collectionPath, eventId);
+      const eventDoc = await getDoc23(eventRef);
       if (eventDoc.exists()) {
         const event = eventDoc.data();
         const syncIds = [...event.syncedCalendarEventId || []];
@@ -9139,9 +9382,9 @@ var CalendarServiceV2 = class extends BaseService {
         } else {
           syncIds.push(syncEvent);
         }
-        await updateDoc20(eventRef, {
+        await updateDoc21(eventRef, {
           syncedCalendarEventId: syncIds,
-          updatedAt: serverTimestamp18()
+          updatedAt: serverTimestamp19()
         });
         console.log(
           `Updated event ${eventId} with sync ID ${syncEvent.eventId}`
@@ -9165,8 +9408,8 @@ var CalendarServiceV2 = class extends BaseService {
    * @returns Working hours for the clinic
    */
   async getClinicWorkingHours(clinicId, date) {
-    const clinicRef = doc19(this.db, CLINICS_COLLECTION, clinicId);
-    const clinicDoc = await getDoc22(clinicRef);
+    const clinicRef = doc20(this.db, CLINICS_COLLECTION, clinicId);
+    const clinicDoc = await getDoc23(clinicRef);
     if (!clinicDoc.exists()) {
       throw new Error(`Clinic with ID ${clinicId} not found`);
     }
@@ -9194,8 +9437,8 @@ var CalendarServiceV2 = class extends BaseService {
    * @returns Doctor's schedule
    */
   async getDoctorSchedule(doctorId, date) {
-    const practitionerRef = doc19(this.db, PRACTITIONERS_COLLECTION, doctorId);
-    const practitionerDoc = await getDoc22(practitionerRef);
+    const practitionerRef = doc20(this.db, PRACTITIONERS_COLLECTION, doctorId);
+    const practitionerDoc = await getDoc23(practitionerRef);
     if (!practitionerDoc.exists()) {
       throw new Error(`Doctor with ID ${doctorId} not found`);
     }
@@ -9227,19 +9470,19 @@ var CalendarServiceV2 = class extends BaseService {
     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(
+    const appointmentsRef = collection18(this.db, CALENDAR_COLLECTION);
+    const q = query17(
       appointmentsRef,
-      where16("practitionerProfileId", "==", doctorId),
-      where16("eventTime.start", ">=", Timestamp23.fromDate(startOfDay)),
-      where16("eventTime.start", "<=", Timestamp23.fromDate(endOfDay)),
-      where16("status", "in", [
+      where17("practitionerProfileId", "==", doctorId),
+      where17("eventTime.start", ">=", Timestamp24.fromDate(startOfDay)),
+      where17("eventTime.start", "<=", Timestamp24.fromDate(endOfDay)),
+      where17("status", "in", [
         "confirmed" /* CONFIRMED */,
         "pending" /* PENDING */
       ])
     );
-    const querySnapshot = await getDocs16(q);
-    return querySnapshot.docs.map((doc20) => doc20.data());
+    const querySnapshot = await getDocs17(q);
+    return querySnapshot.docs.map((doc21) => doc21.data());
   }
   /**
    * Calculates available time slots based on working hours, schedule and existing appointments
@@ -9296,11 +9539,11 @@ var CalendarServiceV2 = class extends BaseService {
     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(
+        getDoc23(doc20(this.db, CLINICS_COLLECTION, clinicId)),
+        getDoc23(doc20(this.db, PRACTITIONERS_COLLECTION, doctorId)),
+        getDoc23(doc20(this.db, PATIENTS_COLLECTION, patientId)),
+        getDoc23(
+          doc20(
             this.db,
             PATIENTS_COLLECTION,
             patientId,
@@ -9333,7 +9576,7 @@ var CalendarServiceV2 = class extends BaseService {
           fullName: `${sensitiveData.firstName} ${sensitiveData.lastName}`,
           email: sensitiveData.email || "",
           phone: sensitiveData.phoneNumber || null,
-          dateOfBirth: sensitiveData.dateOfBirth || Timestamp23.now(),
+          dateOfBirth: sensitiveData.dateOfBirth || Timestamp24.now(),
           gender: sensitiveData.gender || "other" /* OTHER */
         };
       } else if (patientDoc.exists()) {
@@ -9342,7 +9585,7 @@ var CalendarServiceV2 = class extends BaseService {
           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(),
+          dateOfBirth: patientDoc.data().dateOfBirth || Timestamp24.now(),
           gender: patientDoc.data().gender || "other" /* OTHER */
         };
       }
@@ -9364,54 +9607,54 @@ var CalendarServiceV2 = class extends BaseService {
 };
 
 // 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(),
+import { z as z19 } from "zod";
+var baseNotificationSchema = z19.object({
+  id: z19.string().optional(),
+  userId: z19.string(),
+  notificationTime: z19.any(),
   // Timestamp
-  notificationType: z18.nativeEnum(NotificationType),
-  notificationTokens: z18.array(z18.string()),
-  status: z18.nativeEnum(NotificationStatus),
-  createdAt: z18.any().optional(),
+  notificationType: z19.nativeEnum(NotificationType),
+  notificationTokens: z19.array(z19.string()),
+  status: z19.nativeEnum(NotificationStatus),
+  createdAt: z19.any().optional(),
   // Timestamp
-  updatedAt: z18.any().optional(),
+  updatedAt: z19.any().optional(),
   // Timestamp
-  title: z18.string(),
-  body: z18.string(),
-  isRead: z18.boolean(),
-  userRole: z18.nativeEnum(UserRole)
+  title: z19.string(),
+  body: z19.string(),
+  isRead: z19.boolean(),
+  userRole: z19.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z18.literal("preRequirement" /* PRE_REQUIREMENT */),
-  treatmentId: z18.string(),
-  requirements: z18.array(z18.string()),
-  deadline: z18.any()
+  notificationType: z19.literal("preRequirement" /* PRE_REQUIREMENT */),
+  treatmentId: z19.string(),
+  requirements: z19.array(z19.string()),
+  deadline: z19.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z18.literal("postRequirement" /* POST_REQUIREMENT */),
-  treatmentId: z18.string(),
-  requirements: z18.array(z18.string()),
-  deadline: z18.any()
+  notificationType: z19.literal("postRequirement" /* POST_REQUIREMENT */),
+  treatmentId: z19.string(),
+  requirements: z19.array(z19.string()),
+  deadline: z19.any()
   // Timestamp
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z18.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: z18.string(),
-  appointmentTime: z18.any(),
+  notificationType: z19.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: z19.string(),
+  appointmentTime: z19.any(),
   // Timestamp
-  treatmentType: z18.string(),
-  doctorName: z18.string()
+  treatmentType: z19.string(),
+  doctorName: z19.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z18.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
-  appointmentId: z18.string(),
-  appointmentStatus: z18.string(),
-  previousStatus: z18.string(),
-  reason: z18.string().optional()
+  notificationType: z19.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  appointmentId: z19.string(),
+  appointmentStatus: z19.string(),
+  previousStatus: z19.string(),
+  reason: z19.string().optional()
 });
-var notificationSchema = z18.discriminatedUnion("notificationType", [
+var notificationSchema = z19.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   appointmentReminderNotificationSchema,
@@ -9473,6 +9716,7 @@ export {
   PractitionerTokenStatus,
   PricingMeasure,
   ProcedureFamily,
+  ProcedureService,
   REGISTER_TOKENS_COLLECTION,
   SYNCED_CALENDARS_COLLECTION,
   SubscriptionModel,