npm - @blackcode_sa/metaestetics-api - Versions diffs - 1.7.41 → 1.7.43 - Mend

@blackcode_sa/metaestetics-api 1.7.41 → 1.7.43

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/dist/admin/index.d.mts +4 -4
package/dist/admin/index.d.ts +4 -4
package/dist/backoffice/index.d.mts +4 -4
package/dist/backoffice/index.d.ts +4 -4
package/dist/index.d.mts +215 -210
package/dist/index.d.ts +215 -210
package/dist/index.js +475 -381
package/dist/index.mjs +602 -507
package/package.json +1 -1
package/src/services/auth/index.ts +21 -0
package/src/services/auth/utils/error.utils.ts +90 -0
package/src/services/auth/utils/firebase.utils.ts +49 -0
package/src/services/auth/utils/index.ts +21 -0
package/src/services/auth/utils/practitioner.utils.ts +125 -0
package/src/services/auth.service.ts +143 -155
package/src/services/practitioner/practitioner.service.ts +5 -3
package/src/types/index.ts +3 -3
package/src/types/practitioner/index.ts +4 -4
package/src/validations/common.schema.ts +6 -1
package/src/validations/practitioner.schema.ts +7 -4
package/src/validations/schemas.ts +26 -14

package/dist/index.mjs CHANGED Viewed

@@ -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";
@@ -656,12 +657,21 @@ var passwordSchema = z4.string().min(8, "Password must be at least 8 characters"
 );
 var userRoleSchema = z4.nativeEnum(UserRole);
 var userRolesSchema = z4.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = z4.custom((data) => {
-  if (data && typeof data === "object" && "isEqual" in data) {
-    return true;
-  }
-  return data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data;
-}, "Must be a Timestamp object or serverTimestamp");
+var timestampSchema = z4.custom(
+  (data) => {
+    if (data && typeof data === "object" && "isEqual" in data) {
+      return true;
+    }
+    if (data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data) {
+      return true;
+    }
+    if (data instanceof Date) {
+      return true;
+    }
+    return false;
+  },
+  "Must be a Timestamp object, Date object, or serverTimestamp"
+);
 var clinicAdminOptionsSchema = z4.object({
   isGroupOwner: z4.boolean(),
   groupToken: z4.string().optional(),
@@ -1526,11 +1536,16 @@ var timestampSchema2 = z5.union([
     seconds: z5.number(),
     nanoseconds: z5.number()
   }),
-  z5.instanceof(Timestamp2)
+  z5.instanceof(Timestamp2),
+  z5.instanceof(Date)
+  // Add support for Date objects that Firestore returns on client
 ]).transform((data) => {
   if (data instanceof Timestamp2) {
     return data;
   }
+  if (data instanceof Date) {
+    return Timestamp2.fromDate(data);
+  }
   return new Timestamp2(data.seconds, data.nanoseconds);
 });
@@ -4522,10 +4537,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 +4550,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 +7708,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 +7834,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 +7883,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 +8137,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 +8312,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 +8435,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 +8474,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 +8489,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 +8516,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 +8691,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 +8776,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 +8792,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 +8856,7 @@ var NotificationService = class extends BaseService {
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    await deleteDoc8(notificationRef);
+    await deleteDoc9(notificationRef);
   }
   /**
    * Dohvata notifikacije po tipu
@@ -8771,7 +8866,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 +8881,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 +8901,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 +8976,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 +9150,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 +9339,7 @@ var ProcedureService = class extends BaseService {
     }
     await updateDoc16(procedureRef, {
       ...updatedProcedureData,
-      updatedAt: serverTimestamp14()
+      updatedAt: serverTimestamp13()
     });
     const updatedSnapshot = await getDoc19(procedureRef);
     return updatedSnapshot.data();
@@ -9262,7 +9357,7 @@ var ProcedureService = class extends BaseService {
     }
     await updateDoc16(procedureRef, {
       isActive: false,
-      updatedAt: serverTimestamp14()
+      updatedAt: serverTimestamp13()
     });
   }
   /**
@@ -9276,7 +9371,7 @@ var ProcedureService = class extends BaseService {
     if (!procedureSnapshot.exists()) {
       return false;
     }
-    await deleteDoc9(procedureRef);
+    await deleteDoc10(procedureRef);
     return true;
   }
   /**
@@ -9305,24 +9400,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 +9475,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 +9766,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 +9784,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 +9883,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 +9912,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 +9948,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 +9980,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 +10012,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 +10068,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 +10106,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 +10161,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 +10187,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 +10345,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 +10359,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 +10371,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 +10401,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 +10430,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 +10457,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 +10483,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 +10637,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 +10661,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 +10835,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 +10859,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 +10915,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 +10963,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 +11062,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 +11116,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 +11130,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 +11166,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 +11179,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 +11193,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 +11210,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 +11227,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 +11245,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 +11313,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 +11419,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 +11435,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 +11451,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 +11467,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 +11494,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 +11511,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 +11528,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 +11540,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 +11553,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 +11566,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 +11581,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 +12788,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 +13005,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 +13032,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 +13423,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 +13646,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 +13681,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 +13712,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 +13743,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 +13851,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 +13941,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 +14042,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 +14062,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 +14085,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 +14148,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 +14208,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 +14261,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 +14640,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 +14737,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 +14868,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 +14909,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 +14952,7 @@ var AppointmentService = class extends BaseService {
     };
     const updateData = {
       media: arrayUnion8(newMediaItem),
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14878,7 +14973,7 @@ var AppointmentService = class extends BaseService {
     }
     const updateData = {
       media: arrayRemove7(mediaToRemove),
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14896,7 +14991,7 @@ var AppointmentService = class extends BaseService {
     };
     const updateData = {
       reviewInfo: newReviewInfo,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14910,7 +15005,7 @@ var AppointmentService = class extends BaseService {
     const updateData = {
       paymentStatus,
       paymentTransactionId: paymentTransactionId || null,
-      updatedAt: serverTimestamp26()
+      updatedAt: serverTimestamp25()
     };
     return this.updateAppointment(appointmentId, updateData);
   }
@@ -14970,12 +15065,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 +15138,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 +15177,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 +15249,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 +15260,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 +16232,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,