@blackcode_sa/metaestetics-api 1.6.1 → 1.6.3

package/dist/index.mjs

@@ -255,7 +255,7 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/validations/schemas.ts
 import { z as z3 } from "zod";
@@ -792,7 +792,7 @@ var USER_ERRORS = {
 };
 
 // src/services/user.service.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/services/patient/patient.service.ts
 import {
@@ -2160,6 +2160,51 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
     );
   }
 };
+var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, options) => {
+  try {
+    console.log(
+      `[getPatientsByPractitionerWithDetailsUtil] Fetching detailed patient profiles for practitioner ID: ${practitionerId} with options:`,
+      options
+    );
+    const patientProfiles = await getPatientsByPractitionerUtil(
+      db,
+      practitionerId,
+      options
+    );
+    const patientProfilesWithDetails = await Promise.all(
+      patientProfiles.map(async (profile) => {
+        try {
+          const sensitiveInfoDoc = await getDoc7(
+            getSensitiveInfoDocRef(db, profile.id)
+          );
+          const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
+          return {
+            patientProfile: profile,
+            patientSensitiveInfo: sensitiveInfo
+          };
+        } catch (error) {
+          console.error(
+            `[getPatientsByPractitionerWithDetailsUtil] Error fetching sensitive info for patient ${profile.id}:`,
+            error
+          );
+          return { patientProfile: profile };
+        }
+      })
+    );
+    console.log(
+      `[getPatientsByPractitionerWithDetailsUtil] Found ${patientProfilesWithDetails.length} detailed patient profiles for practitioner ID: ${practitionerId}`
+    );
+    return patientProfilesWithDetails;
+  } catch (error) {
+    console.error(
+      `[getPatientsByPractitionerWithDetailsUtil] Error fetching detailed patient profiles:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve detailed patient profiles: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
 
 // src/services/patient/utils/clinic.utils.ts
 import {
@@ -2497,6 +2542,25 @@ var PatientService = class extends BaseService {
     );
     return getPatientsByPractitionerUtil(this.db, practitionerId, options);
   }
+  /**
+   * Gets all patients associated with a specific practitioner with their sensitive information.
+   *
+   * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
+   * @param {Object} options - Optional parameters for pagination
+   * @param {number} options.limit - Maximum number of profiles to return
+   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+   * @returns {Promise<PatientProfileForDoctor[]>} A promise resolving to an array of patient profiles with sensitive info
+   */
+  async getPatientsByPractitionerWithDetails(practitionerId, options) {
+    console.log(
+      `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`
+    );
+    return getPatientsByPractitionerWithDetailsUtil(
+      this.db,
+      practitionerId,
+      options
+    );
+  }
   /**
    * Gets all patients associated with a specific clinic.
    *
@@ -2525,7 +2589,7 @@ import {
   updateDoc as updateDoc7,
   setDoc as setDoc6,
   deleteDoc,
-  Timestamp as Timestamp7,
+  Timestamp as Timestamp6,
   serverTimestamp as serverTimestamp8
 } from "firebase/firestore";
 
@@ -2654,52 +2718,8 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 
 // src/validations/clinic.schema.ts
 import { z as z12 } from "zod";
-import { Timestamp as Timestamp6 } from "firebase/firestore";
-
-// src/validations/practitioner.schema.ts
-import { z as z11 } from "zod";
 import { Timestamp as Timestamp5 } from "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
 import { z as z10 } from "zod";
 var baseReviewSchema = z10.object({
@@ -2833,6 +2853,9 @@ var createReviewSchema = z10.object({
   }
 );
 
+// src/validations/shared.schema.ts
+import { z as z11 } from "zod";
+
 // src/backoffice/types/static/procedure-family.types.ts
 var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
   ProcedureFamily2["AESTHETICS"] = "aesthetics";
@@ -2859,59 +2882,21 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
   return Currency2;
 })(Currency || {});
 
-// src/validations/practitioner.schema.ts
-var practitionerBasicInfoSchema = z11.object({
-  firstName: z11.string().min(2).max(50),
-  lastName: z11.string().min(2).max(50),
-  title: z11.string().min(2).max(100),
+// src/validations/shared.schema.ts
+var sharedClinicContactInfoSchema = z11.object({
   email: z11.string().email(),
-  phoneNumber: z11.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: z11.instanceof(Timestamp5).or(z11.date()),
-  gender: z11.enum(["male", "female", "other"]),
-  profileImageUrl: z11.string().url().optional(),
-  bio: z11.string().max(1e3).optional(),
-  languages: z11.array(z11.string()).min(1)
-});
-var practitionerCertificationSchema = z11.object({
-  level: z11.nativeEnum(CertificationLevel),
-  specialties: z11.array(z11.nativeEnum(CertificationSpecialty)),
-  licenseNumber: z11.string().min(3).max(50),
-  issuingAuthority: z11.string().min(2).max(100),
-  issueDate: z11.instanceof(Timestamp5).or(z11.date()),
-  expiryDate: z11.instanceof(Timestamp5).or(z11.date()).optional(),
-  verificationStatus: z11.enum(["pending", "verified", "rejected"])
-});
-var timeSlotSchema = z11.object({
-  start: z11.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
-  end: z11.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
-}).nullable();
-var practitionerWorkingHoursSchema = z11.object({
-  practitionerId: z11.string().min(1),
-  clinicId: z11.string().min(1),
-  monday: timeSlotSchema,
-  tuesday: timeSlotSchema,
-  wednesday: timeSlotSchema,
-  thursday: timeSlotSchema,
-  friday: timeSlotSchema,
-  saturday: timeSlotSchema,
-  sunday: timeSlotSchema,
-  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
-  updatedAt: z11.instanceof(Timestamp5).or(z11.date())
+  phoneNumber: z11.string(),
+  alternativePhoneNumber: z11.string().nullable().optional(),
+  website: z11.string().nullable().optional()
 });
-var practitionerClinicWorkingHoursSchema = z11.object({
-  clinicId: z11.string().min(1),
-  workingHours: z11.object({
-    monday: timeSlotSchema,
-    tuesday: timeSlotSchema,
-    wednesday: timeSlotSchema,
-    thursday: timeSlotSchema,
-    friday: timeSlotSchema,
-    saturday: timeSlotSchema,
-    sunday: timeSlotSchema
-  }),
-  isActive: z11.boolean(),
-  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
-  updatedAt: z11.instanceof(Timestamp5).or(z11.date())
+var sharedClinicLocationSchema = z11.object({
+  address: z11.string(),
+  city: z11.string(),
+  country: z11.string(),
+  postalCode: z11.string(),
+  latitude: z11.number().min(-90).max(90),
+  longitude: z11.number().min(-180).max(180),
+  geohash: z11.string().nullable().optional()
 });
 var procedureSummaryInfoSchema = z11.object({
   id: z11.string().min(1),
@@ -2931,79 +2916,22 @@ var procedureSummaryInfoSchema = z11.object({
   practitionerId: z11.string().min(1),
   practitionerName: z11.string().min(1)
 });
-var practitionerSchema = z11.object({
-  id: z11.string().min(1),
-  userRef: z11.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: z11.array(z11.string()),
-  clinicWorkingHours: z11.array(practitionerClinicWorkingHoursSchema),
-  clinicsInfo: z11.array(clinicInfoSchema),
-  procedures: z11.array(z11.string()),
-  proceduresInfo: z11.array(procedureSummaryInfoSchema),
-  reviewInfo: practitionerReviewInfoSchema,
-  isActive: z11.boolean(),
-  isVerified: z11.boolean(),
-  status: z11.nativeEnum(PractitionerStatus),
-  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
-  updatedAt: z11.instanceof(Timestamp5).or(z11.date())
+var clinicInfoSchema = z11.object({
+  id: z11.string(),
+  featuredPhoto: z11.string(),
+  name: z11.string(),
+  description: z11.string().nullable().optional(),
+  location: sharedClinicLocationSchema,
+  contactInfo: sharedClinicContactInfoSchema
 });
-var createPractitionerSchema = z11.object({
-  userRef: z11.string().min(1),
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: z11.array(z11.string()).optional(),
-  clinicWorkingHours: z11.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: z11.array(clinicInfoSchema).optional(),
-  proceduresInfo: z11.array(procedureSummaryInfoSchema).optional(),
-  isActive: z11.boolean(),
-  isVerified: z11.boolean(),
-  status: z11.nativeEnum(PractitionerStatus).optional()
-});
-var createDraftPractitionerSchema = z11.object({
-  basicInfo: practitionerBasicInfoSchema,
-  certification: practitionerCertificationSchema,
-  clinics: z11.array(z11.string()).optional(),
-  clinicWorkingHours: z11.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: z11.array(clinicInfoSchema).optional(),
-  proceduresInfo: z11.array(procedureSummaryInfoSchema).optional(),
-  isActive: z11.boolean().optional().default(false),
-  isVerified: z11.boolean().optional().default(false)
-});
-var practitionerTokenSchema = z11.object({
-  id: z11.string().min(1),
-  token: z11.string().min(6),
-  practitionerId: z11.string().min(1),
-  email: z11.string().email(),
-  clinicId: z11.string().min(1),
-  status: z11.nativeEnum(PractitionerTokenStatus),
-  createdBy: z11.string().min(1),
-  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
-  expiresAt: z11.instanceof(Timestamp5).or(z11.date()),
-  usedBy: z11.string().optional(),
-  usedAt: z11.instanceof(Timestamp5).or(z11.date()).optional()
-});
-var createPractitionerTokenSchema = z11.object({
-  practitionerId: z11.string().min(1),
-  email: z11.string().email(),
-  clinicId: z11.string().min(1),
-  expiresAt: z11.date().optional()
-});
-var practitionerSignupSchema = z11.object({
-  email: z11.string().email(),
-  password: z11.string().min(8),
-  firstName: z11.string().min(2).max(50),
-  lastName: z11.string().min(2).max(50),
-  token: z11.string().optional(),
-  profileData: z11.object({
-    basicInfo: z11.object({
-      phoneNumber: z11.string().optional(),
-      profileImageUrl: z11.string().optional(),
-      gender: z11.enum(["male", "female", "other"]).optional(),
-      bio: z11.string().optional()
-    }).optional(),
-    certification: z11.any().optional()
-  }).optional()
+var doctorInfoSchema = z11.object({
+  id: z11.string(),
+  name: z11.string(),
+  description: z11.string().nullable().optional(),
+  photo: z11.string(),
+  rating: z11.number().min(0).max(5),
+  services: z11.array(z11.string())
+  // List of procedure IDs practitioner offers
 });
 
 // src/validations/clinic.schema.ts
@@ -3056,23 +2984,6 @@ var adminInfoSchema = z12.object({
   name: z12.string(),
   email: z12.string().email()
 });
-var clinicInfoSchema = z12.object({
-  id: z12.string(),
-  featuredPhoto: z12.string(),
-  name: z12.string(),
-  description: z12.string().nullable().optional(),
-  location: clinicLocationSchema,
-  contactInfo: clinicContactInfoSchema
-});
-var doctorInfoSchema = z12.object({
-  id: z12.string(),
-  name: z12.string(),
-  description: z12.string().nullable().optional(),
-  photo: z12.string(),
-  rating: z12.number().min(0).max(5),
-  services: z12.array(z12.string())
-  // List of procedure IDs practitioner offers
-});
 var clinicAdminSchema = z12.object({
   id: z12.string(),
   userRef: z12.string(),
@@ -3082,8 +2993,8 @@ var clinicAdminSchema = z12.object({
   clinicsManagedInfo: z12.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
   roleTitle: z12.string(),
-  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
-  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
+  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
   isActive: z12.boolean()
 });
 var adminTokenSchema = z12.object({
@@ -3092,9 +3003,9 @@ var adminTokenSchema = z12.object({
   email: z12.string().email().optional().nullable(),
   status: z12.nativeEnum(AdminTokenStatus),
   usedByUserRef: z12.string().optional(),
-  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
   // Timestamp
-  expiresAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6))
+  expiresAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5))
   // Timestamp
 });
 var createAdminTokenSchema = z12.object({
@@ -3114,9 +3025,9 @@ var clinicGroupSchema = z12.object({
   adminsInfo: z12.array(adminInfoSchema),
   adminTokens: z12.array(adminTokenSchema),
   ownerId: z12.string().nullable(),
-  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
   // Timestamp
-  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
   // Timestamp
   isActive: z12.boolean(),
   logo: z12.string().optional().nullable(),
@@ -3156,9 +3067,9 @@ var clinicSchema = z12.object({
   // servicesInfo: z.array(serviceInfoSchema), // Deprecated, use proceduresInfo
   reviewInfo: clinicReviewInfoSchema,
   admins: z12.array(z12.string()),
-  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
   // Timestamp
-  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp5)),
   // Timestamp
   isActive: z12.boolean(),
   isVerified: z12.boolean(),
@@ -3368,8 +3279,8 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: Timestamp7.now(),
-      updatedAt: Timestamp7.now()
+      createdAt: Timestamp6.now(),
+      updatedAt: Timestamp6.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -3738,7 +3649,182 @@ import {
   arrayUnion as arrayUnion5,
   arrayRemove as arrayRemove4
 } from "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
 import { z as z13 } from "zod";
+import { Timestamp as Timestamp7 } from "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 = z13.object({
+  firstName: z13.string().min(2).max(50),
+  lastName: z13.string().min(2).max(50),
+  title: z13.string().min(2).max(100),
+  email: z13.string().email(),
+  phoneNumber: z13.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
+  dateOfBirth: z13.instanceof(Timestamp7).or(z13.date()),
+  gender: z13.enum(["male", "female", "other"]),
+  profileImageUrl: z13.string().url().optional(),
+  bio: z13.string().max(1e3).optional(),
+  languages: z13.array(z13.string()).min(1)
+});
+var practitionerCertificationSchema = z13.object({
+  level: z13.nativeEnum(CertificationLevel),
+  specialties: z13.array(z13.nativeEnum(CertificationSpecialty)),
+  licenseNumber: z13.string().min(3).max(50),
+  issuingAuthority: z13.string().min(2).max(100),
+  issueDate: z13.instanceof(Timestamp7).or(z13.date()),
+  expiryDate: z13.instanceof(Timestamp7).or(z13.date()).optional(),
+  verificationStatus: z13.enum(["pending", "verified", "rejected"])
+});
+var timeSlotSchema = z13.object({
+  start: z13.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: z13.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
+}).nullable();
+var practitionerWorkingHoursSchema = z13.object({
+  practitionerId: z13.string().min(1),
+  clinicId: z13.string().min(1),
+  monday: timeSlotSchema,
+  tuesday: timeSlotSchema,
+  wednesday: timeSlotSchema,
+  thursday: timeSlotSchema,
+  friday: timeSlotSchema,
+  saturday: timeSlotSchema,
+  sunday: timeSlotSchema,
+  createdAt: z13.instanceof(Timestamp7).or(z13.date()),
+  updatedAt: z13.instanceof(Timestamp7).or(z13.date())
+});
+var practitionerClinicWorkingHoursSchema = z13.object({
+  clinicId: z13.string().min(1),
+  workingHours: z13.object({
+    monday: timeSlotSchema,
+    tuesday: timeSlotSchema,
+    wednesday: timeSlotSchema,
+    thursday: timeSlotSchema,
+    friday: timeSlotSchema,
+    saturday: timeSlotSchema,
+    sunday: timeSlotSchema
+  }),
+  isActive: z13.boolean(),
+  createdAt: z13.instanceof(Timestamp7).or(z13.date()),
+  updatedAt: z13.instanceof(Timestamp7).or(z13.date())
+});
+var practitionerSchema = z13.object({
+  id: z13.string().min(1),
+  userRef: z13.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z13.array(z13.string()),
+  clinicWorkingHours: z13.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: z13.array(clinicInfoSchema),
+  procedures: z13.array(z13.string()),
+  proceduresInfo: z13.array(procedureSummaryInfoSchema),
+  reviewInfo: practitionerReviewInfoSchema,
+  isActive: z13.boolean(),
+  isVerified: z13.boolean(),
+  status: z13.nativeEnum(PractitionerStatus),
+  createdAt: z13.instanceof(Timestamp7).or(z13.date()),
+  updatedAt: z13.instanceof(Timestamp7).or(z13.date())
+});
+var createPractitionerSchema = z13.object({
+  userRef: z13.string().min(1),
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z13.array(z13.string()).optional(),
+  clinicWorkingHours: z13.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: z13.array(clinicInfoSchema).optional(),
+  proceduresInfo: z13.array(procedureSummaryInfoSchema).optional(),
+  isActive: z13.boolean(),
+  isVerified: z13.boolean(),
+  status: z13.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = z13.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z13.array(z13.string()).optional(),
+  clinicWorkingHours: z13.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: z13.array(clinicInfoSchema).optional(),
+  proceduresInfo: z13.array(procedureSummaryInfoSchema).optional(),
+  isActive: z13.boolean().optional().default(false),
+  isVerified: z13.boolean().optional().default(false)
+});
+var practitionerTokenSchema = z13.object({
+  id: z13.string().min(1),
+  token: z13.string().min(6),
+  practitionerId: z13.string().min(1),
+  email: z13.string().email(),
+  clinicId: z13.string().min(1),
+  status: z13.nativeEnum(PractitionerTokenStatus),
+  createdBy: z13.string().min(1),
+  createdAt: z13.instanceof(Timestamp7).or(z13.date()),
+  expiresAt: z13.instanceof(Timestamp7).or(z13.date()),
+  usedBy: z13.string().optional(),
+  usedAt: z13.instanceof(Timestamp7).or(z13.date()).optional()
+});
+var createPractitionerTokenSchema = z13.object({
+  practitionerId: z13.string().min(1),
+  email: z13.string().email(),
+  clinicId: z13.string().min(1),
+  expiresAt: z13.date().optional()
+});
+var practitionerSignupSchema = z13.object({
+  email: z13.string().email(),
+  password: z13.string().min(8),
+  firstName: z13.string().min(2).max(50),
+  lastName: z13.string().min(2).max(50),
+  token: z13.string().optional(),
+  profileData: z13.object({
+    basicInfo: z13.object({
+      phoneNumber: z13.string().optional(),
+      profileImageUrl: z13.string().optional(),
+      gender: z13.enum(["male", "female", "other"]).optional(),
+      bio: z13.string().optional()
+    }).optional(),
+    certification: z13.any().optional()
+  }).optional()
+});
+
+// src/services/practitioner/practitioner.service.ts
+import { z as z14 } from "zod";
 import { distanceBetween } from "geofire-common";
 var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService) {
@@ -3807,7 +3893,7 @@ var PractitionerService = class extends BaseService {
       }
       return createdPractitioner;
     } catch (error) {
-      if (error instanceof z13.ZodError) {
+      if (error instanceof z14.ZodError) {
         throw new Error(`Invalid practitioner data: ${error.message}`);
       }
       console.error("Error creating practitioner:", error);
@@ -3862,7 +3948,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
           });
         }
@@ -3919,7 +4006,7 @@ var PractitionerService = class extends BaseService {
       await setDoc7(doc8(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
-      if (error instanceof z13.ZodError) {
+      if (error instanceof z14.ZodError) {
         throw new Error("Invalid practitioner data: " + error.message);
       }
       throw error;
@@ -3972,7 +4059,7 @@ var PractitionerService = class extends BaseService {
       await setDoc7(doc8(this.db, tokenPath), token);
       return token;
     } catch (error) {
-      if (error instanceof z13.ZodError) {
+      if (error instanceof z14.ZodError) {
         throw new Error("Invalid token data: " + error.message);
       }
       throw error;
@@ -4132,7 +4219,7 @@ var PractitionerService = class extends BaseService {
       }
       return updatedPractitioner;
     } catch (error) {
-      if (error instanceof z13.ZodError) {
+      if (error instanceof z14.ZodError) {
         throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
       console.error(`Error updating practitioner ${practitionerId}:`, error);
@@ -4660,7 +4747,7 @@ var UserService = class extends BaseService {
       });
       return this.getUserById(uid);
     } catch (error) {
-      if (error instanceof z14.ZodError) {
+      if (error instanceof z15.ZodError) {
         throw USER_ERRORS.VALIDATION_ERROR;
       }
       throw error;
@@ -4757,7 +4844,7 @@ import {
   Timestamp as Timestamp10
 } from "firebase/firestore";
 import { geohashForLocation as geohashForLocation2 } from "geofire-common";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/services/clinic/utils/photos.utils.ts
 import {
@@ -4961,7 +5048,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     });
     return groupData;
   } catch (error) {
-    if (error instanceof z15.ZodError) {
+    if (error instanceof z16.ZodError) {
       console.error(
         "[CLINIC_GROUP] Zod validation error:",
         JSON.stringify(error.errors, null, 2)
@@ -5376,7 +5463,7 @@ import {
 import {
   geohashForLocation as geohashForLocation4
 } from "geofire-common";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/services/clinic/utils/clinic.utils.ts
 import {
@@ -5397,7 +5484,7 @@ import {
   distanceBetween as distanceBetween2,
   geohashQueryBounds
 } from "geofire-common";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 async function getClinic(db, clinicId) {
   const docRef = doc11(db, CLINICS_COLLECTION, clinicId);
   const docSnap = await getDoc14(docRef);
@@ -6082,7 +6169,7 @@ var ClinicService = class extends BaseService {
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
     } catch (error) {
-      if (error instanceof z17.ZodError) {
+      if (error instanceof z18.ZodError) {
         throw new Error("Invalid clinic data: " + error.message);
       }
       console.error("Error creating clinic:", error);
@@ -6130,7 +6217,7 @@ var ClinicService = class extends BaseService {
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
-      if (error instanceof z17.ZodError) {
+      if (error instanceof z18.ZodError) {
         throw new Error(
           "Invalid clinic update data: " + error.errors.map((e) => `${e.path.join(".")} - ${e.message}`).join(", ")
         );
@@ -6589,7 +6676,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof z18.ZodError) {
+      if (error instanceof z19.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -6762,7 +6849,7 @@ var AuthService = class extends BaseService {
         email
       );
     } catch (error) {
-      if (error instanceof z18.ZodError) {
+      if (error instanceof z19.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6885,7 +6972,7 @@ var AuthService = class extends BaseService {
       await emailSchema.parseAsync(email);
       await sendPasswordResetEmail(this.auth, email);
     } catch (error) {
-      if (error instanceof z18.ZodError) {
+      if (error instanceof z19.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6924,7 +7011,7 @@ var AuthService = class extends BaseService {
       await passwordSchema.parseAsync(newPassword);
       await confirmPasswordReset(this.auth, oobCode, newPassword);
     } catch (error) {
-      if (error instanceof z18.ZodError) {
+      if (error instanceof z19.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -7093,7 +7180,7 @@ var AuthService = class extends BaseService {
         practitioner
       };
     } catch (error) {
-      if (error instanceof z18.ZodError) {
+      if (error instanceof z19.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpPractitioner:",
           JSON.stringify(error.errors, null, 2)
@@ -7385,59 +7472,59 @@ import {
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-import { z as z19 } from "zod";
-var createProcedureSchema = z19.object({
-  name: z19.string().min(1).max(200),
-  description: z19.string().min(1).max(2e3),
-  family: z19.nativeEnum(ProcedureFamily),
-  categoryId: z19.string().min(1),
-  subcategoryId: z19.string().min(1),
-  technologyId: z19.string().min(1),
-  productId: z19.string().min(1),
-  price: z19.number().min(0),
-  currency: z19.nativeEnum(Currency),
-  pricingMeasure: z19.nativeEnum(PricingMeasure),
-  duration: z19.number().min(1).max(480),
+import { z as z20 } from "zod";
+var createProcedureSchema = z20.object({
+  name: z20.string().min(1).max(200),
+  description: z20.string().min(1).max(2e3),
+  family: z20.nativeEnum(ProcedureFamily),
+  categoryId: z20.string().min(1),
+  subcategoryId: z20.string().min(1),
+  technologyId: z20.string().min(1),
+  productId: z20.string().min(1),
+  price: z20.number().min(0),
+  currency: z20.nativeEnum(Currency),
+  pricingMeasure: z20.nativeEnum(PricingMeasure),
+  duration: z20.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: z19.string().min(1),
-  clinicBranchId: z19.string().min(1)
+  practitionerId: z20.string().min(1),
+  clinicBranchId: z20.string().min(1)
 });
-var updateProcedureSchema = z19.object({
-  name: z19.string().min(3).max(100).optional(),
-  description: z19.string().min(3).max(1e3).optional(),
-  price: z19.number().min(0).optional(),
-  currency: z19.nativeEnum(Currency).optional(),
-  pricingMeasure: z19.nativeEnum(PricingMeasure).optional(),
-  duration: z19.number().min(0).optional(),
-  isActive: z19.boolean().optional(),
-  practitionerId: z19.string().optional(),
-  categoryId: z19.string().optional(),
-  subcategoryId: z19.string().optional(),
-  technologyId: z19.string().optional(),
-  productId: z19.string().optional(),
-  clinicBranchId: z19.string().optional()
+var updateProcedureSchema = z20.object({
+  name: z20.string().min(3).max(100).optional(),
+  description: z20.string().min(3).max(1e3).optional(),
+  price: z20.number().min(0).optional(),
+  currency: z20.nativeEnum(Currency).optional(),
+  pricingMeasure: z20.nativeEnum(PricingMeasure).optional(),
+  duration: z20.number().min(0).optional(),
+  isActive: z20.boolean().optional(),
+  practitionerId: z20.string().optional(),
+  categoryId: z20.string().optional(),
+  subcategoryId: z20.string().optional(),
+  technologyId: z20.string().optional(),
+  productId: z20.string().optional(),
+  clinicBranchId: z20.string().optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: z19.string().min(1),
-  category: z19.any(),
+  id: z20.string().min(1),
+  category: z20.any(),
   // We'll validate the full category object separately
-  subcategory: z19.any(),
+  subcategory: z20.any(),
   // We'll validate the full subcategory object separately
-  technology: z19.any(),
+  technology: z20.any(),
   // We'll validate the full technology object separately
-  product: z19.any(),
+  product: z20.any(),
   // We'll validate the full product object separately
-  blockingConditions: z19.array(z19.any()),
+  blockingConditions: z20.array(z20.any()),
   // We'll validate blocking conditions separately
-  treatmentBenefits: z19.array(z19.any()),
+  treatmentBenefits: z20.array(z20.any()),
   // We'll validate treatment benefits separately
-  preRequirements: z19.array(z19.any()),
+  preRequirements: z20.array(z20.any()),
   // We'll validate requirements separately
-  postRequirements: z19.array(z19.any()),
+  postRequirements: z20.array(z20.any()),
   // We'll validate requirements separately
-  certificationRequirement: z19.any(),
+  certificationRequirement: z20.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: z19.array(z19.any()),
+  documentationTemplates: z20.array(z20.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -7445,9 +7532,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: z19.boolean(),
-  createdAt: z19.date(),
-  updatedAt: z19.date()
+  isActive: z20.boolean(),
+  createdAt: z20.date(),
+  updatedAt: z20.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -8516,42 +8603,42 @@ import {
 } from "firebase/firestore";
 
 // src/validations/calendar.schema.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 import { Timestamp as Timestamp18 } from "firebase/firestore";
 
 // src/validations/profile-info.schema.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 import { Timestamp as Timestamp17 } from "firebase/firestore";
-var clinicInfoSchema2 = z20.object({
-  id: z20.string(),
-  featuredPhoto: z20.string(),
-  name: z20.string(),
-  description: z20.string(),
+var clinicInfoSchema2 = z21.object({
+  id: z21.string(),
+  featuredPhoto: z21.string(),
+  name: z21.string(),
+  description: z21.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var practitionerProfileInfoSchema = z20.object({
-  id: z20.string(),
-  practitionerPhoto: z20.string().nullable(),
-  name: z20.string(),
-  email: z20.string().email(),
-  phone: z20.string().nullable(),
+var practitionerProfileInfoSchema = z21.object({
+  id: z21.string(),
+  practitionerPhoto: z21.string().nullable(),
+  name: z21.string(),
+  email: z21.string().email(),
+  phone: z21.string().nullable(),
   certification: practitionerCertificationSchema
 });
-var patientProfileInfoSchema = z20.object({
-  id: z20.string(),
-  fullName: z20.string(),
-  email: z20.string().email(),
-  phone: z20.string().nullable(),
-  dateOfBirth: z20.instanceof(Timestamp17),
-  gender: z20.nativeEnum(Gender)
+var patientProfileInfoSchema = z21.object({
+  id: z21.string(),
+  fullName: z21.string(),
+  email: z21.string().email(),
+  phone: z21.string().nullable(),
+  dateOfBirth: z21.instanceof(Timestamp17),
+  gender: z21.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = z21.object({
-  start: z21.instanceof(Date).or(z21.instanceof(Timestamp18)),
-  end: z21.instanceof(Date).or(z21.instanceof(Timestamp18))
+var calendarEventTimeSchema = z22.object({
+  start: z22.instanceof(Date).or(z22.instanceof(Timestamp18)),
+  end: z22.instanceof(Date).or(z22.instanceof(Timestamp18))
 }).refine(
   (data) => {
     const startDate = data.start instanceof Timestamp18 ? data.start.toDate() : data.start;
@@ -8572,46 +8659,46 @@ var calendarEventTimeSchema = z21.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = z21.object({
-  start: z21.date(),
-  end: z21.date(),
-  isAvailable: z21.boolean()
+var timeSlotSchema2 = z22.object({
+  start: z22.date(),
+  end: z22.date(),
+  isAvailable: z22.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-var syncedCalendarEventSchema = z21.object({
-  eventId: z21.string(),
-  syncedCalendarProvider: z21.nativeEnum(SyncedCalendarProvider),
-  syncedAt: z21.instanceof(Date).or(z21.instanceof(Timestamp18))
+var syncedCalendarEventSchema = z22.object({
+  eventId: z22.string(),
+  syncedCalendarProvider: z22.nativeEnum(SyncedCalendarProvider),
+  syncedAt: z22.instanceof(Date).or(z22.instanceof(Timestamp18))
 });
-var procedureInfoSchema = z21.object({
-  name: z21.string(),
-  description: z21.string(),
-  duration: z21.number().min(MIN_APPOINTMENT_DURATION),
-  price: z21.number().min(0),
-  currency: z21.nativeEnum(Currency)
+var procedureInfoSchema = z22.object({
+  name: z22.string(),
+  description: z22.string(),
+  duration: z22.number().min(MIN_APPOINTMENT_DURATION),
+  price: z22.number().min(0),
+  currency: z22.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = z21.object({
-  procedureFamily: z21.string(),
+var procedureCategorizationSchema = z22.object({
+  procedureFamily: z22.string(),
   // Replace with proper enum when available
-  procedureCategory: z21.string(),
+  procedureCategory: z22.string(),
   // Replace with proper enum when available
-  procedureSubcategory: z21.string(),
+  procedureSubcategory: z22.string(),
   // Replace with proper enum when available
-  procedureTechnology: z21.string(),
+  procedureTechnology: z22.string(),
   // Replace with proper enum when available
-  procedureProduct: z21.string()
+  procedureProduct: z22.string()
   // Replace with proper enum when available
 });
-var createAppointmentSchema2 = z21.object({
-  clinicId: z21.string().min(1, "Clinic ID is required"),
-  doctorId: z21.string().min(1, "Doctor ID is required"),
-  patientId: z21.string().min(1, "Patient ID is required"),
-  procedureId: z21.string().min(1, "Procedure ID is required"),
+var createAppointmentSchema2 = z22.object({
+  clinicId: z22.string().min(1, "Clinic ID is required"),
+  doctorId: z22.string().min(1, "Doctor ID is required"),
+  patientId: z22.string().min(1, "Patient ID is required"),
+  procedureId: z22.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: z21.string().optional()
+  description: z22.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -8620,73 +8707,73 @@ var createAppointmentSchema2 = z21.object({
     message: "Invalid appointment parameters"
   }
 );
-var updateAppointmentSchema2 = z21.object({
-  appointmentId: z21.string().min(1, "Appointment ID is required"),
-  clinicId: z21.string().min(1, "Clinic ID is required"),
-  doctorId: z21.string().min(1, "Doctor ID is required"),
-  patientId: z21.string().min(1, "Patient ID is required"),
+var updateAppointmentSchema2 = z22.object({
+  appointmentId: z22.string().min(1, "Appointment ID is required"),
+  clinicId: z22.string().min(1, "Clinic ID is required"),
+  doctorId: z22.string().min(1, "Doctor ID is required"),
+  patientId: z22.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z21.string().optional(),
-  status: z21.nativeEnum(CalendarEventStatus).optional()
+  description: z22.string().optional(),
+  status: z22.nativeEnum(CalendarEventStatus).optional()
 });
-var createCalendarEventSchema = z21.object({
-  id: z21.string(),
-  clinicBranchId: z21.string().nullable().optional(),
-  clinicBranchInfo: z21.any().nullable().optional(),
-  practitionerProfileId: z21.string().nullable().optional(),
+var createCalendarEventSchema = z22.object({
+  id: z22.string(),
+  clinicBranchId: z22.string().nullable().optional(),
+  clinicBranchInfo: z22.any().nullable().optional(),
+  practitionerProfileId: z22.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z21.string().nullable().optional(),
+  patientProfileId: z22.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z21.string().nullable().optional(),
-  appointmentId: z21.string().nullable().optional(),
-  syncedCalendarEventId: z21.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: z21.string().min(1, "Event name is required"),
+  procedureId: z22.string().nullable().optional(),
+  appointmentId: z22.string().nullable().optional(),
+  syncedCalendarEventId: z22.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z22.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: z21.string().optional(),
-  status: z21.nativeEnum(CalendarEventStatus),
-  syncStatus: z21.nativeEnum(CalendarSyncStatus),
-  eventType: z21.nativeEnum(CalendarEventType),
-  createdAt: z21.any(),
+  description: z22.string().optional(),
+  status: z22.nativeEnum(CalendarEventStatus),
+  syncStatus: z22.nativeEnum(CalendarSyncStatus),
+  eventType: z22.nativeEnum(CalendarEventType),
+  createdAt: z22.any(),
   // FieldValue for server timestamp
-  updatedAt: z21.any()
+  updatedAt: z22.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = z21.object({
-  syncedCalendarEventId: z21.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: z21.string().nullable().optional(),
-  eventName: z21.string().optional(),
+var updateCalendarEventSchema = z22.object({
+  syncedCalendarEventId: z22.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: z22.string().nullable().optional(),
+  eventName: z22.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z21.string().optional(),
-  status: z21.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: z21.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: z21.nativeEnum(CalendarEventType).optional(),
-  updatedAt: z21.any()
+  description: z22.string().optional(),
+  status: z22.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: z22.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: z22.nativeEnum(CalendarEventType).optional(),
+  updatedAt: z22.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = z21.object({
-  id: z21.string(),
-  clinicBranchId: z21.string().nullable().optional(),
-  clinicBranchInfo: z21.any().nullable().optional(),
+var calendarEventSchema = z22.object({
+  id: z22.string(),
+  clinicBranchId: z22.string().nullable().optional(),
+  clinicBranchInfo: z22.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: z21.string().nullable().optional(),
+  practitionerProfileId: z22.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z21.string().nullable().optional(),
+  patientProfileId: z22.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z21.string().nullable().optional(),
+  procedureId: z22.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: z21.string().nullable().optional(),
-  syncedCalendarEventId: z21.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: z21.string(),
+  appointmentId: z22.string().nullable().optional(),
+  syncedCalendarEventId: z22.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z22.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: z21.string().optional(),
-  status: z21.nativeEnum(CalendarEventStatus),
-  syncStatus: z21.nativeEnum(CalendarSyncStatus),
-  eventType: z21.nativeEnum(CalendarEventType),
-  createdAt: z21.instanceof(Date).or(z21.instanceof(Timestamp18)),
-  updatedAt: z21.instanceof(Date).or(z21.instanceof(Timestamp18))
+  description: z22.string().optional(),
+  status: z22.nativeEnum(CalendarEventStatus),
+  syncStatus: z22.nativeEnum(CalendarSyncStatus),
+  eventType: z22.nativeEnum(CalendarEventType),
+  createdAt: z22.instanceof(Date).or(z22.instanceof(Timestamp18)),
+  updatedAt: z22.instanceof(Date).or(z22.instanceof(Timestamp18))
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -11297,7 +11384,7 @@ import {
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -11403,7 +11490,7 @@ var ReviewService = class extends BaseService {
       await Promise.all(updatePromises);
       return review;
     } catch (error) {
-      if (error instanceof z22.ZodError) {
+      if (error instanceof z23.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -13729,54 +13816,54 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-import { z as z23 } from "zod";
-var baseNotificationSchema = z23.object({
-  id: z23.string().optional(),
-  userId: z23.string(),
-  notificationTime: z23.any(),
+import { z as z24 } from "zod";
+var baseNotificationSchema = z24.object({
+  id: z24.string().optional(),
+  userId: z24.string(),
+  notificationTime: z24.any(),
   // Timestamp
-  notificationType: z23.nativeEnum(NotificationType),
-  notificationTokens: z23.array(z23.string()),
-  status: z23.nativeEnum(NotificationStatus),
-  createdAt: z23.any().optional(),
+  notificationType: z24.nativeEnum(NotificationType),
+  notificationTokens: z24.array(z24.string()),
+  status: z24.nativeEnum(NotificationStatus),
+  createdAt: z24.any().optional(),
   // Timestamp
-  updatedAt: z23.any().optional(),
+  updatedAt: z24.any().optional(),
   // Timestamp
-  title: z23.string(),
-  body: z23.string(),
-  isRead: z23.boolean(),
-  userRole: z23.nativeEnum(UserRole)
+  title: z24.string(),
+  body: z24.string(),
+  isRead: z24.boolean(),
+  userRole: z24.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z23.literal("preRequirement" /* PRE_REQUIREMENT */),
-  treatmentId: z23.string(),
-  requirements: z23.array(z23.string()),
-  deadline: z23.any()
+  notificationType: z24.literal("preRequirement" /* PRE_REQUIREMENT */),
+  treatmentId: z24.string(),
+  requirements: z24.array(z24.string()),
+  deadline: z24.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z23.literal("postRequirement" /* POST_REQUIREMENT */),
-  treatmentId: z23.string(),
-  requirements: z23.array(z23.string()),
-  deadline: z23.any()
+  notificationType: z24.literal("postRequirement" /* POST_REQUIREMENT */),
+  treatmentId: z24.string(),
+  requirements: z24.array(z24.string()),
+  deadline: z24.any()
   // Timestamp
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z23.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: z23.string(),
-  appointmentTime: z23.any(),
+  notificationType: z24.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: z24.string(),
+  appointmentTime: z24.any(),
   // Timestamp
-  treatmentType: z23.string(),
-  doctorName: z23.string()
+  treatmentType: z24.string(),
+  doctorName: z24.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z23.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
-  appointmentId: z23.string(),
-  appointmentStatus: z23.string(),
-  previousStatus: z23.string(),
-  reason: z23.string().optional()
+  notificationType: z24.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  appointmentId: z24.string(),
+  appointmentStatus: z24.string(),
+  previousStatus: z24.string(),
+  reason: z24.string().optional()
 });
-var notificationSchema = z23.discriminatedUnion("notificationType", [
+var notificationSchema = z24.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   appointmentReminderNotificationSchema,
@@ -13916,7 +14003,6 @@ export {
   clinicContactInfoSchema,
   clinicGroupSchema,
   clinicGroupSetupSchema,
-  clinicInfoSchema,
   clinicLocationSchema,
   clinicReviewInfoSchema,
   clinicReviewSchema,
@@ -13944,7 +14030,6 @@ export {
   createProcedureReviewSchema,
   createReviewSchema,
   createUserOptionsSchema,
-  doctorInfoSchema,
   documentElementSchema,
   documentElementWithoutIdSchema,
   documentTemplateSchema,
@@ -13983,7 +14068,6 @@ export {
   procedureInfoSchema,
   procedureReviewInfoSchema,
   procedureReviewSchema,
-  procedureSummaryInfoSchema,
   requesterInfoSchema,
   reviewSchema,
   searchAppointmentsSchema,