@blackcode_sa/metaestetics-api 1.6.1 → 1.6.2

package/dist/index.js

@@ -131,7 +131,6 @@ __export(index_exports, {
   clinicContactInfoSchema: () => clinicContactInfoSchema,
   clinicGroupSchema: () => clinicGroupSchema,
   clinicGroupSetupSchema: () => clinicGroupSetupSchema,
-  clinicInfoSchema: () => clinicInfoSchema,
   clinicLocationSchema: () => clinicLocationSchema,
   clinicReviewInfoSchema: () => clinicReviewInfoSchema,
   clinicReviewSchema: () => clinicReviewSchema,
@@ -159,7 +158,6 @@ __export(index_exports, {
   createProcedureReviewSchema: () => createProcedureReviewSchema,
   createReviewSchema: () => createReviewSchema,
   createUserOptionsSchema: () => createUserOptionsSchema,
-  doctorInfoSchema: () => doctorInfoSchema,
   documentElementSchema: () => documentElementSchema,
   documentElementWithoutIdSchema: () => documentElementWithoutIdSchema,
   documentTemplateSchema: () => documentTemplateSchema,
@@ -198,7 +196,6 @@ __export(index_exports, {
   procedureInfoSchema: () => procedureInfoSchema,
   procedureReviewInfoSchema: () => procedureReviewInfoSchema,
   procedureReviewSchema: () => procedureReviewSchema,
-  procedureSummaryInfoSchema: () => procedureSummaryInfoSchema,
   requesterInfoSchema: () => requesterInfoSchema,
   reviewSchema: () => reviewSchema,
   searchAppointmentsSchema: () => searchAppointmentsSchema,
@@ -464,7 +461,7 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/validations/schemas.ts
 var import_zod3 = require("zod");
@@ -989,7 +986,7 @@ var USER_ERRORS = {
 };
 
 // src/services/user.service.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/services/patient/patient.service.ts
 var import_firestore11 = require("firebase/firestore");
@@ -2643,7 +2640,7 @@ var PatientService = class extends BaseService {
 };
 
 // src/services/clinic/utils/admin.utils.ts
-var import_firestore14 = require("firebase/firestore");
+var import_firestore13 = require("firebase/firestore");
 
 // src/types/clinic/preferences.types.ts
 var PracticeType = /* @__PURE__ */ ((PracticeType2) => {
@@ -2770,52 +2767,8 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 
 // src/validations/clinic.schema.ts
 var import_zod12 = require("zod");
-var import_firestore13 = require("firebase/firestore");
-
-// src/validations/practitioner.schema.ts
-var import_zod11 = require("zod");
 var import_firestore12 = require("firebase/firestore");
 
-// src/backoffice/types/static/certification.types.ts
-var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
-  CertificationLevel2["AESTHETICIAN"] = "aesthetician";
-  CertificationLevel2["NURSE_ASSISTANT"] = "nurse_assistant";
-  CertificationLevel2["NURSE"] = "nurse";
-  CertificationLevel2["NURSE_PRACTITIONER"] = "nurse_practitioner";
-  CertificationLevel2["PHYSICIAN_ASSISTANT"] = "physician_assistant";
-  CertificationLevel2["DOCTOR"] = "doctor";
-  CertificationLevel2["SPECIALIST"] = "specialist";
-  CertificationLevel2["PLASTIC_SURGEON"] = "plastic_surgeon";
-  return CertificationLevel2;
-})(CertificationLevel || {});
-var CertificationSpecialty = /* @__PURE__ */ ((CertificationSpecialty3) => {
-  CertificationSpecialty3["LASER"] = "laser";
-  CertificationSpecialty3["INJECTABLES"] = "injectables";
-  CertificationSpecialty3["CHEMICAL_PEELS"] = "chemical_peels";
-  CertificationSpecialty3["MICRODERMABRASION"] = "microdermabrasion";
-  CertificationSpecialty3["BODY_CONTOURING"] = "body_contouring";
-  CertificationSpecialty3["SKIN_CARE"] = "skin_care";
-  CertificationSpecialty3["WOUND_CARE"] = "wound_care";
-  CertificationSpecialty3["ANESTHESIA"] = "anesthesia";
-  return CertificationSpecialty3;
-})(CertificationSpecialty || {});
-
-// src/types/practitioner/index.ts
-var PRACTITIONERS_COLLECTION = "practitioners";
-var REGISTER_TOKENS_COLLECTION = "register_tokens";
-var PractitionerStatus = /* @__PURE__ */ ((PractitionerStatus2) => {
-  PractitionerStatus2["DRAFT"] = "draft";
-  PractitionerStatus2["ACTIVE"] = "active";
-  return PractitionerStatus2;
-})(PractitionerStatus || {});
-var PractitionerTokenStatus = /* @__PURE__ */ ((PractitionerTokenStatus2) => {
-  PractitionerTokenStatus2["ACTIVE"] = "active";
-  PractitionerTokenStatus2["USED"] = "used";
-  PractitionerTokenStatus2["EXPIRED"] = "expired";
-  PractitionerTokenStatus2["REVOKED"] = "revoked";
-  return PractitionerTokenStatus2;
-})(PractitionerTokenStatus || {});
-
 // src/validations/reviews.schema.ts
 var import_zod10 = require("zod");
 var baseReviewSchema = import_zod10.z.object({
@@ -2949,6 +2902,9 @@ var createReviewSchema = import_zod10.z.object({
   }
 );
 
+// src/validations/shared.schema.ts
+var import_zod11 = require("zod");
+
 // src/backoffice/types/static/procedure-family.types.ts
 var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
   ProcedureFamily2["AESTHETICS"] = "aesthetics";
@@ -2975,59 +2931,21 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
   return Currency2;
 })(Currency || {});
 
-// src/validations/practitioner.schema.ts
-var practitionerBasicInfoSchema = import_zod11.z.object({
-  firstName: import_zod11.z.string().min(2).max(50),
-  lastName: import_zod11.z.string().min(2).max(50),
-  title: import_zod11.z.string().min(2).max(100),
+// src/validations/shared.schema.ts
+var sharedClinicContactInfoSchema = import_zod11.z.object({
   email: import_zod11.z.string().email(),
-  phoneNumber: import_zod11.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  gender: import_zod11.z.enum(["male", "female", "other"]),
-  profileImageUrl: import_zod11.z.string().url().optional(),
-  bio: import_zod11.z.string().max(1e3).optional(),
-  languages: import_zod11.z.array(import_zod11.z.string()).min(1)
-});
-var practitionerCertificationSchema = import_zod11.z.object({
-  level: import_zod11.z.nativeEnum(CertificationLevel),
-  specialties: import_zod11.z.array(import_zod11.z.nativeEnum(CertificationSpecialty)),
-  licenseNumber: import_zod11.z.string().min(3).max(50),
-  issuingAuthority: import_zod11.z.string().min(2).max(100),
-  issueDate: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  expiryDate: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()).optional(),
-  verificationStatus: import_zod11.z.enum(["pending", "verified", "rejected"])
-});
-var timeSlotSchema = import_zod11.z.object({
-  start: import_zod11.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
-  end: import_zod11.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
-}).nullable();
-var practitionerWorkingHoursSchema = import_zod11.z.object({
-  practitionerId: import_zod11.z.string().min(1),
-  clinicId: import_zod11.z.string().min(1),
-  monday: timeSlotSchema,
-  tuesday: timeSlotSchema,
-  wednesday: timeSlotSchema,
-  thursday: timeSlotSchema,
-  friday: timeSlotSchema,
-  saturday: timeSlotSchema,
-  sunday: timeSlotSchema,
-  createdAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  updatedAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date())
+  phoneNumber: import_zod11.z.string(),
+  alternativePhoneNumber: import_zod11.z.string().nullable().optional(),
+  website: import_zod11.z.string().nullable().optional()
 });
-var practitionerClinicWorkingHoursSchema = import_zod11.z.object({
-  clinicId: import_zod11.z.string().min(1),
-  workingHours: import_zod11.z.object({
-    monday: timeSlotSchema,
-    tuesday: timeSlotSchema,
-    wednesday: timeSlotSchema,
-    thursday: timeSlotSchema,
-    friday: timeSlotSchema,
-    saturday: timeSlotSchema,
-    sunday: timeSlotSchema
-  }),
-  isActive: import_zod11.z.boolean(),
-  createdAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  updatedAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date())
+var sharedClinicLocationSchema = import_zod11.z.object({
+  address: import_zod11.z.string(),
+  city: import_zod11.z.string(),
+  country: import_zod11.z.string(),
+  postalCode: import_zod11.z.string(),
+  latitude: import_zod11.z.number().min(-90).max(90),
+  longitude: import_zod11.z.number().min(-180).max(180),
+  geohash: import_zod11.z.string().nullable().optional()
 });
 var procedureSummaryInfoSchema = import_zod11.z.object({
   id: import_zod11.z.string().min(1),
@@ -3047,79 +2965,22 @@ var procedureSummaryInfoSchema = import_zod11.z.object({
   practitionerId: import_zod11.z.string().min(1),
   practitionerName: import_zod11.z.string().min(1)
 });
-var practitionerSchema = import_zod11.z.object({
-  id: import_zod11.z.string().min(1),
-  userRef: import_zod11.z.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod11.z.array(import_zod11.z.string()),
-  clinicWorkingHours: import_zod11.z.array(practitionerClinicWorkingHoursSchema),
-  clinicsInfo: import_zod11.z.array(clinicInfoSchema),
-  procedures: import_zod11.z.array(import_zod11.z.string()),
-  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema),
-  reviewInfo: practitionerReviewInfoSchema,
-  isActive: import_zod11.z.boolean(),
-  isVerified: import_zod11.z.boolean(),
-  status: import_zod11.z.nativeEnum(PractitionerStatus),
-  createdAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  updatedAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date())
-});
-var createPractitionerSchema = import_zod11.z.object({
-  userRef: import_zod11.z.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod11.z.array(import_zod11.z.string()).optional(),
-  clinicWorkingHours: import_zod11.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod11.z.array(clinicInfoSchema).optional(),
-  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod11.z.boolean(),
-  isVerified: import_zod11.z.boolean(),
-  status: import_zod11.z.nativeEnum(PractitionerStatus).optional()
+var clinicInfoSchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  featuredPhoto: import_zod11.z.string(),
+  name: import_zod11.z.string(),
+  description: import_zod11.z.string().nullable().optional(),
+  location: sharedClinicLocationSchema,
+  contactInfo: sharedClinicContactInfoSchema
 });
-var createDraftPractitionerSchema = import_zod11.z.object({
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: import_zod11.z.array(import_zod11.z.string()).optional(),
-  clinicWorkingHours: import_zod11.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod11.z.array(clinicInfoSchema).optional(),
-  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod11.z.boolean().optional().default(false),
-  isVerified: import_zod11.z.boolean().optional().default(false)
-});
-var practitionerTokenSchema = import_zod11.z.object({
-  id: import_zod11.z.string().min(1),
-  token: import_zod11.z.string().min(6),
-  practitionerId: import_zod11.z.string().min(1),
-  email: import_zod11.z.string().email(),
-  clinicId: import_zod11.z.string().min(1),
-  status: import_zod11.z.nativeEnum(PractitionerTokenStatus),
-  createdBy: import_zod11.z.string().min(1),
-  createdAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  expiresAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()),
-  usedBy: import_zod11.z.string().optional(),
-  usedAt: import_zod11.z.instanceof(import_firestore12.Timestamp).or(import_zod11.z.date()).optional()
-});
-var createPractitionerTokenSchema = import_zod11.z.object({
-  practitionerId: import_zod11.z.string().min(1),
-  email: import_zod11.z.string().email(),
-  clinicId: import_zod11.z.string().min(1),
-  expiresAt: import_zod11.z.date().optional()
-});
-var practitionerSignupSchema = import_zod11.z.object({
-  email: import_zod11.z.string().email(),
-  password: import_zod11.z.string().min(8),
-  firstName: import_zod11.z.string().min(2).max(50),
-  lastName: import_zod11.z.string().min(2).max(50),
-  token: import_zod11.z.string().optional(),
-  profileData: import_zod11.z.object({
-    basicInfo: import_zod11.z.object({
-      phoneNumber: import_zod11.z.string().optional(),
-      profileImageUrl: import_zod11.z.string().optional(),
-      gender: import_zod11.z.enum(["male", "female", "other"]).optional(),
-      bio: import_zod11.z.string().optional()
-    }).optional(),
-    certification: import_zod11.z.any().optional()
-  }).optional()
+var doctorInfoSchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  name: import_zod11.z.string(),
+  description: import_zod11.z.string().nullable().optional(),
+  photo: import_zod11.z.string(),
+  rating: import_zod11.z.number().min(0).max(5),
+  services: import_zod11.z.array(import_zod11.z.string())
+  // List of procedure IDs practitioner offers
 });
 
 // src/validations/clinic.schema.ts
@@ -3172,23 +3033,6 @@ var adminInfoSchema = import_zod12.z.object({
   name: import_zod12.z.string(),
   email: import_zod12.z.string().email()
 });
-var clinicInfoSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  featuredPhoto: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  description: import_zod12.z.string().nullable().optional(),
-  location: clinicLocationSchema,
-  contactInfo: clinicContactInfoSchema
-});
-var doctorInfoSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  description: import_zod12.z.string().nullable().optional(),
-  photo: import_zod12.z.string(),
-  rating: import_zod12.z.number().min(0).max(5),
-  services: import_zod12.z.array(import_zod12.z.string())
-  // List of procedure IDs practitioner offers
-});
 var clinicAdminSchema = import_zod12.z.object({
   id: import_zod12.z.string(),
   userRef: import_zod12.z.string(),
@@ -3198,8 +3042,8 @@ var clinicAdminSchema = import_zod12.z.object({
   clinicsManagedInfo: import_zod12.z.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
   roleTitle: import_zod12.z.string(),
-  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
-  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
+  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
   isActive: import_zod12.z.boolean()
 });
 var adminTokenSchema = import_zod12.z.object({
@@ -3208,9 +3052,9 @@ var adminTokenSchema = import_zod12.z.object({
   email: import_zod12.z.string().email().optional().nullable(),
   status: import_zod12.z.nativeEnum(AdminTokenStatus),
   usedByUserRef: import_zod12.z.string().optional(),
-  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
   // Timestamp
-  expiresAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp))
+  expiresAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp))
   // Timestamp
 });
 var createAdminTokenSchema = import_zod12.z.object({
@@ -3230,9 +3074,9 @@ var clinicGroupSchema = import_zod12.z.object({
   adminsInfo: import_zod12.z.array(adminInfoSchema),
   adminTokens: import_zod12.z.array(adminTokenSchema),
   ownerId: import_zod12.z.string().nullable(),
-  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
   // Timestamp
-  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
   // Timestamp
   isActive: import_zod12.z.boolean(),
   logo: import_zod12.z.string().optional().nullable(),
@@ -3272,9 +3116,9 @@ var clinicSchema = import_zod12.z.object({
   // servicesInfo: z.array(serviceInfoSchema), // Deprecated, use proceduresInfo
   reviewInfo: clinicReviewInfoSchema,
   admins: import_zod12.z.array(import_zod12.z.string()),
-  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
   // Timestamp
-  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore12.Timestamp)),
   // Timestamp
   isActive: import_zod12.z.boolean(),
   isVerified: import_zod12.z.boolean(),
@@ -3464,7 +3308,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
   const adminData = {
-    id: (0, import_firestore14.doc)((0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
+    id: (0, import_firestore13.doc)((0, import_firestore13.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
     // Generate a new ID for the admin document
     userRef: validatedData.userRef,
     clinicGroupId: clinicGroupId || "",
@@ -3477,15 +3321,15 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     contactInfo: validatedData.contactInfo,
     roleTitle: validatedData.roleTitle,
     isActive: validatedData.isActive,
-    createdAt: (0, import_firestore14.serverTimestamp)(),
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    createdAt: (0, import_firestore13.serverTimestamp)(),
+    updatedAt: (0, import_firestore13.serverTimestamp)()
   };
   console.log("[CLINIC_ADMIN] Validating complete admin object");
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: import_firestore14.Timestamp.now(),
-      updatedAt: import_firestore14.Timestamp.now()
+      createdAt: import_firestore13.Timestamp.now(),
+      updatedAt: import_firestore13.Timestamp.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -3499,7 +3343,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     adminId: adminData.id
   });
   try {
-    await (0, import_firestore14.setDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    await (0, import_firestore13.setDoc)((0, import_firestore13.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
     console.log("[CLINIC_ADMIN] Admin saved successfully");
   } catch (firestoreError) {
     console.error(
@@ -3548,30 +3392,30 @@ async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   return !!group;
 }
 async function getClinicAdmin(db, adminId) {
-  const docRef = (0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await (0, import_firestore14.getDoc)(docRef);
+  const docRef = (0, import_firestore13.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await (0, import_firestore13.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicAdminByUserRef(db, userRef) {
-  const q = (0, import_firestore14.query)(
-    (0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore14.where)("userRef", "==", userRef)
+  const q = (0, import_firestore13.query)(
+    (0, import_firestore13.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore13.where)("userRef", "==", userRef)
   );
-  const querySnapshot = await (0, import_firestore14.getDocs)(q);
+  const querySnapshot = await (0, import_firestore13.getDocs)(q);
   if (querySnapshot.empty) {
     return null;
   }
   return querySnapshot.docs[0].data();
 }
 async function getClinicAdminsByGroup(db, clinicGroupId) {
-  const q = (0, import_firestore14.query)(
-    (0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore14.where)("clinicGroupId", "==", clinicGroupId)
+  const q = (0, import_firestore13.query)(
+    (0, import_firestore13.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore13.where)("clinicGroupId", "==", clinicGroupId)
   );
-  const querySnapshot = await (0, import_firestore14.getDocs)(q);
+  const querySnapshot = await (0, import_firestore13.getDocs)(q);
   return querySnapshot.docs.map((doc32) => doc32.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
@@ -3581,9 +3425,9 @@ async function updateClinicAdmin(db, adminId, data) {
   }
   const updatedData = {
     ...data,
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    updatedAt: (0, import_firestore13.serverTimestamp)()
   };
-  await (0, import_firestore14.updateDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+  await (0, import_firestore13.updateDoc)((0, import_firestore13.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
   const updatedAdmin = await getClinicAdmin(db, adminId);
   if (!updatedAdmin) {
     throw new Error("Failed to retrieve updated admin");
@@ -3595,7 +3439,7 @@ async function deleteClinicAdmin(db, adminId) {
   if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  await (0, import_firestore14.deleteDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
+  await (0, import_firestore13.deleteDoc)((0, import_firestore13.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3837,7 +3681,182 @@ var ClinicAdminService = class extends BaseService {
 
 // src/services/practitioner/practitioner.service.ts
 var import_firestore15 = require("firebase/firestore");
+
+// src/types/practitioner/index.ts
+var PRACTITIONERS_COLLECTION = "practitioners";
+var REGISTER_TOKENS_COLLECTION = "register_tokens";
+var PractitionerStatus = /* @__PURE__ */ ((PractitionerStatus2) => {
+  PractitionerStatus2["DRAFT"] = "draft";
+  PractitionerStatus2["ACTIVE"] = "active";
+  return PractitionerStatus2;
+})(PractitionerStatus || {});
+var PractitionerTokenStatus = /* @__PURE__ */ ((PractitionerTokenStatus2) => {
+  PractitionerTokenStatus2["ACTIVE"] = "active";
+  PractitionerTokenStatus2["USED"] = "used";
+  PractitionerTokenStatus2["EXPIRED"] = "expired";
+  PractitionerTokenStatus2["REVOKED"] = "revoked";
+  return PractitionerTokenStatus2;
+})(PractitionerTokenStatus || {});
+
+// src/validations/practitioner.schema.ts
 var import_zod13 = require("zod");
+var import_firestore14 = require("firebase/firestore");
+
+// src/backoffice/types/static/certification.types.ts
+var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
+  CertificationLevel2["AESTHETICIAN"] = "aesthetician";
+  CertificationLevel2["NURSE_ASSISTANT"] = "nurse_assistant";
+  CertificationLevel2["NURSE"] = "nurse";
+  CertificationLevel2["NURSE_PRACTITIONER"] = "nurse_practitioner";
+  CertificationLevel2["PHYSICIAN_ASSISTANT"] = "physician_assistant";
+  CertificationLevel2["DOCTOR"] = "doctor";
+  CertificationLevel2["SPECIALIST"] = "specialist";
+  CertificationLevel2["PLASTIC_SURGEON"] = "plastic_surgeon";
+  return CertificationLevel2;
+})(CertificationLevel || {});
+var CertificationSpecialty = /* @__PURE__ */ ((CertificationSpecialty3) => {
+  CertificationSpecialty3["LASER"] = "laser";
+  CertificationSpecialty3["INJECTABLES"] = "injectables";
+  CertificationSpecialty3["CHEMICAL_PEELS"] = "chemical_peels";
+  CertificationSpecialty3["MICRODERMABRASION"] = "microdermabrasion";
+  CertificationSpecialty3["BODY_CONTOURING"] = "body_contouring";
+  CertificationSpecialty3["SKIN_CARE"] = "skin_care";
+  CertificationSpecialty3["WOUND_CARE"] = "wound_care";
+  CertificationSpecialty3["ANESTHESIA"] = "anesthesia";
+  return CertificationSpecialty3;
+})(CertificationSpecialty || {});
+
+// src/validations/practitioner.schema.ts
+var practitionerBasicInfoSchema = import_zod13.z.object({
+  firstName: import_zod13.z.string().min(2).max(50),
+  lastName: import_zod13.z.string().min(2).max(50),
+  title: import_zod13.z.string().min(2).max(100),
+  email: import_zod13.z.string().email(),
+  phoneNumber: import_zod13.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
+  dateOfBirth: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  gender: import_zod13.z.enum(["male", "female", "other"]),
+  profileImageUrl: import_zod13.z.string().url().optional(),
+  bio: import_zod13.z.string().max(1e3).optional(),
+  languages: import_zod13.z.array(import_zod13.z.string()).min(1)
+});
+var practitionerCertificationSchema = import_zod13.z.object({
+  level: import_zod13.z.nativeEnum(CertificationLevel),
+  specialties: import_zod13.z.array(import_zod13.z.nativeEnum(CertificationSpecialty)),
+  licenseNumber: import_zod13.z.string().min(3).max(50),
+  issuingAuthority: import_zod13.z.string().min(2).max(100),
+  issueDate: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  expiryDate: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()).optional(),
+  verificationStatus: import_zod13.z.enum(["pending", "verified", "rejected"])
+});
+var timeSlotSchema = import_zod13.z.object({
+  start: import_zod13.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: import_zod13.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
+}).nullable();
+var practitionerWorkingHoursSchema = import_zod13.z.object({
+  practitionerId: import_zod13.z.string().min(1),
+  clinicId: import_zod13.z.string().min(1),
+  monday: timeSlotSchema,
+  tuesday: timeSlotSchema,
+  wednesday: timeSlotSchema,
+  thursday: timeSlotSchema,
+  friday: timeSlotSchema,
+  saturday: timeSlotSchema,
+  sunday: timeSlotSchema,
+  createdAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  updatedAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date())
+});
+var practitionerClinicWorkingHoursSchema = import_zod13.z.object({
+  clinicId: import_zod13.z.string().min(1),
+  workingHours: import_zod13.z.object({
+    monday: timeSlotSchema,
+    tuesday: timeSlotSchema,
+    wednesday: timeSlotSchema,
+    thursday: timeSlotSchema,
+    friday: timeSlotSchema,
+    saturday: timeSlotSchema,
+    sunday: timeSlotSchema
+  }),
+  isActive: import_zod13.z.boolean(),
+  createdAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  updatedAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date())
+});
+var practitionerSchema = import_zod13.z.object({
+  id: import_zod13.z.string().min(1),
+  userRef: import_zod13.z.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod13.z.array(import_zod13.z.string()),
+  clinicWorkingHours: import_zod13.z.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: import_zod13.z.array(clinicInfoSchema),
+  procedures: import_zod13.z.array(import_zod13.z.string()),
+  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema),
+  reviewInfo: practitionerReviewInfoSchema,
+  isActive: import_zod13.z.boolean(),
+  isVerified: import_zod13.z.boolean(),
+  status: import_zod13.z.nativeEnum(PractitionerStatus),
+  createdAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  updatedAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date())
+});
+var createPractitionerSchema = import_zod13.z.object({
+  userRef: import_zod13.z.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod13.z.array(import_zod13.z.string()).optional(),
+  clinicWorkingHours: import_zod13.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod13.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod13.z.boolean(),
+  isVerified: import_zod13.z.boolean(),
+  status: import_zod13.z.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = import_zod13.z.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod13.z.array(import_zod13.z.string()).optional(),
+  clinicWorkingHours: import_zod13.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod13.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod13.z.boolean().optional().default(false),
+  isVerified: import_zod13.z.boolean().optional().default(false)
+});
+var practitionerTokenSchema = import_zod13.z.object({
+  id: import_zod13.z.string().min(1),
+  token: import_zod13.z.string().min(6),
+  practitionerId: import_zod13.z.string().min(1),
+  email: import_zod13.z.string().email(),
+  clinicId: import_zod13.z.string().min(1),
+  status: import_zod13.z.nativeEnum(PractitionerTokenStatus),
+  createdBy: import_zod13.z.string().min(1),
+  createdAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  expiresAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()),
+  usedBy: import_zod13.z.string().optional(),
+  usedAt: import_zod13.z.instanceof(import_firestore14.Timestamp).or(import_zod13.z.date()).optional()
+});
+var createPractitionerTokenSchema = import_zod13.z.object({
+  practitionerId: import_zod13.z.string().min(1),
+  email: import_zod13.z.string().email(),
+  clinicId: import_zod13.z.string().min(1),
+  expiresAt: import_zod13.z.date().optional()
+});
+var practitionerSignupSchema = import_zod13.z.object({
+  email: import_zod13.z.string().email(),
+  password: import_zod13.z.string().min(8),
+  firstName: import_zod13.z.string().min(2).max(50),
+  lastName: import_zod13.z.string().min(2).max(50),
+  token: import_zod13.z.string().optional(),
+  profileData: import_zod13.z.object({
+    basicInfo: import_zod13.z.object({
+      phoneNumber: import_zod13.z.string().optional(),
+      profileImageUrl: import_zod13.z.string().optional(),
+      gender: import_zod13.z.enum(["male", "female", "other"]).optional(),
+      bio: import_zod13.z.string().optional()
+    }).optional(),
+    certification: import_zod13.z.any().optional()
+  }).optional()
+});
+
+// src/services/practitioner/practitioner.service.ts
+var import_zod14 = require("zod");
 var import_geofire_common2 = require("geofire-common");
 var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService) {
@@ -3906,7 +3925,7 @@ var PractitionerService = class extends BaseService {
       }
       return createdPractitioner;
     } catch (error) {
-      if (error instanceof import_zod13.z.ZodError) {
+      if (error instanceof import_zod14.z.ZodError) {
         throw new Error(`Invalid practitioner data: ${error.message}`);
       }
       console.error("Error creating practitioner:", error);
@@ -3961,7 +3980,8 @@ var PractitionerService = class extends BaseService {
             name: clinicData.name,
             location: clinicData.location,
             contactInfo: clinicData.contactInfo,
-            featuredPhoto: clinicData.coverPhoto || "",
+            // Make sure we're using the right property for featuredPhoto
+            featuredPhoto: clinicData.featuredPhotos && clinicData.featuredPhotos.length > 0 ? clinicData.featuredPhotos[0] : clinicData.coverPhoto || "",
             description: clinicData.description || null
           });
         }
@@ -4018,7 +4038,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore15.setDoc)((0, import_firestore15.doc)(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
-      if (error instanceof import_zod13.z.ZodError) {
+      if (error instanceof import_zod14.z.ZodError) {
         throw new Error("Invalid practitioner data: " + error.message);
       }
       throw error;
@@ -4071,7 +4091,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore15.setDoc)((0, import_firestore15.doc)(this.db, tokenPath), token);
       return token;
     } catch (error) {
-      if (error instanceof import_zod13.z.ZodError) {
+      if (error instanceof import_zod14.z.ZodError) {
         throw new Error("Invalid token data: " + error.message);
       }
       throw error;
@@ -4231,7 +4251,7 @@ var PractitionerService = class extends BaseService {
       }
       return updatedPractitioner;
     } catch (error) {
-      if (error instanceof import_zod13.z.ZodError) {
+      if (error instanceof import_zod14.z.ZodError) {
         throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
       console.error(`Error updating practitioner ${practitionerId}:`, error);
@@ -4759,7 +4779,7 @@ var UserService = class extends BaseService {
       });
       return this.getUserById(uid);
     } catch (error) {
-      if (error instanceof import_zod14.z.ZodError) {
+      if (error instanceof import_zod15.z.ZodError) {
         throw USER_ERRORS.VALIDATION_ERROR;
       }
       throw error;
@@ -4846,7 +4866,7 @@ var UserService = class extends BaseService {
 // src/services/clinic/utils/clinic-group.utils.ts
 var import_firestore17 = require("firebase/firestore");
 var import_geofire_common3 = require("geofire-common");
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
 var import_storage3 = require("firebase/storage");
@@ -5044,7 +5064,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     });
     return groupData;
   } catch (error) {
-    if (error instanceof import_zod15.z.ZodError) {
+    if (error instanceof import_zod16.z.ZodError) {
       console.error(
         "[CLINIC_GROUP] Zod validation error:",
         JSON.stringify(error.errors, null, 2)
@@ -5449,12 +5469,12 @@ var ClinicGroupService = class extends BaseService {
 // src/services/clinic/clinic.service.ts
 var import_firestore21 = require("firebase/firestore");
 var import_geofire_common7 = require("geofire-common");
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/services/clinic/utils/clinic.utils.ts
 var import_firestore18 = require("firebase/firestore");
 var import_geofire_common4 = require("geofire-common");
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 async function getClinic(db, clinicId) {
   const docRef = (0, import_firestore18.doc)(db, CLINICS_COLLECTION, clinicId);
   const docSnap = await (0, import_firestore18.getDoc)(docRef);
@@ -6126,7 +6146,7 @@ var ClinicService = class extends BaseService {
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
     } catch (error) {
-      if (error instanceof import_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         throw new Error("Invalid clinic data: " + error.message);
       }
       console.error("Error creating clinic:", error);
@@ -6174,7 +6194,7 @@ var ClinicService = class extends BaseService {
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
-      if (error instanceof import_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         throw new Error(
           "Invalid clinic update data: " + error.errors.map((e) => `${e.path.join(".")} - ${e.message}`).join(", ")
         );
@@ -6633,7 +6653,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -6806,7 +6826,7 @@ var AuthService = class extends BaseService {
         email
       );
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6929,7 +6949,7 @@ var AuthService = class extends BaseService {
       await emailSchema.parseAsync(email);
       await (0, import_auth5.sendPasswordResetEmail)(this.auth, email);
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6968,7 +6988,7 @@ var AuthService = class extends BaseService {
       await passwordSchema.parseAsync(newPassword);
       await (0, import_auth5.confirmPasswordReset)(this.auth, oobCode, newPassword);
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -7137,7 +7157,7 @@ var AuthService = class extends BaseService {
         practitioner
       };
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpPractitioner:",
           JSON.stringify(error.errors, null, 2)
@@ -7402,59 +7422,59 @@ var import_firestore24 = require("firebase/firestore");
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-var import_zod19 = require("zod");
-var createProcedureSchema = import_zod19.z.object({
-  name: import_zod19.z.string().min(1).max(200),
-  description: import_zod19.z.string().min(1).max(2e3),
-  family: import_zod19.z.nativeEnum(ProcedureFamily),
-  categoryId: import_zod19.z.string().min(1),
-  subcategoryId: import_zod19.z.string().min(1),
-  technologyId: import_zod19.z.string().min(1),
-  productId: import_zod19.z.string().min(1),
-  price: import_zod19.z.number().min(0),
-  currency: import_zod19.z.nativeEnum(Currency),
-  pricingMeasure: import_zod19.z.nativeEnum(PricingMeasure),
-  duration: import_zod19.z.number().min(1).max(480),
+var import_zod20 = require("zod");
+var createProcedureSchema = import_zod20.z.object({
+  name: import_zod20.z.string().min(1).max(200),
+  description: import_zod20.z.string().min(1).max(2e3),
+  family: import_zod20.z.nativeEnum(ProcedureFamily),
+  categoryId: import_zod20.z.string().min(1),
+  subcategoryId: import_zod20.z.string().min(1),
+  technologyId: import_zod20.z.string().min(1),
+  productId: import_zod20.z.string().min(1),
+  price: import_zod20.z.number().min(0),
+  currency: import_zod20.z.nativeEnum(Currency),
+  pricingMeasure: import_zod20.z.nativeEnum(PricingMeasure),
+  duration: import_zod20.z.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: import_zod19.z.string().min(1),
-  clinicBranchId: import_zod19.z.string().min(1)
+  practitionerId: import_zod20.z.string().min(1),
+  clinicBranchId: import_zod20.z.string().min(1)
 });
-var updateProcedureSchema = import_zod19.z.object({
-  name: import_zod19.z.string().min(3).max(100).optional(),
-  description: import_zod19.z.string().min(3).max(1e3).optional(),
-  price: import_zod19.z.number().min(0).optional(),
-  currency: import_zod19.z.nativeEnum(Currency).optional(),
-  pricingMeasure: import_zod19.z.nativeEnum(PricingMeasure).optional(),
-  duration: import_zod19.z.number().min(0).optional(),
-  isActive: import_zod19.z.boolean().optional(),
-  practitionerId: import_zod19.z.string().optional(),
-  categoryId: import_zod19.z.string().optional(),
-  subcategoryId: import_zod19.z.string().optional(),
-  technologyId: import_zod19.z.string().optional(),
-  productId: import_zod19.z.string().optional(),
-  clinicBranchId: import_zod19.z.string().optional()
+var updateProcedureSchema = import_zod20.z.object({
+  name: import_zod20.z.string().min(3).max(100).optional(),
+  description: import_zod20.z.string().min(3).max(1e3).optional(),
+  price: import_zod20.z.number().min(0).optional(),
+  currency: import_zod20.z.nativeEnum(Currency).optional(),
+  pricingMeasure: import_zod20.z.nativeEnum(PricingMeasure).optional(),
+  duration: import_zod20.z.number().min(0).optional(),
+  isActive: import_zod20.z.boolean().optional(),
+  practitionerId: import_zod20.z.string().optional(),
+  categoryId: import_zod20.z.string().optional(),
+  subcategoryId: import_zod20.z.string().optional(),
+  technologyId: import_zod20.z.string().optional(),
+  productId: import_zod20.z.string().optional(),
+  clinicBranchId: import_zod20.z.string().optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: import_zod19.z.string().min(1),
-  category: import_zod19.z.any(),
+  id: import_zod20.z.string().min(1),
+  category: import_zod20.z.any(),
   // We'll validate the full category object separately
-  subcategory: import_zod19.z.any(),
+  subcategory: import_zod20.z.any(),
   // We'll validate the full subcategory object separately
-  technology: import_zod19.z.any(),
+  technology: import_zod20.z.any(),
   // We'll validate the full technology object separately
-  product: import_zod19.z.any(),
+  product: import_zod20.z.any(),
   // We'll validate the full product object separately
-  blockingConditions: import_zod19.z.array(import_zod19.z.any()),
+  blockingConditions: import_zod20.z.array(import_zod20.z.any()),
   // We'll validate blocking conditions separately
-  treatmentBenefits: import_zod19.z.array(import_zod19.z.any()),
+  treatmentBenefits: import_zod20.z.array(import_zod20.z.any()),
   // We'll validate treatment benefits separately
-  preRequirements: import_zod19.z.array(import_zod19.z.any()),
+  preRequirements: import_zod20.z.array(import_zod20.z.any()),
   // We'll validate requirements separately
-  postRequirements: import_zod19.z.array(import_zod19.z.any()),
+  postRequirements: import_zod20.z.array(import_zod20.z.any()),
   // We'll validate requirements separately
-  certificationRequirement: import_zod19.z.any(),
+  certificationRequirement: import_zod20.z.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: import_zod19.z.array(import_zod19.z.any()),
+  documentationTemplates: import_zod20.z.array(import_zod20.z.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -7462,9 +7482,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: import_zod19.z.boolean(),
-  createdAt: import_zod19.z.date(),
-  updatedAt: import_zod19.z.date()
+  isActive: import_zod20.z.boolean(),
+  createdAt: import_zod20.z.date(),
+  updatedAt: import_zod20.z.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -8499,42 +8519,42 @@ var SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 var import_firestore37 = require("firebase/firestore");
 
 // src/validations/calendar.schema.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var import_firestore28 = require("firebase/firestore");
 
 // src/validations/profile-info.schema.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var import_firestore27 = require("firebase/firestore");
-var clinicInfoSchema2 = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  featuredPhoto: import_zod20.z.string(),
-  name: import_zod20.z.string(),
-  description: import_zod20.z.string(),
+var clinicInfoSchema2 = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  featuredPhoto: import_zod21.z.string(),
+  name: import_zod21.z.string(),
+  description: import_zod21.z.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var practitionerProfileInfoSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  practitionerPhoto: import_zod20.z.string().nullable(),
-  name: import_zod20.z.string(),
-  email: import_zod20.z.string().email(),
-  phone: import_zod20.z.string().nullable(),
+var practitionerProfileInfoSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  practitionerPhoto: import_zod21.z.string().nullable(),
+  name: import_zod21.z.string(),
+  email: import_zod21.z.string().email(),
+  phone: import_zod21.z.string().nullable(),
   certification: practitionerCertificationSchema
 });
-var patientProfileInfoSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  fullName: import_zod20.z.string(),
-  email: import_zod20.z.string().email(),
-  phone: import_zod20.z.string().nullable(),
-  dateOfBirth: import_zod20.z.instanceof(import_firestore27.Timestamp),
-  gender: import_zod20.z.nativeEnum(Gender)
+var patientProfileInfoSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  fullName: import_zod21.z.string(),
+  email: import_zod21.z.string().email(),
+  phone: import_zod21.z.string().nullable(),
+  dateOfBirth: import_zod21.z.instanceof(import_firestore27.Timestamp),
+  gender: import_zod21.z.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = import_zod21.z.object({
-  start: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore28.Timestamp)),
-  end: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore28.Timestamp))
+var calendarEventTimeSchema = import_zod22.z.object({
+  start: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore28.Timestamp)),
+  end: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore28.Timestamp))
 }).refine(
   (data) => {
     const startDate = data.start instanceof import_firestore28.Timestamp ? data.start.toDate() : data.start;
@@ -8555,46 +8575,46 @@ var calendarEventTimeSchema = import_zod21.z.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = import_zod21.z.object({
-  start: import_zod21.z.date(),
-  end: import_zod21.z.date(),
-  isAvailable: import_zod21.z.boolean()
+var timeSlotSchema2 = import_zod22.z.object({
+  start: import_zod22.z.date(),
+  end: import_zod22.z.date(),
+  isAvailable: import_zod22.z.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-var syncedCalendarEventSchema = import_zod21.z.object({
-  eventId: import_zod21.z.string(),
-  syncedCalendarProvider: import_zod21.z.nativeEnum(SyncedCalendarProvider),
-  syncedAt: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore28.Timestamp))
+var syncedCalendarEventSchema = import_zod22.z.object({
+  eventId: import_zod22.z.string(),
+  syncedCalendarProvider: import_zod22.z.nativeEnum(SyncedCalendarProvider),
+  syncedAt: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore28.Timestamp))
 });
-var procedureInfoSchema = import_zod21.z.object({
-  name: import_zod21.z.string(),
-  description: import_zod21.z.string(),
-  duration: import_zod21.z.number().min(MIN_APPOINTMENT_DURATION),
-  price: import_zod21.z.number().min(0),
-  currency: import_zod21.z.nativeEnum(Currency)
+var procedureInfoSchema = import_zod22.z.object({
+  name: import_zod22.z.string(),
+  description: import_zod22.z.string(),
+  duration: import_zod22.z.number().min(MIN_APPOINTMENT_DURATION),
+  price: import_zod22.z.number().min(0),
+  currency: import_zod22.z.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = import_zod21.z.object({
-  procedureFamily: import_zod21.z.string(),
+var procedureCategorizationSchema = import_zod22.z.object({
+  procedureFamily: import_zod22.z.string(),
   // Replace with proper enum when available
-  procedureCategory: import_zod21.z.string(),
+  procedureCategory: import_zod22.z.string(),
   // Replace with proper enum when available
-  procedureSubcategory: import_zod21.z.string(),
+  procedureSubcategory: import_zod22.z.string(),
   // Replace with proper enum when available
-  procedureTechnology: import_zod21.z.string(),
+  procedureTechnology: import_zod22.z.string(),
   // Replace with proper enum when available
-  procedureProduct: import_zod21.z.string()
+  procedureProduct: import_zod22.z.string()
   // Replace with proper enum when available
 });
-var createAppointmentSchema2 = import_zod21.z.object({
-  clinicId: import_zod21.z.string().min(1, "Clinic ID is required"),
-  doctorId: import_zod21.z.string().min(1, "Doctor ID is required"),
-  patientId: import_zod21.z.string().min(1, "Patient ID is required"),
-  procedureId: import_zod21.z.string().min(1, "Procedure ID is required"),
+var createAppointmentSchema2 = import_zod22.z.object({
+  clinicId: import_zod22.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod22.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod22.z.string().min(1, "Patient ID is required"),
+  procedureId: import_zod22.z.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: import_zod21.z.string().optional()
+  description: import_zod22.z.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -8603,73 +8623,73 @@ var createAppointmentSchema2 = import_zod21.z.object({
     message: "Invalid appointment parameters"
   }
 );
-var updateAppointmentSchema2 = import_zod21.z.object({
-  appointmentId: import_zod21.z.string().min(1, "Appointment ID is required"),
-  clinicId: import_zod21.z.string().min(1, "Clinic ID is required"),
-  doctorId: import_zod21.z.string().min(1, "Doctor ID is required"),
-  patientId: import_zod21.z.string().min(1, "Patient ID is required"),
+var updateAppointmentSchema2 = import_zod22.z.object({
+  appointmentId: import_zod22.z.string().min(1, "Appointment ID is required"),
+  clinicId: import_zod22.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod22.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod22.z.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod21.z.string().optional(),
-  status: import_zod21.z.nativeEnum(CalendarEventStatus).optional()
+  description: import_zod22.z.string().optional(),
+  status: import_zod22.z.nativeEnum(CalendarEventStatus).optional()
 });
-var createCalendarEventSchema = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  clinicBranchId: import_zod21.z.string().nullable().optional(),
-  clinicBranchInfo: import_zod21.z.any().nullable().optional(),
-  practitionerProfileId: import_zod21.z.string().nullable().optional(),
+var createCalendarEventSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  clinicBranchId: import_zod22.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod22.z.any().nullable().optional(),
+  practitionerProfileId: import_zod22.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod21.z.string().nullable().optional(),
+  patientProfileId: import_zod22.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod21.z.string().nullable().optional(),
-  appointmentId: import_zod21.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod21.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod21.z.string().min(1, "Event name is required"),
+  procedureId: import_zod22.z.string().nullable().optional(),
+  appointmentId: import_zod22.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod22.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod22.z.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: import_zod21.z.string().optional(),
-  status: import_zod21.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod21.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod21.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod21.z.any(),
+  description: import_zod22.z.string().optional(),
+  status: import_zod22.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod22.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod22.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod22.z.any(),
   // FieldValue for server timestamp
-  updatedAt: import_zod21.z.any()
+  updatedAt: import_zod22.z.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = import_zod21.z.object({
-  syncedCalendarEventId: import_zod21.z.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: import_zod21.z.string().nullable().optional(),
-  eventName: import_zod21.z.string().optional(),
+var updateCalendarEventSchema = import_zod22.z.object({
+  syncedCalendarEventId: import_zod22.z.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: import_zod22.z.string().nullable().optional(),
+  eventName: import_zod22.z.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod21.z.string().optional(),
-  status: import_zod21.z.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: import_zod21.z.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: import_zod21.z.nativeEnum(CalendarEventType).optional(),
-  updatedAt: import_zod21.z.any()
+  description: import_zod22.z.string().optional(),
+  status: import_zod22.z.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: import_zod22.z.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: import_zod22.z.nativeEnum(CalendarEventType).optional(),
+  updatedAt: import_zod22.z.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  clinicBranchId: import_zod21.z.string().nullable().optional(),
-  clinicBranchInfo: import_zod21.z.any().nullable().optional(),
+var calendarEventSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  clinicBranchId: import_zod22.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod22.z.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: import_zod21.z.string().nullable().optional(),
+  practitionerProfileId: import_zod22.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod21.z.string().nullable().optional(),
+  patientProfileId: import_zod22.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod21.z.string().nullable().optional(),
+  procedureId: import_zod22.z.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: import_zod21.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod21.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod21.z.string(),
+  appointmentId: import_zod22.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod22.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod22.z.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: import_zod21.z.string().optional(),
-  status: import_zod21.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod21.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod21.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore28.Timestamp)),
-  updatedAt: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore28.Timestamp))
+  description: import_zod22.z.string().optional(),
+  status: import_zod22.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod22.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod22.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore28.Timestamp)),
+  updatedAt: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore28.Timestamp))
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -11207,7 +11227,7 @@ var import_firestore38 = require("firebase/firestore");
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -11313,7 +11333,7 @@ var ReviewService = class extends BaseService {
       await Promise.all(updatePromises);
       return review;
     } catch (error) {
-      if (error instanceof import_zod22.z.ZodError) {
+      if (error instanceof import_zod23.z.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -13576,54 +13596,54 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-var import_zod23 = require("zod");
-var baseNotificationSchema = import_zod23.z.object({
-  id: import_zod23.z.string().optional(),
-  userId: import_zod23.z.string(),
-  notificationTime: import_zod23.z.any(),
+var import_zod24 = require("zod");
+var baseNotificationSchema = import_zod24.z.object({
+  id: import_zod24.z.string().optional(),
+  userId: import_zod24.z.string(),
+  notificationTime: import_zod24.z.any(),
   // Timestamp
-  notificationType: import_zod23.z.nativeEnum(NotificationType),
-  notificationTokens: import_zod23.z.array(import_zod23.z.string()),
-  status: import_zod23.z.nativeEnum(NotificationStatus),
-  createdAt: import_zod23.z.any().optional(),
+  notificationType: import_zod24.z.nativeEnum(NotificationType),
+  notificationTokens: import_zod24.z.array(import_zod24.z.string()),
+  status: import_zod24.z.nativeEnum(NotificationStatus),
+  createdAt: import_zod24.z.any().optional(),
   // Timestamp
-  updatedAt: import_zod23.z.any().optional(),
+  updatedAt: import_zod24.z.any().optional(),
   // Timestamp
-  title: import_zod23.z.string(),
-  body: import_zod23.z.string(),
-  isRead: import_zod23.z.boolean(),
-  userRole: import_zod23.z.nativeEnum(UserRole)
+  title: import_zod24.z.string(),
+  body: import_zod24.z.string(),
+  isRead: import_zod24.z.boolean(),
+  userRole: import_zod24.z.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod23.z.literal("preRequirement" /* PRE_REQUIREMENT */),
-  treatmentId: import_zod23.z.string(),
-  requirements: import_zod23.z.array(import_zod23.z.string()),
-  deadline: import_zod23.z.any()
+  notificationType: import_zod24.z.literal("preRequirement" /* PRE_REQUIREMENT */),
+  treatmentId: import_zod24.z.string(),
+  requirements: import_zod24.z.array(import_zod24.z.string()),
+  deadline: import_zod24.z.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod23.z.literal("postRequirement" /* POST_REQUIREMENT */),
-  treatmentId: import_zod23.z.string(),
-  requirements: import_zod23.z.array(import_zod23.z.string()),
-  deadline: import_zod23.z.any()
+  notificationType: import_zod24.z.literal("postRequirement" /* POST_REQUIREMENT */),
+  treatmentId: import_zod24.z.string(),
+  requirements: import_zod24.z.array(import_zod24.z.string()),
+  deadline: import_zod24.z.any()
   // Timestamp
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod23.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: import_zod23.z.string(),
-  appointmentTime: import_zod23.z.any(),
+  notificationType: import_zod24.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: import_zod24.z.string(),
+  appointmentTime: import_zod24.z.any(),
   // Timestamp
-  treatmentType: import_zod23.z.string(),
-  doctorName: import_zod23.z.string()
+  treatmentType: import_zod24.z.string(),
+  doctorName: import_zod24.z.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod23.z.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
-  appointmentId: import_zod23.z.string(),
-  appointmentStatus: import_zod23.z.string(),
-  previousStatus: import_zod23.z.string(),
-  reason: import_zod23.z.string().optional()
+  notificationType: import_zod24.z.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  appointmentId: import_zod24.z.string(),
+  appointmentStatus: import_zod24.z.string(),
+  previousStatus: import_zod24.z.string(),
+  reason: import_zod24.z.string().optional()
 });
-var notificationSchema = import_zod23.z.discriminatedUnion("notificationType", [
+var notificationSchema = import_zod24.z.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   appointmentReminderNotificationSchema,
@@ -13764,7 +13784,6 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   clinicContactInfoSchema,
   clinicGroupSchema,
   clinicGroupSetupSchema,
-  clinicInfoSchema,
   clinicLocationSchema,
   clinicReviewInfoSchema,
   clinicReviewSchema,
@@ -13792,7 +13811,6 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   createProcedureReviewSchema,
   createReviewSchema,
   createUserOptionsSchema,
-  doctorInfoSchema,
   documentElementSchema,
   documentElementWithoutIdSchema,
   documentTemplateSchema,
@@ -13831,7 +13849,6 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   procedureInfoSchema,
   procedureReviewInfoSchema,
   procedureReviewSchema,
-  procedureSummaryInfoSchema,
   requesterInfoSchema,
   reviewSchema,
   searchAppointmentsSchema,