@blackcode_sa/metaestetics-api 1.7.41 → 1.7.42

package/dist/index.mjs

@@ -599,7 +599,8 @@ import {
 import {
   collection as collection14,
   query as query14,
-  getDocs as getDocs14
+  getDocs as getDocs14,
+  runTransaction
 } from "firebase/firestore";
 
 // src/types/calendar/index.ts
@@ -645,7 +646,7 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 
 // src/validations/schemas.ts
 import { z as z4 } from "zod";
@@ -4522,10 +4523,10 @@ var practitionerBasicInfoSchema = z14.object({
   lastName: z14.string().min(2).max(50),
   title: z14.string().min(2).max(100),
   email: z14.string().email(),
-  phoneNumber: z14.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: z14.instanceof(Timestamp9).or(z14.date()),
+  phoneNumber: z14.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number").nullable(),
+  dateOfBirth: z14.instanceof(Timestamp9).or(z14.date()).nullable(),
   gender: z14.enum(["male", "female", "other"]),
-  profileImageUrl: mediaResourceSchema.optional(),
+  profileImageUrl: mediaResourceSchema.optional().nullable(),
   bio: z14.string().max(1e3).optional(),
   languages: z14.array(z14.string()).min(1)
 });
@@ -4535,7 +4536,7 @@ var practitionerCertificationSchema = z14.object({
   licenseNumber: z14.string().min(3).max(50),
   issuingAuthority: z14.string().min(2).max(100),
   issueDate: z14.instanceof(Timestamp9).or(z14.date()),
-  expiryDate: z14.instanceof(Timestamp9).or(z14.date()).optional(),
+  expiryDate: z14.instanceof(Timestamp9).or(z14.date()).optional().nullable(),
   verificationStatus: z14.enum(["pending", "verified", "rejected"])
 });
 var timeSlotSchema = z14.object({
@@ -7693,6 +7694,125 @@ var ClinicService = class extends BaseService {
   }
 };
 
+// src/services/auth/utils/firebase.utils.ts
+import { fetchSignInMethodsForEmail } from "firebase/auth";
+var checkEmailExists = async (auth, email) => {
+  try {
+    const methods = await fetchSignInMethodsForEmail(auth, email);
+    return methods.length > 0;
+  } catch (error) {
+    console.warn(
+      "[FIREBASE] Could not check email existence, allowing signup to proceed:",
+      error
+    );
+    return false;
+  }
+};
+var cleanupFirebaseUser = async (firebaseUser) => {
+  try {
+    console.log("[FIREBASE] Cleaning up Firebase user", {
+      uid: firebaseUser.uid
+    });
+    await firebaseUser.delete();
+    console.log("[FIREBASE] Firebase user cleanup successful");
+  } catch (cleanupError) {
+    console.error("[FIREBASE] Failed to cleanup Firebase user:", cleanupError);
+  }
+};
+
+// src/services/auth/utils/error.utils.ts
+import { z as z20 } from "zod";
+var handleFirebaseError = (error) => {
+  const firebaseError = error;
+  switch (firebaseError.code) {
+    case "auth/email-already-in-use" /* EMAIL_ALREADY_IN_USE */:
+      return AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+    case "auth/weak-password":
+      return new Error(
+        "Password is too weak. Please choose a stronger password."
+      );
+    case "auth/invalid-email":
+      return new Error("Please enter a valid email address.");
+    case "auth/network-request-failed":
+      return new Error(
+        "Network error. Please check your internet connection and try again."
+      );
+    default:
+      return new Error(
+        `Account creation failed: ${firebaseError.message || "Unknown error"}`
+      );
+  }
+};
+var handleSignupError = (error) => {
+  if (error instanceof z20.ZodError) {
+    const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    return new Error(`Validation failed: ${errorMessages}`);
+  }
+  if (error.code && error.code.startsWith("auth/")) {
+    return handleFirebaseError(error);
+  }
+  if (error.message && error.message.includes("token")) {
+    return new Error("Invalid or expired invitation token");
+  }
+  if (error.message && error.message.includes("validation")) {
+    return new Error(`Invalid practitioner data: ${error.message}`);
+  }
+  return new Error(
+    `Registration failed: ${error.message || "Unknown error occurred"}`
+  );
+};
+
+// src/services/auth/utils/practitioner.utils.ts
+import { z as z21 } from "zod";
+var profileDataSchema = z21.object({
+  basicInfo: practitionerBasicInfoSchema.partial().optional(),
+  certification: practitionerCertificationSchema.partial().optional()
+}).partial();
+var buildPractitionerData = (data, userRef) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const basicInfo = {
+    firstName: data.firstName || "Name",
+    lastName: data.lastName || "Surname",
+    email: data.email,
+    phoneNumber: ((_b = (_a = data.profileData) == null ? void 0 : _a.basicInfo) == null ? void 0 : _b.phoneNumber) || null,
+    profileImageUrl: ((_d = (_c = data.profileData) == null ? void 0 : _c.basicInfo) == null ? void 0 : _d.profileImageUrl) || "",
+    gender: ((_f = (_e = data.profileData) == null ? void 0 : _e.basicInfo) == null ? void 0 : _f.gender) || "other",
+    bio: ((_h = (_g = data.profileData) == null ? void 0 : _g.basicInfo) == null ? void 0 : _h.bio) || "",
+    title: "Practitioner",
+    dateOfBirth: ((_j = (_i = data.profileData) == null ? void 0 : _i.basicInfo) == null ? void 0 : _j.dateOfBirth) || /* @__PURE__ */ new Date(),
+    languages: ((_l = (_k = data.profileData) == null ? void 0 : _k.basicInfo) == null ? void 0 : _l.languages) || ["English"]
+  };
+  const certification = ((_m = data.profileData) == null ? void 0 : _m.certification) || {
+    level: "aesthetician" /* AESTHETICIAN */,
+    specialties: [],
+    licenseNumber: "Pending",
+    issuingAuthority: "Pending",
+    issueDate: /* @__PURE__ */ new Date(),
+    verificationStatus: "pending"
+  };
+  return {
+    userRef,
+    basicInfo,
+    certification,
+    status: "active" /* ACTIVE */,
+    isActive: true,
+    isVerified: false
+  };
+};
+var validatePractitionerProfileData = async (profileData) => {
+  try {
+    await profileDataSchema.parseAsync(profileData);
+  } catch (error) {
+    if (error instanceof z21.ZodError) {
+      const errorMessages = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(
+        `Practitioner profile validation failed: ${errorMessages}`
+      );
+    }
+    throw error;
+  }
+};
+
 // src/services/auth.service.ts
 var AuthService = class extends BaseService {
   constructor(db, auth, app, userService) {
@@ -7700,10 +7820,7 @@ var AuthService = class extends BaseService {
     this.googleProvider = new GoogleAuthProvider();
     this.facebookProvider = new FacebookAuthProvider();
     this.appleProvider = new OAuthProvider("apple.com");
-    if (!userService) {
-      userService = new UserService(db, auth, app);
-    }
-    this.userService = userService;
+    this.userService = userService || new UserService(db, auth, app);
   }
   /**
    * Registruje novog korisnika sa email-om i lozinkom
@@ -7752,7 +7869,7 @@ var AuthService = class extends BaseService {
         });
       } catch (firebaseError) {
         console.error("[AUTH] Firebase user creation failed:", firebaseError);
-        throw firebaseError;
+        throw handleFirebaseError(firebaseError);
       }
       console.log("[AUTH] Creating user with CLINIC_ADMIN role");
       let user;
@@ -8006,7 +8123,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof z20.ZodError) {
+      if (error instanceof z22.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -8181,7 +8298,7 @@ var AuthService = class extends BaseService {
         email
       );
     } catch (error) {
-      if (error instanceof z20.ZodError) {
+      if (error instanceof z22.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -8304,7 +8421,7 @@ var AuthService = class extends BaseService {
       await emailSchema.parseAsync(email);
       await sendPasswordResetEmail(this.auth, email);
     } catch (error) {
-      if (error instanceof z20.ZodError) {
+      if (error instanceof z22.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -8343,7 +8460,7 @@ var AuthService = class extends BaseService {
       await passwordSchema.parseAsync(newPassword);
       await confirmPasswordReset(this.auth, oobCode, newPassword);
     } catch (error) {
-      if (error instanceof z20.ZodError) {
+      if (error instanceof z22.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -8358,31 +8475,21 @@ var AuthService = class extends BaseService {
     }
   }
   /**
-   * Registers a new practitioner user with email and password
-   * Can either create a new practitioner profile or claim an existing draft profile with a token
+   * Registers a new practitioner user with email and password (ATOMIC VERSION)
+   * Uses Firestore transactions to ensure atomicity and proper rollback on failures
    *
    * @param data - Practitioner signup data containing either new profile details or token for claiming draft profile
    * @returns Object containing the created user and practitioner profile
    */
   async signUpPractitioner(data) {
-    var _a, _b, _c, _d;
+    let firebaseUser = null;
     try {
-      console.log("[AUTH] Starting practitioner signup process", {
+      console.log("[AUTH] Starting atomic practitioner signup process", {
         email: data.email,
         hasToken: !!data.token
       });
-      try {
-        await practitionerSignupSchema.parseAsync(data);
-        console.log("[AUTH] Practitioner signup data validation passed");
-      } catch (validationError) {
-        console.error(
-          "[AUTH] Validation error in signUpPractitioner:",
-          validationError
-        );
-        throw validationError;
-      }
+      await this.validateSignupData(data);
       console.log("[AUTH] Creating Firebase user");
-      let firebaseUser;
       try {
         const result = await createUserWithEmailAndPassword(
           this.auth,
@@ -8395,136 +8502,110 @@ var AuthService = class extends BaseService {
         });
       } catch (firebaseError) {
         console.error("[AUTH] Firebase user creation failed:", firebaseError);
-        throw firebaseError;
+        throw handleFirebaseError(firebaseError);
       }
-      console.log("[AUTH] Creating user with PRACTITIONER role");
-      let user;
-      try {
-        user = await this.userService.createUser(
-          firebaseUser,
-          ["practitioner" /* PRACTITIONER */],
-          {
-            skipProfileCreation: true
-            // We'll create the profile separately
-          }
-        );
-        console.log("[AUTH] User with PRACTITIONER role created successfully", {
-          userId: user.uid
-        });
-      } catch (userCreationError) {
-        console.error("[AUTH] User creation failed:", userCreationError);
-        throw userCreationError;
-      }
-      console.log("[AUTH] Initializing practitioner service");
-      const practitionerService = new PractitionerService(
+      console.log("[AUTH] Starting Firestore transaction");
+      const transactionResult = await runTransaction(
         this.db,
-        this.auth,
-        this.app
-      );
-      let practitioner = null;
-      if (data.token) {
-        console.log("[AUTH] Token provided, attempting to claim draft profile");
-        try {
-          practitioner = await practitionerService.validateTokenAndClaimProfile(
-            data.token,
-            firebaseUser.uid
-          );
-          if (!practitioner) {
-            throw new Error("Invalid or expired invitation token");
-          }
-          console.log("[AUTH] Successfully claimed draft profile", {
-            practitionerId: practitioner.id
-          });
-          await this.userService.updateUser(firebaseUser.uid, {
-            practitionerProfile: practitioner.id
-          });
+        async (transaction) => {
           console.log(
-            "[AUTH] User updated with practitioner profile reference"
+            "[AUTH] Transaction started - creating user and practitioner"
           );
-        } catch (tokenError) {
-          console.error("[AUTH] Failed to claim draft profile:", tokenError);
-          throw tokenError;
-        }
-      } else {
-        console.log("[AUTH] Creating new practitioner profile");
-        if (!data.profileData) {
-          data.profileData = {};
-        }
-        const basicInfo = {
-          firstName: data.firstName || "",
-          lastName: data.lastName || "",
-          email: data.email,
-          phoneNumber: ((_a = data.profileData.basicInfo) == null ? void 0 : _a.phoneNumber) || "",
-          profileImageUrl: ((_b = data.profileData.basicInfo) == null ? void 0 : _b.profileImageUrl) || "",
-          gender: ((_c = data.profileData.basicInfo) == null ? void 0 : _c.gender) || "other",
-          // Default to "other" if not provided
-          bio: ((_d = data.profileData.basicInfo) == null ? void 0 : _d.bio) || "",
-          title: "Practitioner",
-          // Default title
-          dateOfBirth: /* @__PURE__ */ new Date(),
-          // Default to today
-          languages: ["English"]
-          // Default language
-        };
-        const certification = data.profileData.certification || {
-          level: "aesthetician" /* AESTHETICIAN */,
-          specialties: [],
-          licenseNumber: "Pending",
-          issuingAuthority: "Pending",
-          issueDate: /* @__PURE__ */ new Date(),
-          verificationStatus: "pending"
-        };
-        const createPractitionerData = {
-          userRef: firebaseUser.uid,
-          basicInfo,
-          certification,
-          status: "active" /* ACTIVE */,
-          isActive: true,
-          isVerified: false
-        };
-        try {
-          practitioner = await practitionerService.createPractitioner(
-            createPractitionerData
+          const practitionerService = new PractitionerService(
+            this.db,
+            this.auth,
+            this.app
           );
-          console.log("[AUTH] Practitioner profile created successfully", {
-            practitionerId: practitioner.id
-          });
+          console.log("[AUTH] Creating user document");
+          const user = await this.userService.createUser(
+            firebaseUser,
+            ["practitioner" /* PRACTITIONER */],
+            { skipProfileCreation: true }
+          );
+          let practitioner;
+          if (data.token) {
+            console.log(
+              "[AUTH] Claiming existing practitioner profile with token"
+            );
+            const claimedPractitioner = await practitionerService.validateTokenAndClaimProfile(
+              data.token,
+              firebaseUser.uid
+            );
+            if (!claimedPractitioner) {
+              throw new Error("Invalid or expired invitation token");
+            }
+            practitioner = claimedPractitioner;
+          } else {
+            console.log("[AUTH] Creating new practitioner profile");
+            const practitionerData = buildPractitionerData(
+              data,
+              firebaseUser.uid
+            );
+            practitioner = await practitionerService.createPractitioner(
+              practitionerData
+            );
+          }
+          console.log("[AUTH] Linking practitioner to user");
           await this.userService.updateUser(firebaseUser.uid, {
             practitionerProfile: practitioner.id
           });
-          console.log(
-            "[AUTH] User updated with practitioner profile reference"
-          );
-        } catch (createError) {
-          console.error(
-            "[AUTH] Failed to create practitioner profile:",
-            createError
-          );
-          throw createError;
+          console.log("[AUTH] Transaction operations completed successfully");
+          return { user, practitioner };
         }
-      }
-      console.log("[AUTH] Practitioner signup completed successfully", {
-        userId: user.uid,
-        practitionerId: (practitioner == null ? void 0 : practitioner.id) || "unknown"
+      );
+      console.log("[AUTH] Atomic practitioner signup completed successfully", {
+        userId: transactionResult.user.uid,
+        practitionerId: transactionResult.practitioner.id
       });
-      return {
-        user,
-        practitioner
-      };
+      return transactionResult;
     } catch (error) {
-      if (error instanceof z20.ZodError) {
-        console.error(
-          "[AUTH] Zod validation error in signUpPractitioner:",
-          JSON.stringify(error.errors, null, 2)
-        );
-        throw AUTH_ERRORS.VALIDATION_ERROR;
+      console.error(
+        "[AUTH] Atomic signup failed, initiating cleanup...",
+        error
+      );
+      if (firebaseUser) {
+        await cleanupFirebaseUser(firebaseUser);
       }
-      const firebaseError = error;
-      if (firebaseError.code === "auth/email-already-in-use" /* EMAIL_ALREADY_IN_USE */) {
-        console.error("[AUTH] Email already in use:", data.email);
+      throw handleSignupError(error);
+    }
+  }
+  /**
+   * Pre-validate all signup data before any mutations
+   * Prevents partial creation by catching issues early
+   */
+  async validateSignupData(data) {
+    console.log("[AUTH] Pre-validating signup data");
+    try {
+      await practitionerSignupSchema.parseAsync(data);
+      console.log("[AUTH] Schema validation passed");
+      const emailExists = await checkEmailExists(this.auth, data.email);
+      if (emailExists) {
+        console.log("[AUTH] Email already exists:", data.email);
         throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
       }
-      console.error("[AUTH] Unhandled error in signUpPractitioner:", error);
+      console.log("[AUTH] Email availability confirmed");
+      if (data.token) {
+        const practitionerService = new PractitionerService(
+          this.db,
+          this.auth,
+          this.app
+        );
+        const isValidToken = await practitionerService.validateToken(
+          data.token
+        );
+        if (!isValidToken) {
+          console.log("[AUTH] Invalid token provided:", data.token);
+          throw new Error("Invalid or expired invitation token");
+        }
+        console.log("[AUTH] Token validation passed");
+      }
+      if (data.profileData) {
+        await validatePractitionerProfileData(data.profileData);
+        console.log("[AUTH] Profile data validation passed");
+      }
+      console.log("[AUTH] All pre-validation checks passed");
+    } catch (error) {
+      console.error("[AUTH] Pre-validation failed:", error);
       throw error;
     }
   }
@@ -8596,8 +8677,8 @@ import {
   query as query15,
   where as where15,
   updateDoc as updateDoc15,
-  deleteDoc as deleteDoc8,
-  orderBy as orderBy4,
+  deleteDoc as deleteDoc9,
+  orderBy as orderBy5,
   Timestamp as Timestamp16,
   addDoc as addDoc2,
   writeBatch as writeBatch5
@@ -8681,7 +8762,7 @@ var NotificationService = class extends BaseService {
     const q = query15(
       collection15(this.db, NOTIFICATIONS_COLLECTION),
       where15("userId", "==", userId),
-      orderBy4("notificationTime", "desc")
+      orderBy5("notificationTime", "desc")
     );
     const querySnapshot = await getDocs15(q);
     return querySnapshot.docs.map((doc36) => ({
@@ -8697,7 +8778,7 @@ var NotificationService = class extends BaseService {
       collection15(this.db, NOTIFICATIONS_COLLECTION),
       where15("userId", "==", userId),
       where15("isRead", "==", false),
-      orderBy4("notificationTime", "desc")
+      orderBy5("notificationTime", "desc")
     );
     const querySnapshot = await getDocs15(q);
     return querySnapshot.docs.map((doc36) => ({
@@ -8761,7 +8842,7 @@ var NotificationService = class extends BaseService {
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await deleteDoc8(notificationRef);
+    await deleteDoc9(notificationRef);
   }
   /**
    * Dohvata notifikacije po tipu
@@ -8771,7 +8852,7 @@ var NotificationService = class extends BaseService {
       collection15(this.db, NOTIFICATIONS_COLLECTION),
       where15("userId", "==", userId),
       where15("notificationType", "==", type),
-      orderBy4("notificationTime", "desc")
+      orderBy5("notificationTime", "desc")
     );
     const querySnapshot = await getDocs15(q);
     return querySnapshot.docs.map((doc36) => ({
@@ -8786,7 +8867,7 @@ var NotificationService = class extends BaseService {
     const q = query15(
       collection15(this.db, NOTIFICATIONS_COLLECTION),
       where15("appointmentId", "==", appointmentId),
-      orderBy4("notificationTime", "desc")
+      orderBy5("notificationTime", "desc")
     );
     const querySnapshot = await getDocs15(q);
     return querySnapshot.docs.map((doc36) => ({
@@ -8806,74 +8887,74 @@ import {
   where as where16,
   updateDoc as updateDoc16,
   setDoc as setDoc14,
-  deleteDoc as deleteDoc9,
-  serverTimestamp as serverTimestamp14,
-  orderBy as orderBy5,
-  limit as limit8,
-  startAfter as startAfter7
+  deleteDoc as deleteDoc10,
+  serverTimestamp as serverTimestamp13,
+  orderBy as orderBy6,
+  limit as limit9,
+  startAfter as startAfter8
 } from "firebase/firestore";
 
 // src/types/procedure/index.ts
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-import { z as z21 } from "zod";
-var createProcedureSchema = z21.object({
-  name: z21.string().min(1).max(200),
-  description: z21.string().min(1).max(2e3),
-  family: z21.nativeEnum(ProcedureFamily),
-  categoryId: z21.string().min(1),
-  subcategoryId: z21.string().min(1),
-  technologyId: z21.string().min(1),
-  productId: z21.string().min(1),
-  price: z21.number().min(0),
-  currency: z21.nativeEnum(Currency),
-  pricingMeasure: z21.nativeEnum(PricingMeasure),
-  duration: z21.number().min(1).max(480),
+import { z as z23 } from "zod";
+var createProcedureSchema = z23.object({
+  name: z23.string().min(1).max(200),
+  description: z23.string().min(1).max(2e3),
+  family: z23.nativeEnum(ProcedureFamily),
+  categoryId: z23.string().min(1),
+  subcategoryId: z23.string().min(1),
+  technologyId: z23.string().min(1),
+  productId: z23.string().min(1),
+  price: z23.number().min(0),
+  currency: z23.nativeEnum(Currency),
+  pricingMeasure: z23.nativeEnum(PricingMeasure),
+  duration: z23.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: z21.string().min(1),
-  clinicBranchId: z21.string().min(1),
-  photos: z21.array(mediaResourceSchema).optional()
+  practitionerId: z23.string().min(1),
+  clinicBranchId: z23.string().min(1),
+  photos: z23.array(mediaResourceSchema).optional()
 });
-var updateProcedureSchema = z21.object({
-  name: z21.string().min(3).max(100).optional(),
-  description: z21.string().min(3).max(1e3).optional(),
-  price: z21.number().min(0).optional(),
-  currency: z21.nativeEnum(Currency).optional(),
-  pricingMeasure: z21.nativeEnum(PricingMeasure).optional(),
-  duration: z21.number().min(0).optional(),
-  isActive: z21.boolean().optional(),
-  practitionerId: z21.string().optional(),
-  categoryId: z21.string().optional(),
-  subcategoryId: z21.string().optional(),
-  technologyId: z21.string().optional(),
-  productId: z21.string().optional(),
-  clinicBranchId: z21.string().optional(),
-  photos: z21.array(mediaResourceSchema).optional()
+var updateProcedureSchema = z23.object({
+  name: z23.string().min(3).max(100).optional(),
+  description: z23.string().min(3).max(1e3).optional(),
+  price: z23.number().min(0).optional(),
+  currency: z23.nativeEnum(Currency).optional(),
+  pricingMeasure: z23.nativeEnum(PricingMeasure).optional(),
+  duration: z23.number().min(0).optional(),
+  isActive: z23.boolean().optional(),
+  practitionerId: z23.string().optional(),
+  categoryId: z23.string().optional(),
+  subcategoryId: z23.string().optional(),
+  technologyId: z23.string().optional(),
+  productId: z23.string().optional(),
+  clinicBranchId: z23.string().optional(),
+  photos: z23.array(mediaResourceSchema).optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: z21.string().min(1),
-  category: z21.any(),
+  id: z23.string().min(1),
+  category: z23.any(),
   // We'll validate the full category object separately
-  subcategory: z21.any(),
+  subcategory: z23.any(),
   // We'll validate the full subcategory object separately
-  technology: z21.any(),
+  technology: z23.any(),
   // We'll validate the full technology object separately
-  product: z21.any(),
+  product: z23.any(),
   // We'll validate the full product object separately
-  blockingConditions: z21.array(z21.any()),
+  blockingConditions: z23.array(z23.any()),
   // We'll validate blocking conditions separately
-  contraindications: z21.array(z21.any()),
+  contraindications: z23.array(z23.any()),
   // We'll validate contraindications separately
-  treatmentBenefits: z21.array(z21.any()),
+  treatmentBenefits: z23.array(z23.any()),
   // We'll validate treatment benefits separately
-  preRequirements: z21.array(z21.any()),
+  preRequirements: z23.array(z23.any()),
   // We'll validate requirements separately
-  postRequirements: z21.array(z21.any()),
+  postRequirements: z23.array(z23.any()),
   // We'll validate requirements separately
-  certificationRequirement: z21.any(),
+  certificationRequirement: z23.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: z21.array(z21.any()),
+  documentationTemplates: z23.array(z23.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -8881,9 +8962,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: z21.boolean(),
-  createdAt: z21.date(),
-  updatedAt: z21.date()
+  isActive: z23.boolean(),
+  createdAt: z23.date(),
+  updatedAt: z23.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -9055,8 +9136,8 @@ var ProcedureService = class extends BaseService {
     const procedureRef = doc16(this.db, PROCEDURES_COLLECTION, procedureId);
     await setDoc14(procedureRef, {
       ...newProcedure,
-      createdAt: serverTimestamp14(),
-      updatedAt: serverTimestamp14()
+      createdAt: serverTimestamp13(),
+      updatedAt: serverTimestamp13()
     });
     const savedDoc = await getDoc19(procedureRef);
     return savedDoc.data();
@@ -9244,7 +9325,7 @@ var ProcedureService = class extends BaseService {
     }
     await updateDoc16(procedureRef, {
       ...updatedProcedureData,
-      updatedAt: serverTimestamp14()
+      updatedAt: serverTimestamp13()
     });
     const updatedSnapshot = await getDoc19(procedureRef);
     return updatedSnapshot.data();
@@ -9262,7 +9343,7 @@ var ProcedureService = class extends BaseService {
     }
     await updateDoc16(procedureRef, {
       isActive: false,
-      updatedAt: serverTimestamp14()
+      updatedAt: serverTimestamp13()
     });
   }
   /**
@@ -9276,7 +9357,7 @@ var ProcedureService = class extends BaseService {
     if (!procedureSnapshot.exists()) {
       return false;
     }
-    await deleteDoc9(procedureRef);
+    await deleteDoc10(procedureRef);
     return true;
   }
   /**
@@ -9305,24 +9386,24 @@ var ProcedureService = class extends BaseService {
       const proceduresCollection = collection16(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = query16(proceduresCollection);
       if (pagination && pagination > 0) {
-        const { limit: limit15, startAfter: startAfter13 } = await import("firebase/firestore");
+        const { limit: limit16, startAfter: startAfter14 } = await import("firebase/firestore");
         if (lastDoc) {
           proceduresQuery = query16(
             proceduresCollection,
-            orderBy5("name"),
+            orderBy6("name"),
             // Use imported orderBy
-            startAfter13(lastDoc),
-            limit15(pagination)
+            startAfter14(lastDoc),
+            limit16(pagination)
           );
         } else {
           proceduresQuery = query16(
             proceduresCollection,
-            orderBy5("name"),
-            limit15(pagination)
+            orderBy6("name"),
+            limit16(pagination)
           );
         }
       } else {
-        proceduresQuery = query16(proceduresCollection, orderBy5("name"));
+        proceduresQuery = query16(proceduresCollection, orderBy6("name"));
       }
       const proceduresSnapshot = await getDocs16(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
@@ -9380,12 +9461,12 @@ var ProcedureService = class extends BaseService {
       if (filters.procedureFamily) {
         constraints.push(where16("family", "==", filters.procedureFamily));
       }
-      constraints.push(orderBy5("clinicInfo.location.geohash"));
+      constraints.push(orderBy6("clinicInfo.location.geohash"));
       if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
-        constraints.push(startAfter7(filters.lastDoc));
-        constraints.push(limit8(filters.pagination));
+        constraints.push(startAfter8(filters.lastDoc));
+        constraints.push(limit9(filters.pagination));
       } else if (filters.pagination && filters.pagination > 0) {
-        constraints.push(limit8(filters.pagination));
+        constraints.push(limit9(filters.pagination));
       }
       let proceduresResult = [];
       let lastVisibleDoc = null;
@@ -9671,8 +9752,8 @@ var ProcedureService = class extends BaseService {
     const procedureRef = doc16(this.db, PROCEDURES_COLLECTION, procedureId);
     await setDoc14(procedureRef, {
       ...newProcedure,
-      createdAt: serverTimestamp14(),
-      updatedAt: serverTimestamp14()
+      createdAt: serverTimestamp13(),
+      updatedAt: serverTimestamp13()
     });
     const savedDoc = await getDoc19(procedureRef);
     return savedDoc.data();
@@ -9689,11 +9770,11 @@ import {
   where as where17,
   updateDoc as updateDoc17,
   setDoc as setDoc15,
-  deleteDoc as deleteDoc10,
+  deleteDoc as deleteDoc11,
   Timestamp as Timestamp18,
-  serverTimestamp as serverTimestamp15,
-  orderBy as orderBy6,
-  limit as limit9
+  serverTimestamp as serverTimestamp14,
+  orderBy as orderBy7,
+  limit as limit10
 } from "firebase/firestore";
 var PractitionerInviteService = class extends BaseService {
   constructor(db, auth, app) {
@@ -9788,7 +9869,7 @@ var PractitionerInviteService = class extends BaseService {
     try {
       const constraints = [
         where17("practitionerId", "==", practitionerId),
-        orderBy6("createdAt", "desc")
+        orderBy7("createdAt", "desc")
       ];
       if (statusFilter && statusFilter.length > 0) {
         constraints.push(where17("status", "in", statusFilter));
@@ -9817,7 +9898,7 @@ var PractitionerInviteService = class extends BaseService {
     try {
       const constraints = [
         where17("clinicId", "==", clinicId),
-        orderBy6("createdAt", "desc")
+        orderBy7("createdAt", "desc")
       ];
       if (statusFilter && statusFilter.length > 0) {
         constraints.push(where17("status", "in", statusFilter));
@@ -9853,7 +9934,7 @@ var PractitionerInviteService = class extends BaseService {
       const updateData = {
         status: "accepted" /* ACCEPTED */,
         acceptedAt: Timestamp18.now(),
-        updatedAt: serverTimestamp15()
+        updatedAt: serverTimestamp14()
       };
       const docRef = doc17(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
       await updateDoc17(docRef, updateData);
@@ -9885,7 +9966,7 @@ var PractitionerInviteService = class extends BaseService {
         status: "rejected" /* REJECTED */,
         rejectionReason: rejectionReason || null,
         rejectedAt: Timestamp18.now(),
-        updatedAt: serverTimestamp15()
+        updatedAt: serverTimestamp14()
       };
       const docRef = doc17(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
       await updateDoc17(docRef, updateData);
@@ -9917,7 +9998,7 @@ var PractitionerInviteService = class extends BaseService {
         status: "cancelled" /* CANCELLED */,
         cancelReason: cancelReason || null,
         cancelledAt: Timestamp18.now(),
-        updatedAt: serverTimestamp15()
+        updatedAt: serverTimestamp14()
       };
       const docRef = doc17(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
       await updateDoc17(docRef, updateData);
@@ -9973,9 +10054,9 @@ var PractitionerInviteService = class extends BaseService {
       }
       const orderField = filters.orderBy || "createdAt";
       const orderDirection = filters.orderDirection || "desc";
-      constraints.push(orderBy6(orderField, orderDirection));
+      constraints.push(orderBy7(orderField, orderDirection));
       if (filters.limit) {
-        constraints.push(limit9(filters.limit));
+        constraints.push(limit10(filters.limit));
       }
       const q = query17(
         collection17(this.db, PRACTITIONER_INVITES_COLLECTION),
@@ -10011,7 +10092,7 @@ var PractitionerInviteService = class extends BaseService {
   async deleteInvite(inviteId) {
     try {
       const docRef = doc17(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
-      await deleteDoc10(docRef);
+      await deleteDoc11(docRef);
     } catch (error) {
       console.error(
         "[PractitionerInviteService] Error deleting invite:",
@@ -10066,8 +10147,8 @@ var PractitionerInviteService = class extends BaseService {
         collection17(this.db, PRACTITIONER_INVITES_COLLECTION),
         where17("practitionerId", "==", practitionerId),
         where17("clinicId", "==", clinicId),
-        orderBy6("createdAt", "desc"),
-        limit9(1)
+        orderBy7("createdAt", "desc"),
+        limit10(1)
       );
       const querySnapshot = await getDocs17(q);
       if (querySnapshot.empty) {
@@ -10092,12 +10173,12 @@ import {
   getDocs as getDocs18,
   setDoc as setDoc16,
   updateDoc as updateDoc18,
-  deleteDoc as deleteDoc11,
+  deleteDoc as deleteDoc12,
   query as query18,
   where as where18,
-  orderBy as orderBy7,
-  limit as limit10,
-  startAfter as startAfter8
+  orderBy as orderBy8,
+  limit as limit11,
+  startAfter as startAfter9
 } from "firebase/firestore";
 var DocumentationTemplateService = class extends BaseService {
   constructor() {
@@ -10250,7 +10331,7 @@ var DocumentationTemplateService = class extends BaseService {
       this.db,
       `${DOCUMENTATION_TEMPLATES_COLLECTION}/${templateId}/versions`
     );
-    const q = query18(versionsCollectionRef, orderBy7("version", "desc"));
+    const q = query18(versionsCollectionRef, orderBy8("version", "desc"));
     const querySnapshot = await getDocs18(q);
     const versions = [];
     querySnapshot.forEach((doc36) => {
@@ -10264,7 +10345,7 @@ var DocumentationTemplateService = class extends BaseService {
    */
   async deleteTemplate(templateId) {
     const docRef = doc18(this.collectionRef, templateId);
-    await deleteDoc11(docRef);
+    await deleteDoc12(docRef);
   }
   /**
    * Get all active templates
@@ -10276,11 +10357,11 @@ var DocumentationTemplateService = class extends BaseService {
     let q = query18(
       this.collectionRef,
       where18("isActive", "==", true),
-      orderBy7("updatedAt", "desc"),
-      limit10(pageSize)
+      orderBy8("updatedAt", "desc"),
+      limit11(pageSize)
     );
     if (lastDoc) {
-      q = query18(q, startAfter8(lastDoc));
+      q = query18(q, startAfter9(lastDoc));
     }
     const querySnapshot = await getDocs18(q);
     const templates = [];
@@ -10306,11 +10387,11 @@ var DocumentationTemplateService = class extends BaseService {
       this.collectionRef,
       where18("isActive", "==", true),
       where18("tags", "array-contains-any", tags),
-      orderBy7("updatedAt", "desc"),
-      limit10(pageSize)
+      orderBy8("updatedAt", "desc"),
+      limit11(pageSize)
     );
     if (lastDoc) {
-      q = query18(q, startAfter8(lastDoc));
+      q = query18(q, startAfter9(lastDoc));
     }
     const querySnapshot = await getDocs18(q);
     const templates = [];
@@ -10335,11 +10416,11 @@ var DocumentationTemplateService = class extends BaseService {
     let q = query18(
       this.collectionRef,
       where18("createdBy", "==", userId),
-      orderBy7("updatedAt", "desc"),
-      limit10(pageSize)
+      orderBy8("updatedAt", "desc"),
+      limit11(pageSize)
     );
     if (lastDoc) {
-      q = query18(q, startAfter8(lastDoc));
+      q = query18(q, startAfter9(lastDoc));
     }
     const querySnapshot = await getDocs18(q);
     const templates = [];
@@ -10362,7 +10443,7 @@ var DocumentationTemplateService = class extends BaseService {
     let q = query18(
       this.collectionRef,
       where18("isActive", "==", true),
-      orderBy7("updatedAt", "desc")
+      orderBy8("updatedAt", "desc")
     );
     if ((options == null ? void 0 : options.isUserForm) !== void 0) {
       q = query18(q, where18("isUserForm", "==", options.isUserForm));
@@ -10388,9 +10469,9 @@ import {
   setDoc as setDoc17,
   updateDoc as updateDoc19,
   query as query19,
-  orderBy as orderBy8,
-  limit as limit11,
-  startAfter as startAfter9
+  orderBy as orderBy9,
+  limit as limit12,
+  startAfter as startAfter10
 } from "firebase/firestore";
 var FilledDocumentService = class extends BaseService {
   constructor(...args) {
@@ -10542,11 +10623,11 @@ var FilledDocumentService = class extends BaseService {
     );
     let q = query19(
       subcollectionRef,
-      orderBy8("updatedAt", "desc"),
-      limit11(pageSize)
+      orderBy9("updatedAt", "desc"),
+      limit12(pageSize)
     );
     if (lastDoc) {
-      q = query19(q, startAfter9(lastDoc));
+      q = query19(q, startAfter10(lastDoc));
     }
     return this.executeQuery(q);
   }
@@ -10566,11 +10647,11 @@ var FilledDocumentService = class extends BaseService {
     );
     let q = query19(
       subcollectionRef,
-      orderBy8("updatedAt", "desc"),
-      limit11(pageSize)
+      orderBy9("updatedAt", "desc"),
+      limit12(pageSize)
     );
     if (lastDoc) {
-      q = query19(q, startAfter9(lastDoc));
+      q = query19(q, startAfter10(lastDoc));
     }
     return this.executeQuery(q);
   }
@@ -10740,7 +10821,7 @@ var FilledDocumentService = class extends BaseService {
 };
 
 // src/services/calendar/calendar-refactored.service.ts
-import { Timestamp as Timestamp28, serverTimestamp as serverTimestamp22 } from "firebase/firestore";
+import { Timestamp as Timestamp28, serverTimestamp as serverTimestamp21 } from "firebase/firestore";
 
 // src/types/calendar/synced-calendar.types.ts
 var SyncedCalendarProvider = /* @__PURE__ */ ((SyncedCalendarProvider3) => {
@@ -10764,42 +10845,42 @@ import {
 } from "firebase/firestore";
 
 // src/validations/calendar.schema.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 import { Timestamp as Timestamp21 } from "firebase/firestore";
 
 // src/validations/profile-info.schema.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 import { Timestamp as Timestamp20 } from "firebase/firestore";
-var clinicInfoSchema2 = z22.object({
-  id: z22.string(),
-  featuredPhoto: z22.string(),
-  name: z22.string(),
-  description: z22.string(),
+var clinicInfoSchema2 = z24.object({
+  id: z24.string(),
+  featuredPhoto: z24.string(),
+  name: z24.string(),
+  description: z24.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var practitionerProfileInfoSchema = z22.object({
-  id: z22.string(),
-  practitionerPhoto: z22.string().nullable(),
-  name: z22.string(),
-  email: z22.string().email(),
-  phone: z22.string().nullable(),
+var practitionerProfileInfoSchema = z24.object({
+  id: z24.string(),
+  practitionerPhoto: z24.string().nullable(),
+  name: z24.string(),
+  email: z24.string().email(),
+  phone: z24.string().nullable(),
   certification: practitionerCertificationSchema
 });
-var patientProfileInfoSchema = z22.object({
-  id: z22.string(),
-  fullName: z22.string(),
-  email: z22.string().email(),
-  phone: z22.string().nullable(),
-  dateOfBirth: z22.instanceof(Timestamp20),
-  gender: z22.nativeEnum(Gender)
+var patientProfileInfoSchema = z24.object({
+  id: z24.string(),
+  fullName: z24.string(),
+  email: z24.string().email(),
+  phone: z24.string().nullable(),
+  dateOfBirth: z24.instanceof(Timestamp20),
+  gender: z24.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = z23.object({
-  start: z23.instanceof(Date).or(z23.instanceof(Timestamp21)),
-  end: z23.instanceof(Date).or(z23.instanceof(Timestamp21))
+var calendarEventTimeSchema = z25.object({
+  start: z25.instanceof(Date).or(z25.instanceof(Timestamp21)),
+  end: z25.instanceof(Date).or(z25.instanceof(Timestamp21))
 }).refine(
   (data) => {
     const startDate = data.start instanceof Timestamp21 ? data.start.toDate() : data.start;
@@ -10820,46 +10901,46 @@ var calendarEventTimeSchema = z23.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = z23.object({
-  start: z23.date(),
-  end: z23.date(),
-  isAvailable: z23.boolean()
+var timeSlotSchema2 = z25.object({
+  start: z25.date(),
+  end: z25.date(),
+  isAvailable: z25.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-var syncedCalendarEventSchema = z23.object({
-  eventId: z23.string(),
-  syncedCalendarProvider: z23.nativeEnum(SyncedCalendarProvider),
-  syncedAt: z23.instanceof(Date).or(z23.instanceof(Timestamp21))
+var syncedCalendarEventSchema = z25.object({
+  eventId: z25.string(),
+  syncedCalendarProvider: z25.nativeEnum(SyncedCalendarProvider),
+  syncedAt: z25.instanceof(Date).or(z25.instanceof(Timestamp21))
 });
-var procedureInfoSchema = z23.object({
-  name: z23.string(),
-  description: z23.string(),
-  duration: z23.number().min(MIN_APPOINTMENT_DURATION),
-  price: z23.number().min(0),
-  currency: z23.nativeEnum(Currency)
+var procedureInfoSchema = z25.object({
+  name: z25.string(),
+  description: z25.string(),
+  duration: z25.number().min(MIN_APPOINTMENT_DURATION),
+  price: z25.number().min(0),
+  currency: z25.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = z23.object({
-  procedureFamily: z23.string(),
+var procedureCategorizationSchema = z25.object({
+  procedureFamily: z25.string(),
   // Replace with proper enum when available
-  procedureCategory: z23.string(),
+  procedureCategory: z25.string(),
   // Replace with proper enum when available
-  procedureSubcategory: z23.string(),
+  procedureSubcategory: z25.string(),
   // Replace with proper enum when available
-  procedureTechnology: z23.string(),
+  procedureTechnology: z25.string(),
   // Replace with proper enum when available
-  procedureProduct: z23.string()
+  procedureProduct: z25.string()
   // Replace with proper enum when available
 });
-var createAppointmentSchema2 = z23.object({
-  clinicId: z23.string().min(1, "Clinic ID is required"),
-  doctorId: z23.string().min(1, "Doctor ID is required"),
-  patientId: z23.string().min(1, "Patient ID is required"),
-  procedureId: z23.string().min(1, "Procedure ID is required"),
+var createAppointmentSchema2 = z25.object({
+  clinicId: z25.string().min(1, "Clinic ID is required"),
+  doctorId: z25.string().min(1, "Doctor ID is required"),
+  patientId: z25.string().min(1, "Patient ID is required"),
+  procedureId: z25.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: z23.string().optional()
+  description: z25.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -10868,95 +10949,95 @@ var createAppointmentSchema2 = z23.object({
     message: "Invalid appointment parameters"
   }
 );
-var updateAppointmentSchema2 = z23.object({
-  appointmentId: z23.string().min(1, "Appointment ID is required"),
-  clinicId: z23.string().min(1, "Clinic ID is required"),
-  doctorId: z23.string().min(1, "Doctor ID is required"),
-  patientId: z23.string().min(1, "Patient ID is required"),
+var updateAppointmentSchema2 = z25.object({
+  appointmentId: z25.string().min(1, "Appointment ID is required"),
+  clinicId: z25.string().min(1, "Clinic ID is required"),
+  doctorId: z25.string().min(1, "Doctor ID is required"),
+  patientId: z25.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z23.string().optional(),
-  status: z23.nativeEnum(CalendarEventStatus).optional()
+  description: z25.string().optional(),
+  status: z25.nativeEnum(CalendarEventStatus).optional()
 });
-var createCalendarEventSchema = z23.object({
-  id: z23.string(),
-  clinicBranchId: z23.string().nullable().optional(),
-  clinicBranchInfo: z23.any().nullable().optional(),
-  practitionerProfileId: z23.string().nullable().optional(),
+var createCalendarEventSchema = z25.object({
+  id: z25.string(),
+  clinicBranchId: z25.string().nullable().optional(),
+  clinicBranchInfo: z25.any().nullable().optional(),
+  practitionerProfileId: z25.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z23.string().nullable().optional(),
+  patientProfileId: z25.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z23.string().nullable().optional(),
-  appointmentId: z23.string().nullable().optional(),
-  syncedCalendarEventId: z23.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: z23.string().min(1, "Event name is required"),
+  procedureId: z25.string().nullable().optional(),
+  appointmentId: z25.string().nullable().optional(),
+  syncedCalendarEventId: z25.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z25.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: z23.string().optional(),
-  status: z23.nativeEnum(CalendarEventStatus),
-  syncStatus: z23.nativeEnum(CalendarSyncStatus),
-  eventType: z23.nativeEnum(CalendarEventType),
-  createdAt: z23.any(),
+  description: z25.string().optional(),
+  status: z25.nativeEnum(CalendarEventStatus),
+  syncStatus: z25.nativeEnum(CalendarSyncStatus),
+  eventType: z25.nativeEnum(CalendarEventType),
+  createdAt: z25.any(),
   // FieldValue for server timestamp
-  updatedAt: z23.any()
+  updatedAt: z25.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = z23.object({
-  syncedCalendarEventId: z23.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: z23.string().nullable().optional(),
-  eventName: z23.string().optional(),
+var updateCalendarEventSchema = z25.object({
+  syncedCalendarEventId: z25.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: z25.string().nullable().optional(),
+  eventName: z25.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z23.string().optional(),
-  status: z23.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: z23.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: z23.nativeEnum(CalendarEventType).optional(),
-  updatedAt: z23.any()
+  description: z25.string().optional(),
+  status: z25.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: z25.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: z25.nativeEnum(CalendarEventType).optional(),
+  updatedAt: z25.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = z23.object({
-  id: z23.string(),
-  clinicBranchId: z23.string().nullable().optional(),
-  clinicBranchInfo: z23.any().nullable().optional(),
+var calendarEventSchema = z25.object({
+  id: z25.string(),
+  clinicBranchId: z25.string().nullable().optional(),
+  clinicBranchInfo: z25.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: z23.string().nullable().optional(),
+  practitionerProfileId: z25.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z23.string().nullable().optional(),
+  patientProfileId: z25.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z23.string().nullable().optional(),
+  procedureId: z25.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: z23.string().nullable().optional(),
-  syncedCalendarEventId: z23.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: z23.string(),
+  appointmentId: z25.string().nullable().optional(),
+  syncedCalendarEventId: z25.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z25.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: z23.string().optional(),
-  status: z23.nativeEnum(CalendarEventStatus),
-  syncStatus: z23.nativeEnum(CalendarSyncStatus),
-  eventType: z23.nativeEnum(CalendarEventType),
-  createdAt: z23.instanceof(Date).or(z23.instanceof(Timestamp21)),
-  updatedAt: z23.instanceof(Date).or(z23.instanceof(Timestamp21))
+  description: z25.string().optional(),
+  status: z25.nativeEnum(CalendarEventStatus),
+  syncStatus: z25.nativeEnum(CalendarSyncStatus),
+  eventType: z25.nativeEnum(CalendarEventType),
+  createdAt: z25.instanceof(Date).or(z25.instanceof(Timestamp21)),
+  updatedAt: z25.instanceof(Date).or(z25.instanceof(Timestamp21))
 });
-var createBlockingEventSchema = z23.object({
-  entityType: z23.enum(["practitioner", "clinic"]),
-  entityId: z23.string().min(1, "Entity ID is required"),
-  eventName: z23.string().min(1, "Event name is required").max(200, "Event name too long"),
+var createBlockingEventSchema = z25.object({
+  entityType: z25.enum(["practitioner", "clinic"]),
+  entityId: z25.string().min(1, "Entity ID is required"),
+  eventName: z25.string().min(1, "Event name is required").max(200, "Event name too long"),
   eventTime: calendarEventTimeSchema,
-  eventType: z23.enum([
+  eventType: z25.enum([
     "blocking" /* BLOCKING */,
     "break" /* BREAK */,
     "free_day" /* FREE_DAY */,
     "other" /* OTHER */
   ]),
-  description: z23.string().max(1e3, "Description too long").optional()
+  description: z25.string().max(1e3, "Description too long").optional()
 });
-var updateBlockingEventSchema = z23.object({
-  entityType: z23.enum(["practitioner", "clinic"]),
-  entityId: z23.string().min(1, "Entity ID is required"),
-  eventId: z23.string().min(1, "Event ID is required"),
-  eventName: z23.string().min(1, "Event name is required").max(200, "Event name too long").optional(),
+var updateBlockingEventSchema = z25.object({
+  entityType: z25.enum(["practitioner", "clinic"]),
+  entityId: z25.string().min(1, "Entity ID is required"),
+  eventId: z25.string().min(1, "Event ID is required"),
+  eventName: z25.string().min(1, "Event name is required").max(200, "Event name too long").optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z23.string().max(1e3, "Description too long").optional(),
-  status: z23.nativeEnum(CalendarEventStatus).optional()
+  description: z25.string().max(1e3, "Description too long").optional(),
+  status: z25.nativeEnum(CalendarEventStatus).optional()
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -10967,12 +11048,12 @@ import {
   getDocs as getDocs20,
   setDoc as setDoc18,
   updateDoc as updateDoc20,
-  deleteDoc as deleteDoc12,
+  deleteDoc as deleteDoc13,
   query as query20,
   where as where20,
-  orderBy as orderBy9,
+  orderBy as orderBy10,
   Timestamp as Timestamp22,
-  serverTimestamp as serverTimestamp17
+  serverTimestamp as serverTimestamp16
 } from "firebase/firestore";
 
 // src/services/calendar/utils/docs.utils.ts
@@ -11021,8 +11102,8 @@ async function createClinicCalendarEventUtil(db, clinicId, eventData, generateId
   const newEvent = {
     id: eventId,
     ...eventData,
-    createdAt: serverTimestamp17(),
-    updatedAt: serverTimestamp17()
+    createdAt: serverTimestamp16(),
+    updatedAt: serverTimestamp16()
   };
   await setDoc18(eventRef, newEvent);
   return {
@@ -11035,7 +11116,7 @@ async function updateClinicCalendarEventUtil(db, clinicId, eventId, updateData)
   const eventRef = getClinicCalendarEventDocRef(db, clinicId, eventId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp17()
+    updatedAt: serverTimestamp16()
   };
   await updateDoc20(eventRef, updates);
   const updatedDoc = await getDoc23(eventRef);
@@ -11071,12 +11152,12 @@ import {
   getDocs as getDocs21,
   setDoc as setDoc19,
   updateDoc as updateDoc21,
-  deleteDoc as deleteDoc13,
+  deleteDoc as deleteDoc14,
   query as query21,
   where as where21,
-  orderBy as orderBy10,
+  orderBy as orderBy11,
   Timestamp as Timestamp23,
-  serverTimestamp as serverTimestamp18
+  serverTimestamp as serverTimestamp17
 } from "firebase/firestore";
 async function createPatientCalendarEventUtil(db, patientId, eventData, generateId2) {
   const eventId = generateId2();
@@ -11084,8 +11165,8 @@ async function createPatientCalendarEventUtil(db, patientId, eventData, generate
   const newEvent = {
     id: eventId,
     ...eventData,
-    createdAt: serverTimestamp18(),
-    updatedAt: serverTimestamp18()
+    createdAt: serverTimestamp17(),
+    updatedAt: serverTimestamp17()
   };
   await setDoc19(eventRef, newEvent);
   return {
@@ -11098,7 +11179,7 @@ async function updatePatientCalendarEventUtil(db, patientId, eventId, updateData
   const eventRef = getPatientCalendarEventDocRef(db, patientId, eventId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp18()
+    updatedAt: serverTimestamp17()
   };
   await updateDoc21(eventRef, updates);
   const updatedDoc = await getDoc24(eventRef);
@@ -11115,12 +11196,12 @@ import {
   getDocs as getDocs22,
   setDoc as setDoc20,
   updateDoc as updateDoc22,
-  deleteDoc as deleteDoc14,
+  deleteDoc as deleteDoc15,
   query as query22,
   where as where22,
-  orderBy as orderBy11,
+  orderBy as orderBy12,
   Timestamp as Timestamp24,
-  serverTimestamp as serverTimestamp19
+  serverTimestamp as serverTimestamp18
 } from "firebase/firestore";
 async function createPractitionerCalendarEventUtil(db, practitionerId, eventData, generateId2) {
   const eventId = generateId2();
@@ -11132,8 +11213,8 @@ async function createPractitionerCalendarEventUtil(db, practitionerId, eventData
   const newEvent = {
     id: eventId,
     ...eventData,
-    createdAt: serverTimestamp19(),
-    updatedAt: serverTimestamp19()
+    createdAt: serverTimestamp18(),
+    updatedAt: serverTimestamp18()
   };
   await setDoc20(eventRef, newEvent);
   return {
@@ -11150,7 +11231,7 @@ async function updatePractitionerCalendarEventUtil(db, practitionerId, eventId,
   );
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp19()
+    updatedAt: serverTimestamp18()
   };
   await updateDoc22(eventRef, updates);
   const updatedDoc = await getDoc25(eventRef);
@@ -11218,12 +11299,12 @@ import {
   getDocs as getDocs23,
   setDoc as setDoc21,
   updateDoc as updateDoc23,
-  deleteDoc as deleteDoc15,
+  deleteDoc as deleteDoc16,
   query as query23,
   where as where23,
-  orderBy as orderBy12,
+  orderBy as orderBy13,
   Timestamp as Timestamp25,
-  serverTimestamp as serverTimestamp20
+  serverTimestamp as serverTimestamp19
 } from "firebase/firestore";
 async function searchCalendarEventsUtil(db, params) {
   const { searchLocation, entityId, ...filters } = params;
@@ -11324,11 +11405,11 @@ import {
   getDocs as getDocs24,
   setDoc as setDoc22,
   updateDoc as updateDoc24,
-  deleteDoc as deleteDoc16,
+  deleteDoc as deleteDoc17,
   query as query24,
-  orderBy as orderBy13,
+  orderBy as orderBy14,
   Timestamp as Timestamp26,
-  serverTimestamp as serverTimestamp21
+  serverTimestamp as serverTimestamp20
 } from "firebase/firestore";
 async function createPractitionerSyncedCalendarUtil(db, practitionerId, calendarData, generateId2) {
   const calendarId = generateId2();
@@ -11340,8 +11421,8 @@ async function createPractitionerSyncedCalendarUtil(db, practitionerId, calendar
   const newCalendar = {
     id: calendarId,
     ...calendarData,
-    createdAt: serverTimestamp21(),
-    updatedAt: serverTimestamp21()
+    createdAt: serverTimestamp20(),
+    updatedAt: serverTimestamp20()
   };
   await setDoc22(calendarRef, newCalendar);
   return {
@@ -11356,8 +11437,8 @@ async function createPatientSyncedCalendarUtil(db, patientId, calendarData, gene
   const newCalendar = {
     id: calendarId,
     ...calendarData,
-    createdAt: serverTimestamp21(),
-    updatedAt: serverTimestamp21()
+    createdAt: serverTimestamp20(),
+    updatedAt: serverTimestamp20()
   };
   await setDoc22(calendarRef, newCalendar);
   return {
@@ -11372,8 +11453,8 @@ async function createClinicSyncedCalendarUtil(db, clinicId, calendarData, genera
   const newCalendar = {
     id: calendarId,
     ...calendarData,
-    createdAt: serverTimestamp21(),
-    updatedAt: serverTimestamp21()
+    createdAt: serverTimestamp20(),
+    updatedAt: serverTimestamp20()
   };
   await setDoc22(calendarRef, newCalendar);
   return {
@@ -11399,7 +11480,7 @@ async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
     db,
     `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
   );
-  const q = query24(calendarsRef, orderBy13("createdAt", "desc"));
+  const q = query24(calendarsRef, orderBy14("createdAt", "desc"));
   const querySnapshot = await getDocs24(q);
   return querySnapshot.docs.map((doc36) => doc36.data());
 }
@@ -11416,7 +11497,7 @@ async function getPatientSyncedCalendarsUtil(db, patientId) {
     db,
     `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
   );
-  const q = query24(calendarsRef, orderBy13("createdAt", "desc"));
+  const q = query24(calendarsRef, orderBy14("createdAt", "desc"));
   const querySnapshot = await getDocs24(q);
   return querySnapshot.docs.map((doc36) => doc36.data());
 }
@@ -11433,7 +11514,7 @@ async function getClinicSyncedCalendarsUtil(db, clinicId) {
     db,
     `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
   );
-  const q = query24(calendarsRef, orderBy13("createdAt", "desc"));
+  const q = query24(calendarsRef, orderBy14("createdAt", "desc"));
   const querySnapshot = await getDocs24(q);
   return querySnapshot.docs.map((doc36) => doc36.data());
 }
@@ -11445,7 +11526,7 @@ async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendar
   );
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp21()
+    updatedAt: serverTimestamp20()
   };
   await updateDoc24(calendarRef, updates);
   const updatedDoc = await getDoc27(calendarRef);
@@ -11458,7 +11539,7 @@ async function updatePatientSyncedCalendarUtil(db, patientId, calendarId, update
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp21()
+    updatedAt: serverTimestamp20()
   };
   await updateDoc24(calendarRef, updates);
   const updatedDoc = await getDoc27(calendarRef);
@@ -11471,7 +11552,7 @@ async function updateClinicSyncedCalendarUtil(db, clinicId, calendarId, updateDa
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
   const updates = {
     ...updateData,
-    updatedAt: serverTimestamp21()
+    updatedAt: serverTimestamp20()
   };
   await updateDoc24(calendarRef, updates);
   const updatedDoc = await getDoc27(calendarRef);
@@ -11486,15 +11567,15 @@ async function deletePractitionerSyncedCalendarUtil(db, practitionerId, calendar
     practitionerId,
     calendarId
   );
-  await deleteDoc16(calendarRef);
+  await deleteDoc17(calendarRef);
 }
 async function deletePatientSyncedCalendarUtil(db, patientId, calendarId) {
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
-  await deleteDoc16(calendarRef);
+  await deleteDoc17(calendarRef);
 }
 async function deleteClinicSyncedCalendarUtil(db, clinicId, calendarId) {
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
-  await deleteDoc16(calendarRef);
+  await deleteDoc17(calendarRef);
 }
 async function updateLastSyncedTimestampUtil(db, entityType, entityId, calendarId) {
   const updateData = {
@@ -12693,8 +12774,8 @@ var CalendarServiceV2 = class extends BaseService {
       const newEvent = {
         id: eventId,
         ...eventData,
-        createdAt: serverTimestamp22(),
-        updatedAt: serverTimestamp22()
+        createdAt: serverTimestamp21(),
+        updatedAt: serverTimestamp21()
       };
       await setDoc23(eventRef, newEvent);
       return {
@@ -12910,7 +12991,7 @@ var CalendarServiceV2 = class extends BaseService {
           end: Timestamp28.fromDate(endTime)
         },
         description: externalEvent.description || "",
-        updatedAt: serverTimestamp22()
+        updatedAt: serverTimestamp21()
       });
       console.log(`Updated local event ${eventId} from external event`);
     } catch (error) {
@@ -12937,7 +13018,7 @@ var CalendarServiceV2 = class extends BaseService {
       );
       await updateDoc25(eventRef, {
         status,
-        updatedAt: serverTimestamp22()
+        updatedAt: serverTimestamp21()
       });
       console.log(`Updated event ${eventId} status to ${status}`);
     } catch (error) {
@@ -13328,7 +13409,7 @@ var CalendarServiceV2 = class extends BaseService {
         }
         await updateDoc25(eventRef, {
           syncedCalendarEventId: syncIds,
-          updatedAt: serverTimestamp22()
+          updatedAt: serverTimestamp21()
         });
         console.log(
           `Updated event ${eventId} with sync ID ${syncEvent.eventId}`
@@ -13551,8 +13632,8 @@ var CalendarServiceV2 = class extends BaseService {
 };
 
 // src/services/calendar/calendar.v3.service.ts
-import { Timestamp as Timestamp29, serverTimestamp as serverTimestamp23 } from "firebase/firestore";
-import { doc as doc27, getDoc as getDoc29, setDoc as setDoc24, updateDoc as updateDoc26, deleteDoc as deleteDoc17 } from "firebase/firestore";
+import { Timestamp as Timestamp29, serverTimestamp as serverTimestamp22 } from "firebase/firestore";
+import { doc as doc27, getDoc as getDoc29, setDoc as setDoc24, updateDoc as updateDoc26, deleteDoc as deleteDoc18 } from "firebase/firestore";
 var CalendarServiceV3 = class extends BaseService {
   /**
    * Creates a new CalendarServiceV3 instance
@@ -13586,8 +13667,8 @@ var CalendarServiceV3 = class extends BaseService {
       status: "confirmed" /* CONFIRMED */,
       // Blocking events are always confirmed
       syncStatus: "internal" /* INTERNAL */,
-      createdAt: serverTimestamp23(),
-      updatedAt: serverTimestamp23()
+      createdAt: serverTimestamp22(),
+      updatedAt: serverTimestamp22()
     };
     if (params.entityType === "practitioner") {
       eventData.practitionerProfileId = params.entityId;
@@ -13617,7 +13698,7 @@ var CalendarServiceV3 = class extends BaseService {
       throw new Error(`Blocking event with ID ${params.eventId} not found`);
     }
     const updateData = {
-      updatedAt: serverTimestamp23()
+      updatedAt: serverTimestamp22()
     };
     if (params.eventName !== void 0) {
       updateData.eventName = params.eventName;
@@ -13648,7 +13729,7 @@ var CalendarServiceV3 = class extends BaseService {
     if (!eventDoc.exists()) {
       throw new Error(`Blocking event with ID ${eventId} not found`);
     }
-    await deleteDoc17(eventRef);
+    await deleteDoc18(eventRef);
   }
   /**
    * Gets a specific blocking event
@@ -13756,15 +13837,15 @@ import {
   query as query26,
   where as where26,
   setDoc as setDoc25,
-  deleteDoc as deleteDoc18,
-  serverTimestamp as serverTimestamp24
+  deleteDoc as deleteDoc19,
+  serverTimestamp as serverTimestamp23
 } from "firebase/firestore";
 
 // src/types/reviews/index.ts
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -13846,12 +13927,12 @@ var ReviewService = class extends BaseService {
       const docRef = doc28(this.db, REVIEWS_COLLECTION, reviewId);
       await setDoc25(docRef, {
         ...review,
-        createdAt: serverTimestamp24(),
-        updatedAt: serverTimestamp24()
+        createdAt: serverTimestamp23(),
+        updatedAt: serverTimestamp23()
       });
       return review;
     } catch (error) {
-      if (error instanceof z24.ZodError) {
+      if (error instanceof z26.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -13947,7 +14028,7 @@ var ReviewService = class extends BaseService {
     if (!review) {
       throw new Error(`Review with ID ${reviewId} not found`);
     }
-    await deleteDoc18(doc28(this.db, REVIEWS_COLLECTION, reviewId));
+    await deleteDoc19(doc28(this.db, REVIEWS_COLLECTION, reviewId));
   }
   /**
    * Calculates the average of an array of numbers
@@ -13967,15 +14048,15 @@ var ReviewService = class extends BaseService {
 // src/services/appointment/appointment.service.ts
 import {
   Timestamp as Timestamp31,
-  serverTimestamp as serverTimestamp26,
+  serverTimestamp as serverTimestamp25,
   arrayUnion as arrayUnion8,
   arrayRemove as arrayRemove7,
   where as where28,
-  orderBy as orderBy15,
+  orderBy as orderBy16,
   collection as collection28,
   query as query28,
-  limit as limit13,
-  startAfter as startAfter11,
+  limit as limit14,
+  startAfter as startAfter12,
   getDocs as getDocs28
 } from "firebase/firestore";
 import { getFunctions as getFunctions2 } from "firebase/functions";
@@ -13990,11 +14071,11 @@ import {
   where as where27,
   setDoc as setDoc26,
   updateDoc as updateDoc27,
-  serverTimestamp as serverTimestamp25,
+  serverTimestamp as serverTimestamp24,
   Timestamp as Timestamp30,
-  orderBy as orderBy14,
-  limit as limit12,
-  startAfter as startAfter10
+  orderBy as orderBy15,
+  limit as limit13,
+  startAfter as startAfter11
 } from "firebase/firestore";
 
 // src/backoffice/types/technology.types.ts
@@ -14053,7 +14134,7 @@ async function updateAppointmentUtil2(db, appointmentId, data) {
       ...data,
       completedPreRequirements,
       completedPostRequirements,
-      updatedAt: serverTimestamp25()
+      updatedAt: serverTimestamp24()
     };
     Object.keys(updateData).forEach((key) => {
       if (updateData[key] === void 0) {
@@ -14113,7 +14194,7 @@ async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus)
     }
     await updateDoc27(calendarEventRef, {
       status: calendarStatus,
-      updatedAt: serverTimestamp25()
+      updatedAt: serverTimestamp24()
     });
   } catch (error) {
     console.error(`Error updating calendar event ${calendarEventId}:`, error);
@@ -14166,12 +14247,12 @@ async function searchAppointmentsUtil(db, params) {
         constraints.push(where27("status", "==", params.status));
       }
     }
-    constraints.push(orderBy14("appointmentStartTime", "asc"));
+    constraints.push(orderBy15("appointmentStartTime", "asc"));
     if (params.limit) {
-      constraints.push(limit12(params.limit));
+      constraints.push(limit13(params.limit));
     }
     if (params.startAfter) {
-      constraints.push(startAfter10(params.startAfter));
+      constraints.push(startAfter11(params.startAfter));
     }
     const q = query27(collection27(db, APPOINTMENTS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs27(q);
@@ -14545,7 +14626,7 @@ var AppointmentService = class extends BaseService {
     );
     const updateData = {
       status: newStatus,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     if (newStatus === "canceled_clinic" /* CANCELED_CLINIC */ || newStatus === "canceled_patient" /* CANCELED_PATIENT */ || newStatus === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */) {
       if (!(details == null ? void 0 : details.cancellationReason)) {
@@ -14642,7 +14723,7 @@ var AppointmentService = class extends BaseService {
       appointmentEndTime: endTimestamp,
       rescheduleTime: Timestamp31.now(),
       confirmationTime: null,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(validatedParams.appointmentId, updateData);
   }
@@ -14773,7 +14854,7 @@ var AppointmentService = class extends BaseService {
       status: "in_progress" /* IN_PROGRESS */,
       procedureActualStartTime: Timestamp31.now(),
       // Set actual start time
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14814,7 +14895,7 @@ var AppointmentService = class extends BaseService {
       },
       // Optionally update appointmentEndTime to the actual completion time
       // appointmentEndTime: procedureCompletionTime,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14857,7 +14938,7 @@ var AppointmentService = class extends BaseService {
     };
     const updateData = {
       media: arrayUnion8(newMediaItem),
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14878,7 +14959,7 @@ var AppointmentService = class extends BaseService {
     }
     const updateData = {
       media: arrayRemove7(mediaToRemove),
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14896,7 +14977,7 @@ var AppointmentService = class extends BaseService {
     };
     const updateData = {
       reviewInfo: newReviewInfo,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14910,7 +14991,7 @@ var AppointmentService = class extends BaseService {
     const updateData = {
       paymentStatus,
       paymentTransactionId: paymentTransactionId || null,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14970,12 +15051,12 @@ var AppointmentService = class extends BaseService {
           )
         );
       }
-      constraints.push(orderBy15("appointmentStartTime", "asc"));
+      constraints.push(orderBy16("appointmentStartTime", "asc"));
       if (options == null ? void 0 : options.limit) {
-        constraints.push(limit13(options.limit));
+        constraints.push(limit14(options.limit));
       }
       if (options == null ? void 0 : options.startAfter) {
-        constraints.push(startAfter11(options.startAfter));
+        constraints.push(startAfter12(options.startAfter));
       }
       const q = query28(
         collection28(this.db, APPOINTMENTS_COLLECTION),
@@ -15043,12 +15124,12 @@ var AppointmentService = class extends BaseService {
           Timestamp31.fromDate(effectiveEndDate)
         )
       );
-      constraints.push(orderBy15("appointmentStartTime", "desc"));
+      constraints.push(orderBy16("appointmentStartTime", "desc"));
       if (options == null ? void 0 : options.limit) {
-        constraints.push(limit13(options.limit));
+        constraints.push(limit14(options.limit));
       }
       if (options == null ? void 0 : options.startAfter) {
-        constraints.push(startAfter11(options.startAfter));
+        constraints.push(startAfter12(options.startAfter));
       }
       const q = query28(
         collection28(this.db, APPOINTMENTS_COLLECTION),
@@ -15082,9 +15163,9 @@ import {
   doc as doc30,
   updateDoc as updateDoc28,
   Timestamp as Timestamp32,
-  orderBy as orderBy16,
-  limit as limit14,
-  startAfter as startAfter12,
+  orderBy as orderBy17,
+  limit as limit15,
+  startAfter as startAfter13,
   getDoc as getDoc32
 } from "firebase/firestore";
 
@@ -15154,7 +15235,7 @@ var PatientRequirementsService = class extends BaseService {
    */
   async getAllPatientRequirementInstances(patientId, filters, pageLimit = 20, lastVisible) {
     const collRef = this.getPatientRequirementsCollectionRef(patientId);
-    let q = query29(collRef, orderBy16("createdAt", "desc"));
+    let q = query29(collRef, orderBy17("createdAt", "desc"));
     const queryConstraints = [];
     if ((filters == null ? void 0 : filters.appointmentId) && filters.appointmentId !== "all") {
       queryConstraints.push(
@@ -15165,9 +15246,9 @@ var PatientRequirementsService = class extends BaseService {
       queryConstraints.push(where29("overallStatus", "in", filters.statuses));
     }
     if (lastVisible) {
-      queryConstraints.push(startAfter12(lastVisible));
+      queryConstraints.push(startAfter13(lastVisible));
     }
-    queryConstraints.push(limit14(pageLimit));
+    queryConstraints.push(limit15(pageLimit));
     q = query29(collRef, ...queryConstraints);
     const snapshot = await getDocs29(q);
     let requirements = snapshot.docs.map((docSnap) => {
@@ -16137,63 +16218,63 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-import { z as z25 } from "zod";
-var baseNotificationSchema = z25.object({
-  id: z25.string().optional(),
-  userId: z25.string(),
-  notificationTime: z25.any(),
+import { z as z27 } from "zod";
+var baseNotificationSchema = z27.object({
+  id: z27.string().optional(),
+  userId: z27.string(),
+  notificationTime: z27.any(),
   // Timestamp
-  notificationType: z25.nativeEnum(NotificationType),
-  notificationTokens: z25.array(z25.string()),
-  status: z25.nativeEnum(NotificationStatus),
-  createdAt: z25.any().optional(),
+  notificationType: z27.nativeEnum(NotificationType),
+  notificationTokens: z27.array(z27.string()),
+  status: z27.nativeEnum(NotificationStatus),
+  createdAt: z27.any().optional(),
   // Timestamp
-  updatedAt: z25.any().optional(),
+  updatedAt: z27.any().optional(),
   // Timestamp
-  title: z25.string(),
-  body: z25.string(),
-  isRead: z25.boolean(),
-  userRole: z25.nativeEnum(UserRole)
+  title: z27.string(),
+  body: z27.string(),
+  isRead: z27.boolean(),
+  userRole: z27.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z25.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
-  treatmentId: z25.string(),
-  requirements: z25.array(z25.string()),
-  deadline: z25.any()
+  notificationType: z27.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
+  treatmentId: z27.string(),
+  requirements: z27.array(z27.string()),
+  deadline: z27.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z25.literal(
+  notificationType: z27.literal(
     "postRequirementInstructionDue" /* POST_REQUIREMENT_INSTRUCTION_DUE */
   ),
-  treatmentId: z25.string(),
-  requirements: z25.array(z25.string()),
-  deadline: z25.any()
+  treatmentId: z27.string(),
+  requirements: z27.array(z27.string()),
+  deadline: z27.any()
   // Timestamp
 });
 var requirementInstructionDueNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z25.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
-  appointmentId: z25.string(),
-  patientRequirementInstanceId: z25.string(),
-  instructionId: z25.string(),
-  originalRequirementId: z25.string().optional()
+  notificationType: z27.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
+  appointmentId: z27.string(),
+  patientRequirementInstanceId: z27.string(),
+  instructionId: z27.string(),
+  originalRequirementId: z27.string().optional()
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z25.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: z25.string(),
-  appointmentTime: z25.any(),
+  notificationType: z27.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: z27.string(),
+  appointmentTime: z27.any(),
   // Timestamp
-  treatmentType: z25.string(),
-  doctorName: z25.string()
+  treatmentType: z27.string(),
+  doctorName: z27.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z25.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
-  appointmentId: z25.string(),
-  appointmentStatus: z25.string(),
-  previousStatus: z25.string(),
-  reason: z25.string().optional()
+  notificationType: z27.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
+  appointmentId: z27.string(),
+  appointmentStatus: z27.string(),
+  previousStatus: z27.string(),
+  reason: z27.string().optional()
 });
-var notificationSchema = z25.discriminatedUnion("notificationType", [
+var notificationSchema = z27.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   requirementInstructionDueNotificationSchema,