@blackcode_sa/metaestetics-api 1.7.11 → 1.7.13

package/dist/index.js

@@ -796,7 +796,7 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/validations/schemas.ts
 var import_zod3 = require("zod");
@@ -1191,7 +1191,7 @@ var USER_ERRORS = {
 };
 
 // src/services/user.service.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/services/patient/patient.service.ts
 var import_firestore12 = require("firebase/firestore");
@@ -3102,7 +3102,7 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 })(SubscriptionModel || {});
 
 // src/validations/clinic.schema.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var import_firestore13 = require("firebase/firestore");
 
 // src/validations/reviews.schema.ts
@@ -3319,38 +3319,41 @@ var doctorInfoSchema = import_zod11.z.object({
   // List of procedure IDs practitioner offers
 });
 
-// src/validations/clinic.schema.ts
+// src/validations/media.schema.ts
+var import_zod12 = require("zod");
 var mediaResourceSchema = import_zod12.z.union([
   import_zod12.z.string(),
   import_zod12.z.instanceof(File),
   import_zod12.z.instanceof(Blob)
 ]);
-var clinicContactInfoSchema = import_zod12.z.object({
-  email: import_zod12.z.string().email(),
-  phoneNumber: import_zod12.z.string(),
-  alternativePhoneNumber: import_zod12.z.string().nullable().optional(),
-  website: import_zod12.z.string().nullable().optional()
+
+// src/validations/clinic.schema.ts
+var clinicContactInfoSchema = import_zod13.z.object({
+  email: import_zod13.z.string().email(),
+  phoneNumber: import_zod13.z.string(),
+  alternativePhoneNumber: import_zod13.z.string().nullable().optional(),
+  website: import_zod13.z.string().nullable().optional()
 });
-var clinicLocationSchema = import_zod12.z.object({
-  address: import_zod12.z.string(),
-  city: import_zod12.z.string(),
-  country: import_zod12.z.string(),
-  postalCode: import_zod12.z.string(),
-  latitude: import_zod12.z.number().min(-90).max(90),
-  longitude: import_zod12.z.number().min(-180).max(180),
-  geohash: import_zod12.z.string().nullable().optional()
+var clinicLocationSchema = import_zod13.z.object({
+  address: import_zod13.z.string(),
+  city: import_zod13.z.string(),
+  country: import_zod13.z.string(),
+  postalCode: import_zod13.z.string(),
+  latitude: import_zod13.z.number().min(-90).max(90),
+  longitude: import_zod13.z.number().min(-180).max(180),
+  geohash: import_zod13.z.string().nullable().optional()
 });
-var workingHoursTimeSchema = import_zod12.z.object({
-  open: import_zod12.z.string(),
-  close: import_zod12.z.string(),
-  breaks: import_zod12.z.array(
-    import_zod12.z.object({
-      start: import_zod12.z.string(),
-      end: import_zod12.z.string()
+var workingHoursTimeSchema = import_zod13.z.object({
+  open: import_zod13.z.string(),
+  close: import_zod13.z.string(),
+  breaks: import_zod13.z.array(
+    import_zod13.z.object({
+      start: import_zod13.z.string(),
+      end: import_zod13.z.string()
     })
   ).optional()
 });
-var workingHoursSchema = import_zod12.z.object({
+var workingHoursSchema = import_zod13.z.object({
   monday: workingHoursTimeSchema.nullable(),
   tuesday: workingHoursTimeSchema.nullable(),
   wednesday: workingHoursTimeSchema.nullable(),
@@ -3359,239 +3362,255 @@ var workingHoursSchema = import_zod12.z.object({
   saturday: workingHoursTimeSchema.nullable(),
   sunday: workingHoursTimeSchema.nullable()
 });
-var clinicTagsSchema = import_zod12.z.object({
-  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag))
+var clinicTagsSchema = import_zod13.z.object({
+  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag))
 });
-var contactPersonSchema = import_zod12.z.object({
-  firstName: import_zod12.z.string(),
-  lastName: import_zod12.z.string(),
-  title: import_zod12.z.string().nullable().optional(),
-  email: import_zod12.z.string().email(),
-  phoneNumber: import_zod12.z.string().nullable().optional()
+var contactPersonSchema = import_zod13.z.object({
+  firstName: import_zod13.z.string(),
+  lastName: import_zod13.z.string(),
+  title: import_zod13.z.string().nullable().optional(),
+  email: import_zod13.z.string().email(),
+  phoneNumber: import_zod13.z.string().nullable().optional()
 });
-var adminInfoSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  email: import_zod12.z.string().email()
+var adminInfoSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  name: import_zod13.z.string(),
+  email: import_zod13.z.string().email()
 });
-var clinicAdminSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  userRef: import_zod12.z.string(),
-  clinicGroupId: import_zod12.z.string(),
-  isGroupOwner: import_zod12.z.boolean(),
-  clinicsManaged: import_zod12.z.array(import_zod12.z.string()),
-  clinicsManagedInfo: import_zod12.z.array(clinicInfoSchema),
+var clinicAdminSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  userRef: import_zod13.z.string(),
+  clinicGroupId: import_zod13.z.string(),
+  isGroupOwner: import_zod13.z.boolean(),
+  clinicsManaged: import_zod13.z.array(import_zod13.z.string()),
+  clinicsManagedInfo: import_zod13.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)),
-  isActive: import_zod12.z.boolean()
+  roleTitle: import_zod13.z.string(),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  isActive: import_zod13.z.boolean()
 });
-var adminTokenSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  token: import_zod12.z.string(),
-  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)),
+var adminTokenSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  token: import_zod13.z.string(),
+  email: import_zod13.z.string().email().optional().nullable(),
+  status: import_zod13.z.nativeEnum(AdminTokenStatus),
+  usedByUserRef: import_zod13.z.string().optional(),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
   // Timestamp
-  expiresAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp))
+  expiresAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp))
   // Timestamp
 });
-var createAdminTokenSchema = import_zod12.z.object({
-  expiresInDays: import_zod12.z.number().min(1).max(30).optional(),
-  email: import_zod12.z.string().email().optional().nullable()
+var createAdminTokenSchema = import_zod13.z.object({
+  expiresInDays: import_zod13.z.number().min(1).max(30).optional(),
+  email: import_zod13.z.string().email().optional().nullable()
 });
-var clinicGroupSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  description: import_zod12.z.string().nullable().optional(),
+var clinicGroupSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  name: import_zod13.z.string(),
+  description: import_zod13.z.string().nullable().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  clinics: import_zod12.z.array(import_zod12.z.string()),
-  clinicsInfo: import_zod12.z.array(clinicInfoSchema),
-  admins: import_zod12.z.array(import_zod12.z.string()),
-  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)),
+  clinics: import_zod13.z.array(import_zod13.z.string()),
+  clinicsInfo: import_zod13.z.array(clinicInfoSchema),
+  admins: import_zod13.z.array(import_zod13.z.string()),
+  adminsInfo: import_zod13.z.array(adminInfoSchema),
+  adminTokens: import_zod13.z.array(adminTokenSchema),
+  ownerId: import_zod13.z.string().nullable(),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
   // Timestamp
-  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
   // Timestamp
-  isActive: import_zod12.z.boolean(),
+  isActive: import_zod13.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
-  practiceType: import_zod12.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod12.z.array(import_zod12.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod12.z.nativeEnum(SubscriptionModel),
-  calendarSyncEnabled: import_zod12.z.boolean().optional(),
-  autoConfirmAppointments: import_zod12.z.boolean().optional(),
-  businessIdentificationNumber: import_zod12.z.string().optional().nullable()
+  practiceType: import_zod13.z.nativeEnum(PracticeType).optional(),
+  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)).optional(),
+  subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel),
+  calendarSyncEnabled: import_zod13.z.boolean().optional(),
+  autoConfirmAppointments: import_zod13.z.boolean().optional(),
+  businessIdentificationNumber: import_zod13.z.string().optional().nullable(),
+  onboarding: import_zod13.z.object({
+    completed: import_zod13.z.boolean().optional().default(false),
+    step: import_zod13.z.number().optional().default(1)
+  }).optional()
 });
-var clinicSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  clinicGroupId: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  description: import_zod12.z.string().nullable().optional(),
+var clinicSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  clinicGroupId: import_zod13.z.string(),
+  name: import_zod13.z.string(),
+  description: import_zod13.z.string().nullable().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)),
-  featuredPhotos: import_zod12.z.array(mediaResourceSchema),
+  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)),
+  featuredPhotos: import_zod13.z.array(mediaResourceSchema),
   coverPhoto: mediaResourceSchema.nullable(),
-  photosWithTags: import_zod12.z.array(
-    import_zod12.z.object({
+  photosWithTags: import_zod13.z.array(
+    import_zod13.z.object({
       url: mediaResourceSchema,
-      tag: import_zod12.z.string()
+      tag: import_zod13.z.string()
     })
   ).optional(),
-  doctors: import_zod12.z.array(import_zod12.z.string()),
+  doctors: import_zod13.z.array(import_zod13.z.string()),
   // List of practitioner IDs
-  doctorsInfo: import_zod12.z.array(doctorInfoSchema),
+  doctorsInfo: import_zod13.z.array(doctorInfoSchema),
   // Aggregated doctor info
-  procedures: import_zod12.z.array(import_zod12.z.string()),
+  procedures: import_zod13.z.array(import_zod13.z.string()),
   // List of procedure IDs offered by clinic
-  proceduresInfo: import_zod12.z.array(procedureSummaryInfoSchema),
+  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema),
   // Use the correct schema for aggregated procedure info
   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)),
+  admins: import_zod13.z.array(import_zod13.z.string()),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
   // Timestamp
-  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
   // Timestamp
-  isActive: import_zod12.z.boolean(),
-  isVerified: import_zod12.z.boolean(),
+  isActive: import_zod13.z.boolean(),
+  isVerified: import_zod13.z.boolean(),
   logo: mediaResourceSchema.optional().nullable()
 });
-var createClinicAdminSchema = import_zod12.z.object({
-  userRef: import_zod12.z.string(),
-  clinicGroupId: import_zod12.z.string().optional(),
-  isGroupOwner: import_zod12.z.boolean(),
-  clinicsManaged: import_zod12.z.array(import_zod12.z.string()),
+var createClinicAdminSchema = import_zod13.z.object({
+  userRef: import_zod13.z.string(),
+  clinicGroupId: import_zod13.z.string().optional(),
+  isGroupOwner: import_zod13.z.boolean(),
+  clinicsManaged: import_zod13.z.array(import_zod13.z.string()),
   contactInfo: contactPersonSchema,
-  roleTitle: import_zod12.z.string(),
-  isActive: import_zod12.z.boolean()
+  roleTitle: import_zod13.z.string(),
+  isActive: import_zod13.z.boolean()
   // clinicsManagedInfo is aggregated, not provided on creation
 });
-var createClinicGroupSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
-  description: import_zod12.z.string().optional(),
+var createClinicGroupSchema = import_zod13.z.object({
+  name: import_zod13.z.string(),
+  description: import_zod13.z.string().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  ownerId: import_zod12.z.string().nullable(),
-  isActive: import_zod12.z.boolean(),
+  ownerId: import_zod13.z.string().nullable(),
+  isActive: import_zod13.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
-  practiceType: import_zod12.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod12.z.array(import_zod12.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod12.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
-  calendarSyncEnabled: import_zod12.z.boolean().optional(),
-  autoConfirmAppointments: import_zod12.z.boolean().optional(),
-  businessIdentificationNumber: import_zod12.z.string().optional().nullable()
+  practiceType: import_zod13.z.nativeEnum(PracticeType).optional(),
+  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)).optional(),
+  subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
+  calendarSyncEnabled: import_zod13.z.boolean().optional(),
+  autoConfirmAppointments: import_zod13.z.boolean().optional(),
+  businessIdentificationNumber: import_zod13.z.string().optional().nullable(),
+  onboarding: import_zod13.z.object({
+    completed: import_zod13.z.boolean().optional().default(false),
+    step: import_zod13.z.number().optional().default(1)
+  }).optional()
   // clinics, clinicsInfo, admins, adminsInfo, adminTokens are managed internally
 });
-var createClinicSchema = import_zod12.z.object({
-  clinicGroupId: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  description: import_zod12.z.string().optional(),
+var createClinicSchema = import_zod13.z.object({
+  clinicGroupId: import_zod13.z.string(),
+  name: import_zod13.z.string(),
+  description: import_zod13.z.string().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)),
+  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)),
   coverPhoto: mediaResourceSchema.nullable().optional(),
-  photosWithTags: import_zod12.z.array(
-    import_zod12.z.object({
+  photosWithTags: import_zod13.z.array(
+    import_zod13.z.object({
       url: mediaResourceSchema,
-      tag: import_zod12.z.string()
+      tag: import_zod13.z.string()
     })
   ).optional(),
-  doctors: import_zod12.z.array(import_zod12.z.string()).optional().default([]),
-  procedures: import_zod12.z.array(import_zod12.z.string()).optional().default([]),
-  proceduresInfo: import_zod12.z.array(procedureSummaryInfoSchema).optional(),
-  admins: import_zod12.z.array(import_zod12.z.string()),
-  isActive: import_zod12.z.boolean().optional().default(true),
-  isVerified: import_zod12.z.boolean().optional().default(false),
+  doctors: import_zod13.z.array(import_zod13.z.string()).optional().default([]),
+  procedures: import_zod13.z.array(import_zod13.z.string()).optional().default([]),
+  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema).optional(),
+  admins: import_zod13.z.array(import_zod13.z.string()),
+  isActive: import_zod13.z.boolean().optional().default(true),
+  isVerified: import_zod13.z.boolean().optional().default(false),
   logo: mediaResourceSchema.optional().nullable(),
-  featuredPhotos: import_zod12.z.array(mediaResourceSchema).optional().default([])
+  featuredPhotos: import_zod13.z.array(mediaResourceSchema).optional().default([])
 });
-var createDefaultClinicGroupSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
-  ownerId: import_zod12.z.string().nullable(),
+var createDefaultClinicGroupSchema = import_zod13.z.object({
+  name: import_zod13.z.string(),
+  ownerId: import_zod13.z.string().nullable(),
   contactPerson: contactPersonSchema,
   contactInfo: clinicContactInfoSchema,
   hqLocation: clinicLocationSchema,
-  isActive: import_zod12.z.boolean(),
+  isActive: import_zod13.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
-  practiceType: import_zod12.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod12.z.array(import_zod12.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod12.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+  practiceType: import_zod13.z.nativeEnum(PracticeType).optional(),
+  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)).optional(),
+  subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
+  onboarding: import_zod13.z.object({
+    completed: import_zod13.z.boolean().optional().default(false),
+    step: import_zod13.z.number().optional().default(1)
+  }).optional()
 });
-var clinicAdminSignupSchema = import_zod12.z.object({
-  email: import_zod12.z.string().email(),
-  password: import_zod12.z.string().min(8),
-  firstName: import_zod12.z.string(),
-  lastName: import_zod12.z.string(),
-  title: import_zod12.z.string(),
-  phoneNumber: import_zod12.z.string(),
-  isCreatingNewGroup: import_zod12.z.boolean(),
-  inviteToken: import_zod12.z.string().optional(),
-  clinicGroupData: import_zod12.z.object({
-    name: import_zod12.z.string(),
+var clinicAdminSignupSchema = import_zod13.z.object({
+  email: import_zod13.z.string().email(),
+  password: import_zod13.z.string().min(8),
+  firstName: import_zod13.z.string(),
+  lastName: import_zod13.z.string(),
+  title: import_zod13.z.string(),
+  phoneNumber: import_zod13.z.string(),
+  isCreatingNewGroup: import_zod13.z.boolean(),
+  inviteToken: import_zod13.z.string().optional(),
+  clinicGroupData: import_zod13.z.object({
+    name: import_zod13.z.string(),
     hqLocation: clinicLocationSchema,
     logo: mediaResourceSchema.optional(),
     contactInfo: clinicContactInfoSchema,
-    subscriptionModel: import_zod12.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+    subscriptionModel: import_zod13.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
   }).optional()
 });
-var clinicGroupSetupSchema = import_zod12.z.object({
-  languages: import_zod12.z.array(import_zod12.z.nativeEnum(Language)),
-  practiceType: import_zod12.z.nativeEnum(PracticeType),
-  description: import_zod12.z.string(),
+var clinicGroupSetupSchema = import_zod13.z.object({
+  languages: import_zod13.z.array(import_zod13.z.nativeEnum(Language)),
+  practiceType: import_zod13.z.nativeEnum(PracticeType),
+  description: import_zod13.z.string(),
   logo: mediaResourceSchema,
-  calendarSyncEnabled: import_zod12.z.boolean(),
-  autoConfirmAppointments: import_zod12.z.boolean(),
-  businessIdentificationNumber: import_zod12.z.string().optional().nullable()
+  calendarSyncEnabled: import_zod13.z.boolean(),
+  autoConfirmAppointments: import_zod13.z.boolean(),
+  businessIdentificationNumber: import_zod13.z.string().optional().nullable(),
+  onboarding: import_zod13.z.object({
+    completed: import_zod13.z.boolean().optional().default(false),
+    step: import_zod13.z.number().optional().default(1)
+  }).optional()
 });
-var clinicBranchSetupSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
+var clinicBranchSetupSchema = import_zod13.z.object({
+  name: import_zod13.z.string(),
   location: clinicLocationSchema,
-  description: import_zod12.z.string().optional(),
+  description: import_zod13.z.string().optional(),
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)),
+  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)),
   logo: mediaResourceSchema.optional(),
   coverPhoto: mediaResourceSchema.nullable().optional(),
-  photosWithTags: import_zod12.z.array(
-    import_zod12.z.object({
+  photosWithTags: import_zod13.z.array(
+    import_zod13.z.object({
       url: mediaResourceSchema,
-      tag: import_zod12.z.string()
+      tag: import_zod13.z.string()
     })
   ).optional(),
-  featuredPhotos: import_zod12.z.array(mediaResourceSchema).optional()
+  featuredPhotos: import_zod13.z.array(mediaResourceSchema).optional()
 });
 var updateClinicAdminSchema = createClinicAdminSchema.partial();
 var updateClinicGroupSchema = createClinicGroupSchema.partial();
-var updateClinicSchema = import_zod12.z.object({
-  name: import_zod12.z.string().optional(),
-  description: import_zod12.z.string().optional(),
+var updateClinicSchema = import_zod13.z.object({
+  name: import_zod13.z.string().optional(),
+  description: import_zod13.z.string().optional(),
   location: clinicLocationSchema.optional(),
   contactInfo: clinicContactInfoSchema.optional(),
   workingHours: workingHoursSchema.optional(),
-  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)).optional(),
+  tags: import_zod13.z.array(import_zod13.z.nativeEnum(ClinicTag)).optional(),
   coverPhoto: mediaResourceSchema.nullable().optional(),
-  photosWithTags: import_zod12.z.array(
-    import_zod12.z.object({
+  photosWithTags: import_zod13.z.array(
+    import_zod13.z.object({
       url: mediaResourceSchema,
-      tag: import_zod12.z.string()
+      tag: import_zod13.z.string()
     })
   ).optional(),
-  doctors: import_zod12.z.array(import_zod12.z.string()).optional(),
-  procedures: import_zod12.z.array(import_zod12.z.string()).optional(),
-  proceduresInfo: import_zod12.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod12.z.boolean().optional(),
-  isVerified: import_zod12.z.boolean().optional(),
+  doctors: import_zod13.z.array(import_zod13.z.string()).optional(),
+  procedures: import_zod13.z.array(import_zod13.z.string()).optional(),
+  proceduresInfo: import_zod13.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod13.z.boolean().optional(),
+  isVerified: import_zod13.z.boolean().optional(),
   logo: mediaResourceSchema.optional().nullable(),
-  featuredPhotos: import_zod12.z.array(mediaResourceSchema).optional()
+  featuredPhotos: import_zod13.z.array(mediaResourceSchema).optional()
 });
 
 // src/services/clinic/utils/admin.utils.ts
@@ -4044,7 +4063,7 @@ var ClinicAdminService = class extends BaseService {
 var import_firestore16 = require("firebase/firestore");
 
 // src/validations/practitioner.schema.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var import_firestore15 = require("firebase/firestore");
 
 // src/backoffice/types/static/certification.types.ts
@@ -4072,34 +4091,34 @@ var CertificationSpecialty = /* @__PURE__ */ ((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_firestore15.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 practitionerBasicInfoSchema = import_zod14.z.object({
+  firstName: import_zod14.z.string().min(2).max(50),
+  lastName: import_zod14.z.string().min(2).max(50),
+  title: import_zod14.z.string().min(2).max(100),
+  email: import_zod14.z.string().email(),
+  phoneNumber: import_zod14.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
+  dateOfBirth: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  gender: import_zod14.z.enum(["male", "female", "other"]),
+  profileImageUrl: import_zod14.z.string().url().optional(),
+  bio: import_zod14.z.string().max(1e3).optional(),
+  languages: import_zod14.z.array(import_zod14.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_firestore15.Timestamp).or(import_zod13.z.date()),
-  expiryDate: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date()).optional(),
-  verificationStatus: import_zod13.z.enum(["pending", "verified", "rejected"])
+var practitionerCertificationSchema = import_zod14.z.object({
+  level: import_zod14.z.nativeEnum(CertificationLevel),
+  specialties: import_zod14.z.array(import_zod14.z.nativeEnum(CertificationSpecialty)),
+  licenseNumber: import_zod14.z.string().min(3).max(50),
+  issuingAuthority: import_zod14.z.string().min(2).max(100),
+  issueDate: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  expiryDate: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()).optional(),
+  verificationStatus: import_zod14.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")
+var timeSlotSchema = import_zod14.z.object({
+  start: import_zod14.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: import_zod14.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),
+var practitionerWorkingHoursSchema = import_zod14.z.object({
+  practitionerId: import_zod14.z.string().min(1),
+  clinicId: import_zod14.z.string().min(1),
   monday: timeSlotSchema,
   tuesday: timeSlotSchema,
   wednesday: timeSlotSchema,
@@ -4107,12 +4126,12 @@ var practitionerWorkingHoursSchema = import_zod13.z.object({
   friday: timeSlotSchema,
   saturday: timeSlotSchema,
   sunday: timeSlotSchema,
-  createdAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date()),
-  updatedAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date())
+  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
 });
-var practitionerClinicWorkingHoursSchema = import_zod13.z.object({
-  clinicId: import_zod13.z.string().min(1),
-  workingHours: import_zod13.z.object({
+var practitionerClinicWorkingHoursSchema = import_zod14.z.object({
+  clinicId: import_zod14.z.string().min(1),
+  workingHours: import_zod14.z.object({
     monday: timeSlotSchema,
     tuesday: timeSlotSchema,
     wednesday: timeSlotSchema,
@@ -4121,87 +4140,87 @@ var practitionerClinicWorkingHoursSchema = import_zod13.z.object({
     saturday: timeSlotSchema,
     sunday: timeSlotSchema
   }),
-  isActive: import_zod13.z.boolean(),
-  createdAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date()),
-  updatedAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date())
+  isActive: import_zod14.z.boolean(),
+  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
 });
-var practitionerSchema = import_zod13.z.object({
-  id: import_zod13.z.string().min(1),
-  userRef: import_zod13.z.string().min(1),
+var practitionerSchema = import_zod14.z.object({
+  id: import_zod14.z.string().min(1),
+  userRef: import_zod14.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),
+  clinics: import_zod14.z.array(import_zod14.z.string()),
+  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: import_zod14.z.array(clinicInfoSchema),
+  procedures: import_zod14.z.array(import_zod14.z.string()),
+  proceduresInfo: import_zod14.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_firestore15.Timestamp).or(import_zod13.z.date()),
-  updatedAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date())
+  isActive: import_zod14.z.boolean(),
+  isVerified: import_zod14.z.boolean(),
+  status: import_zod14.z.nativeEnum(PractitionerStatus),
+  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
 });
-var createPractitionerSchema = import_zod13.z.object({
-  userRef: import_zod13.z.string().min(1),
+var createPractitionerSchema = import_zod14.z.object({
+  userRef: import_zod14.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()
+  clinics: import_zod14.z.array(import_zod14.z.string()).optional(),
+  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod14.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod14.z.boolean(),
+  isVerified: import_zod14.z.boolean(),
+  status: import_zod14.z.nativeEnum(PractitionerStatus).optional()
 });
-var createDraftPractitionerSchema = import_zod13.z.object({
+var createDraftPractitionerSchema = import_zod14.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)
+  clinics: import_zod14.z.array(import_zod14.z.string()).optional(),
+  clinicWorkingHours: import_zod14.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod14.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod14.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod14.z.boolean().optional().default(false),
+  isVerified: import_zod14.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_firestore15.Timestamp).or(import_zod13.z.date()),
-  expiresAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date()),
-  usedBy: import_zod13.z.string().optional(),
-  usedAt: import_zod13.z.instanceof(import_firestore15.Timestamp).or(import_zod13.z.date()).optional()
+var practitionerTokenSchema = import_zod14.z.object({
+  id: import_zod14.z.string().min(1),
+  token: import_zod14.z.string().min(6),
+  practitionerId: import_zod14.z.string().min(1),
+  email: import_zod14.z.string().email(),
+  clinicId: import_zod14.z.string().min(1),
+  status: import_zod14.z.nativeEnum(PractitionerTokenStatus),
+  createdBy: import_zod14.z.string().min(1),
+  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  expiresAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  usedBy: import_zod14.z.string().optional(),
+  usedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.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 createPractitionerTokenSchema = import_zod14.z.object({
+  practitionerId: import_zod14.z.string().min(1),
+  email: import_zod14.z.string().email(),
+  clinicId: import_zod14.z.string().min(1),
+  expiresAt: import_zod14.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).optional(),
-  lastName: import_zod13.z.string().min(2).max(50).optional(),
-  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()
+var practitionerSignupSchema = import_zod14.z.object({
+  email: import_zod14.z.string().email(),
+  password: import_zod14.z.string().min(8),
+  firstName: import_zod14.z.string().min(2).max(50).optional(),
+  lastName: import_zod14.z.string().min(2).max(50).optional(),
+  token: import_zod14.z.string().optional(),
+  profileData: import_zod14.z.object({
+    basicInfo: import_zod14.z.object({
+      phoneNumber: import_zod14.z.string().optional(),
+      profileImageUrl: import_zod14.z.string().optional(),
+      gender: import_zod14.z.enum(["male", "female", "other"]).optional(),
+      bio: import_zod14.z.string().optional()
     }).optional(),
-    certification: import_zod13.z.any().optional()
+    certification: import_zod14.z.any().optional()
   }).optional()
 });
 
 // src/services/practitioner/practitioner.service.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var import_geofire_common2 = require("geofire-common");
 var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService) {
@@ -4270,7 +4289,7 @@ var PractitionerService = class extends BaseService {
       }
       return createdPractitioner;
     } catch (error) {
-      if (error instanceof import_zod14.z.ZodError) {
+      if (error instanceof import_zod15.z.ZodError) {
         throw new Error(`Invalid practitioner data: ${error.message}`);
       }
       console.error("Error creating practitioner:", error);
@@ -4383,7 +4402,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
-      if (error instanceof import_zod14.z.ZodError) {
+      if (error instanceof import_zod15.z.ZodError) {
         throw new Error("Invalid practitioner data: " + error.message);
       }
       throw error;
@@ -4436,7 +4455,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(this.db, tokenPath), token);
       return token;
     } catch (error) {
-      if (error instanceof import_zod14.z.ZodError) {
+      if (error instanceof import_zod15.z.ZodError) {
         throw new Error("Invalid token data: " + error.message);
       }
       throw error;
@@ -4623,7 +4642,7 @@ var PractitionerService = class extends BaseService {
       }
       return updatedPractitioner;
     } catch (error) {
-      if (error instanceof import_zod14.z.ZodError) {
+      if (error instanceof import_zod15.z.ZodError) {
         throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
       console.error(`Error updating practitioner ${practitionerId}:`, error);
@@ -5179,7 +5198,7 @@ var UserService = class extends BaseService {
       });
       return this.getUserById(uid);
     } catch (error) {
-      if (error instanceof import_zod15.z.ZodError) {
+      if (error instanceof import_zod16.z.ZodError) {
         throw USER_ERRORS.VALIDATION_ERROR;
       }
       throw error;
@@ -5266,7 +5285,7 @@ var UserService = class extends BaseService {
 // src/services/clinic/utils/clinic-group.utils.ts
 var import_firestore18 = require("firebase/firestore");
 var import_geofire_common3 = require("geofire-common");
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
 var import_storage4 = require("firebase/storage");
@@ -5464,7 +5483,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     });
     return groupData;
   } catch (error) {
-    if (error instanceof import_zod16.z.ZodError) {
+    if (error instanceof import_zod17.z.ZodError) {
       console.error(
         "[CLINIC_GROUP] Zod validation error:",
         JSON.stringify(error.errors, null, 2)
@@ -5869,17 +5888,54 @@ var ClinicGroupService = class extends BaseService {
   // but to add them to a subcollection called adminTokens that belongs to a specific clinicGroup document
   // TODO: Add granular control over admin permissions, e.g. only allow admins to manage certain clinics to tokens directly
   // TODO: Generally refactor admin tokens and invites, also create cloud function to send invites and send updates when sombody uses the token
+  /**
+   * Updates the onboarding status for a clinic group
+   *
+   * @param groupId - The ID of the clinic group to update
+   * @param onboardingData - The onboarding data to update
+   * @returns The updated clinic group
+   */
+  async setOnboarding(groupId, onboardingData) {
+    console.log("[CLINIC_GROUP] Updating onboarding status", {
+      groupId,
+      onboardingData
+    });
+    return this.updateClinicGroup(groupId, {
+      onboarding: onboardingData
+    });
+  }
+  /**
+   * Sets the current onboarding step for a clinic group
+   *
+   * @param groupId - The ID of the clinic group to update
+   * @param step - The current onboarding step number
+   * @returns The updated clinic group
+   */
+  async setOnboardingStep(groupId, step) {
+    console.log("[CLINIC_GROUP] Setting onboarding step", { groupId, step });
+    return this.setOnboarding(groupId, { step, completed: false });
+  }
+  /**
+   * Marks the onboarding process as completed for a clinic group
+   *
+   * @param groupId - The ID of the clinic group to update
+   * @returns The updated clinic group
+   */
+  async completeOnboarding(groupId) {
+    console.log("[CLINIC_GROUP] Completing onboarding", { groupId });
+    return this.setOnboarding(groupId, { completed: true });
+  }
 };
 
 // src/services/clinic/clinic.service.ts
 var import_firestore24 = require("firebase/firestore");
 var import_geofire_common7 = require("geofire-common");
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/services/clinic/utils/clinic.utils.ts
 var import_firestore19 = require("firebase/firestore");
 var import_geofire_common4 = require("geofire-common");
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 async function getClinic(db, clinicId) {
   const docRef = (0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId);
   const docSnap = await (0, import_firestore19.getDoc)(docRef);
@@ -6941,7 +6997,7 @@ var ClinicService = class extends BaseService {
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         throw new Error("Invalid clinic data: " + error.message);
       }
       console.error("Error creating clinic:", error);
@@ -7021,7 +7077,7 @@ var ClinicService = class extends BaseService {
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
-      if (error instanceof import_zod18.z.ZodError) {
+      if (error instanceof import_zod19.z.ZodError) {
         throw new Error("Invalid clinic update data: " + error.message);
       }
       console.error(`Error updating clinic ${clinicId}:`, error);
@@ -7038,6 +7094,16 @@ var ClinicService = class extends BaseService {
       updatedAt: (0, import_firestore24.serverTimestamp)()
     });
   }
+  /**
+   * Activates a clinic.
+   */
+  async activateClinic(clinicId, adminId) {
+    const clinicRef = (0, import_firestore24.doc)(this.db, CLINICS_COLLECTION, clinicId);
+    await (0, import_firestore24.updateDoc)(clinicRef, {
+      isActive: true,
+      updatedAt: (0, import_firestore24.serverTimestamp)()
+    });
+  }
   /**
    * Dohvata kliniku po ID-u
    */
@@ -7343,7 +7409,11 @@ var AuthService = class extends BaseService {
           // Use admin profile ID, not user UID
           isActive: true,
           logo: data.clinicGroupData.logo || null,
-          subscriptionModel: data.clinicGroupData.subscriptionModel || "no_subscription" /* NO_SUBSCRIPTION */
+          subscriptionModel: data.clinicGroupData.subscriptionModel || "no_subscription" /* NO_SUBSCRIPTION */,
+          onboarding: {
+            completed: false,
+            step: 1
+          }
         };
         console.log("[AUTH] Clinic group data prepared", {
           groupName: createClinicGroupData.name
@@ -7483,7 +7553,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof import_zod19.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -7658,7 +7728,7 @@ var AuthService = class extends BaseService {
         email
       );
     } catch (error) {
-      if (error instanceof import_zod19.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -7781,7 +7851,7 @@ var AuthService = class extends BaseService {
       await emailSchema.parseAsync(email);
       await (0, import_auth5.sendPasswordResetEmail)(this.auth, email);
     } catch (error) {
-      if (error instanceof import_zod19.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -7820,7 +7890,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_zod19.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -7989,7 +8059,7 @@ var AuthService = class extends BaseService {
         practitioner
       };
     } catch (error) {
-      if (error instanceof import_zod19.z.ZodError) {
+      if (error instanceof import_zod20.z.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpPractitioner:",
           JSON.stringify(error.errors, null, 2)
@@ -8267,63 +8337,63 @@ var import_firestore27 = require("firebase/firestore");
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-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),
+var import_zod21 = require("zod");
+var createProcedureSchema = import_zod21.z.object({
+  name: import_zod21.z.string().min(1).max(200),
+  description: import_zod21.z.string().min(1).max(2e3),
+  family: import_zod21.z.nativeEnum(ProcedureFamily),
+  categoryId: import_zod21.z.string().min(1),
+  subcategoryId: import_zod21.z.string().min(1),
+  technologyId: import_zod21.z.string().min(1),
+  productId: import_zod21.z.string().min(1),
+  price: import_zod21.z.number().min(0),
+  currency: import_zod21.z.nativeEnum(Currency),
+  pricingMeasure: import_zod21.z.nativeEnum(PricingMeasure),
+  duration: import_zod21.z.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: import_zod20.z.string().min(1),
-  clinicBranchId: import_zod20.z.string().min(1),
-  photos: import_zod20.z.array(import_zod20.z.string()).optional()
+  practitionerId: import_zod21.z.string().min(1),
+  clinicBranchId: import_zod21.z.string().min(1),
+  photos: import_zod21.z.array(import_zod21.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(),
-  photos: import_zod20.z.array(import_zod20.z.string()).optional()
+var updateProcedureSchema = import_zod21.z.object({
+  name: import_zod21.z.string().min(3).max(100).optional(),
+  description: import_zod21.z.string().min(3).max(1e3).optional(),
+  price: import_zod21.z.number().min(0).optional(),
+  currency: import_zod21.z.nativeEnum(Currency).optional(),
+  pricingMeasure: import_zod21.z.nativeEnum(PricingMeasure).optional(),
+  duration: import_zod21.z.number().min(0).optional(),
+  isActive: import_zod21.z.boolean().optional(),
+  practitionerId: import_zod21.z.string().optional(),
+  categoryId: import_zod21.z.string().optional(),
+  subcategoryId: import_zod21.z.string().optional(),
+  technologyId: import_zod21.z.string().optional(),
+  productId: import_zod21.z.string().optional(),
+  clinicBranchId: import_zod21.z.string().optional(),
+  photos: import_zod21.z.array(import_zod21.z.string()).optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: import_zod20.z.string().min(1),
-  category: import_zod20.z.any(),
+  id: import_zod21.z.string().min(1),
+  category: import_zod21.z.any(),
   // We'll validate the full category object separately
-  subcategory: import_zod20.z.any(),
+  subcategory: import_zod21.z.any(),
   // We'll validate the full subcategory object separately
-  technology: import_zod20.z.any(),
+  technology: import_zod21.z.any(),
   // We'll validate the full technology object separately
-  product: import_zod20.z.any(),
+  product: import_zod21.z.any(),
   // We'll validate the full product object separately
-  blockingConditions: import_zod20.z.array(import_zod20.z.any()),
+  blockingConditions: import_zod21.z.array(import_zod21.z.any()),
   // We'll validate blocking conditions separately
-  contraindications: import_zod20.z.array(import_zod20.z.any()),
+  contraindications: import_zod21.z.array(import_zod21.z.any()),
   // We'll validate contraindications separately
-  treatmentBenefits: import_zod20.z.array(import_zod20.z.any()),
+  treatmentBenefits: import_zod21.z.array(import_zod21.z.any()),
   // We'll validate treatment benefits separately
-  preRequirements: import_zod20.z.array(import_zod20.z.any()),
+  preRequirements: import_zod21.z.array(import_zod21.z.any()),
   // We'll validate requirements separately
-  postRequirements: import_zod20.z.array(import_zod20.z.any()),
+  postRequirements: import_zod21.z.array(import_zod21.z.any()),
   // We'll validate requirements separately
-  certificationRequirement: import_zod20.z.any(),
+  certificationRequirement: import_zod21.z.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: import_zod20.z.array(import_zod20.z.any()),
+  documentationTemplates: import_zod21.z.array(import_zod21.z.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -8331,9 +8401,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: import_zod20.z.boolean(),
-  createdAt: import_zod20.z.date(),
-  updatedAt: import_zod20.z.date()
+  isActive: import_zod21.z.boolean(),
+  createdAt: import_zod21.z.date(),
+  updatedAt: import_zod21.z.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -9508,42 +9578,42 @@ var SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 var import_firestore40 = require("firebase/firestore");
 
 // src/validations/calendar.schema.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 var import_firestore31 = require("firebase/firestore");
 
 // src/validations/profile-info.schema.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var import_firestore30 = require("firebase/firestore");
-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(),
+var clinicInfoSchema2 = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  featuredPhoto: import_zod22.z.string(),
+  name: import_zod22.z.string(),
+  description: import_zod22.z.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-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(),
+var practitionerProfileInfoSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  practitionerPhoto: import_zod22.z.string().nullable(),
+  name: import_zod22.z.string(),
+  email: import_zod22.z.string().email(),
+  phone: import_zod22.z.string().nullable(),
   certification: practitionerCertificationSchema
 });
-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_firestore30.Timestamp),
-  gender: import_zod21.z.nativeEnum(Gender)
+var patientProfileInfoSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  fullName: import_zod22.z.string(),
+  email: import_zod22.z.string().email(),
+  phone: import_zod22.z.string().nullable(),
+  dateOfBirth: import_zod22.z.instanceof(import_firestore30.Timestamp),
+  gender: import_zod22.z.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = import_zod22.z.object({
-  start: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore31.Timestamp)),
-  end: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore31.Timestamp))
+var calendarEventTimeSchema = import_zod23.z.object({
+  start: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore31.Timestamp)),
+  end: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore31.Timestamp))
 }).refine(
   (data) => {
     const startDate = data.start instanceof import_firestore31.Timestamp ? data.start.toDate() : data.start;
@@ -9564,46 +9634,46 @@ var calendarEventTimeSchema = import_zod22.z.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = import_zod22.z.object({
-  start: import_zod22.z.date(),
-  end: import_zod22.z.date(),
-  isAvailable: import_zod22.z.boolean()
+var timeSlotSchema2 = import_zod23.z.object({
+  start: import_zod23.z.date(),
+  end: import_zod23.z.date(),
+  isAvailable: import_zod23.z.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-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_firestore31.Timestamp))
+var syncedCalendarEventSchema = import_zod23.z.object({
+  eventId: import_zod23.z.string(),
+  syncedCalendarProvider: import_zod23.z.nativeEnum(SyncedCalendarProvider),
+  syncedAt: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore31.Timestamp))
 });
-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 procedureInfoSchema = import_zod23.z.object({
+  name: import_zod23.z.string(),
+  description: import_zod23.z.string(),
+  duration: import_zod23.z.number().min(MIN_APPOINTMENT_DURATION),
+  price: import_zod23.z.number().min(0),
+  currency: import_zod23.z.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = import_zod22.z.object({
-  procedureFamily: import_zod22.z.string(),
+var procedureCategorizationSchema = import_zod23.z.object({
+  procedureFamily: import_zod23.z.string(),
   // Replace with proper enum when available
-  procedureCategory: import_zod22.z.string(),
+  procedureCategory: import_zod23.z.string(),
   // Replace with proper enum when available
-  procedureSubcategory: import_zod22.z.string(),
+  procedureSubcategory: import_zod23.z.string(),
   // Replace with proper enum when available
-  procedureTechnology: import_zod22.z.string(),
+  procedureTechnology: import_zod23.z.string(),
   // Replace with proper enum when available
-  procedureProduct: import_zod22.z.string()
+  procedureProduct: import_zod23.z.string()
   // Replace with proper enum when available
 });
-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"),
+var createAppointmentSchema2 = import_zod23.z.object({
+  clinicId: import_zod23.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod23.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod23.z.string().min(1, "Patient ID is required"),
+  procedureId: import_zod23.z.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: import_zod22.z.string().optional()
+  description: import_zod23.z.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -9612,73 +9682,73 @@ var createAppointmentSchema2 = import_zod22.z.object({
     message: "Invalid appointment parameters"
   }
 );
-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"),
+var updateAppointmentSchema2 = import_zod23.z.object({
+  appointmentId: import_zod23.z.string().min(1, "Appointment ID is required"),
+  clinicId: import_zod23.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod23.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod23.z.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod22.z.string().optional(),
-  status: import_zod22.z.nativeEnum(CalendarEventStatus).optional()
+  description: import_zod23.z.string().optional(),
+  status: import_zod23.z.nativeEnum(CalendarEventStatus).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(),
+var createCalendarEventSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  clinicBranchId: import_zod23.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod23.z.any().nullable().optional(),
+  practitionerProfileId: import_zod23.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod22.z.string().nullable().optional(),
+  patientProfileId: import_zod23.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  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"),
+  procedureId: import_zod23.z.string().nullable().optional(),
+  appointmentId: import_zod23.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod23.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod23.z.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  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(),
+  description: import_zod23.z.string().optional(),
+  status: import_zod23.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod23.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod23.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod23.z.any(),
   // FieldValue for server timestamp
-  updatedAt: import_zod22.z.any()
+  updatedAt: import_zod23.z.any()
   // FieldValue for server timestamp
 });
-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(),
+var updateCalendarEventSchema = import_zod23.z.object({
+  syncedCalendarEventId: import_zod23.z.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: import_zod23.z.string().nullable().optional(),
+  eventName: import_zod23.z.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  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()
+  description: import_zod23.z.string().optional(),
+  status: import_zod23.z.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: import_zod23.z.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: import_zod23.z.nativeEnum(CalendarEventType).optional(),
+  updatedAt: import_zod23.z.any()
   // FieldValue for server timestamp
 });
-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(),
+var calendarEventSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  clinicBranchId: import_zod23.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod23.z.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: import_zod22.z.string().nullable().optional(),
+  practitionerProfileId: import_zod23.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod22.z.string().nullable().optional(),
+  patientProfileId: import_zod23.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod22.z.string().nullable().optional(),
+  procedureId: import_zod23.z.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: import_zod22.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod22.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod22.z.string(),
+  appointmentId: import_zod23.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod23.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod23.z.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  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_firestore31.Timestamp)),
-  updatedAt: import_zod22.z.instanceof(Date).or(import_zod22.z.instanceof(import_firestore31.Timestamp))
+  description: import_zod23.z.string().optional(),
+  status: import_zod23.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod23.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod23.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore31.Timestamp)),
+  updatedAt: import_zod23.z.instanceof(Date).or(import_zod23.z.instanceof(import_firestore31.Timestamp))
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -12218,13 +12288,13 @@ var import_firestore41 = require("firebase/firestore");
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
   }
   /**
-   * Creates a new review and updates related entities
+   * Creates a new review
    * @param data - The review data to create
    * @param appointmentId - ID of the completed appointment
    * @returns The created review
@@ -12303,28 +12373,9 @@ var ReviewService = class extends BaseService {
         createdAt: (0, import_firestore41.serverTimestamp)(),
         updatedAt: (0, import_firestore41.serverTimestamp)()
       });
-      const updatePromises = [];
-      if (data.clinicReview) {
-        updatePromises.push(
-          this.updateClinicReviewInfo(data.clinicReview.clinicId)
-        );
-      }
-      if (data.practitionerReview) {
-        updatePromises.push(
-          this.updatePractitionerReviewInfo(
-            data.practitionerReview.practitionerId
-          )
-        );
-      }
-      if (data.procedureReview) {
-        updatePromises.push(
-          this.updateProcedureReviewInfo(data.procedureReview.procedureId)
-        );
-      }
-      await Promise.all(updatePromises);
       return review;
     } catch (error) {
-      if (error instanceof import_zod23.z.ZodError) {
+      if (error instanceof import_zod24.z.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -12412,7 +12463,7 @@ var ReviewService = class extends BaseService {
     return snapshot.docs[0].data();
   }
   /**
-   * Deletes a review and updates related entities
+   * Deletes a review
    * @param reviewId The ID of the review to delete
    */
   async deleteReview(reviewId) {
@@ -12421,389 +12472,6 @@ var ReviewService = class extends BaseService {
       throw new Error(`Review with ID ${reviewId} not found`);
     }
     await (0, import_firestore41.deleteDoc)((0, import_firestore41.doc)(this.db, REVIEWS_COLLECTION, reviewId));
-    const updatePromises = [];
-    if (review.clinicReview) {
-      updatePromises.push(
-        this.updateClinicReviewInfo(
-          review.clinicReview.clinicId,
-          review.clinicReview,
-          true
-        )
-      );
-    }
-    if (review.practitionerReview) {
-      updatePromises.push(
-        this.updatePractitionerReviewInfo(
-          review.practitionerReview.practitionerId,
-          review.practitionerReview,
-          true
-        )
-      );
-    }
-    if (review.procedureReview) {
-      updatePromises.push(
-        this.updateProcedureReviewInfo(
-          review.procedureReview.procedureId,
-          review.procedureReview,
-          true
-        )
-      );
-    }
-    await Promise.all(updatePromises);
-  }
-  /**
-   * Updates the review info for a clinic
-   * @param clinicId The ID of the clinic to update
-   * @param newReview Optional new review being added or removed
-   * @param isRemoval Whether this update is for a review removal
-   * @returns The updated clinic review info
-   */
-  async updateClinicReviewInfo(clinicId, newReview, isRemoval = false) {
-    const clinicDoc = await (0, import_firestore41.getDoc)((0, import_firestore41.doc)(this.db, CLINICS_COLLECTION, clinicId));
-    if (!clinicDoc.exists()) {
-      throw new Error(`Clinic with ID ${clinicId} not found`);
-    }
-    const clinicData = clinicDoc.data();
-    const currentReviewInfo = clinicData.reviewInfo || {
-      totalReviews: 0,
-      averageRating: 0,
-      cleanliness: 0,
-      facilities: 0,
-      staffFriendliness: 0,
-      waitingTime: 0,
-      accessibility: 0,
-      recommendationPercentage: 0
-    };
-    if (currentReviewInfo.totalReviews === 0 && !newReview) {
-      await (0, import_firestore41.updateDoc)((0, import_firestore41.doc)(this.db, CLINICS_COLLECTION, clinicId), {
-        reviewInfo: currentReviewInfo,
-        updatedAt: (0, import_firestore41.serverTimestamp)()
-      });
-      return currentReviewInfo;
-    }
-    let updatedReviewInfo;
-    if (newReview) {
-      const oldTotal = currentReviewInfo.totalReviews;
-      const newTotal = isRemoval ? oldTotal - 1 : oldTotal + 1;
-      if (newTotal === 0) {
-        updatedReviewInfo = {
-          totalReviews: 0,
-          averageRating: 0,
-          cleanliness: 0,
-          facilities: 0,
-          staffFriendliness: 0,
-          waitingTime: 0,
-          accessibility: 0,
-          recommendationPercentage: 0
-        };
-      } else {
-        const updateAverage = (currentAvg, newValue) => {
-          const currentSum = currentAvg * oldTotal;
-          const newSum = isRemoval ? currentSum - newValue : currentSum + newValue;
-          const newAvg = newSum / newTotal;
-          return Math.round(newAvg * 10) / 10;
-        };
-        const currentRecommendations = currentReviewInfo.recommendationPercentage / 100 * oldTotal;
-        const newRecommendations = isRemoval ? newReview.wouldRecommend ? currentRecommendations - 1 : currentRecommendations : newReview.wouldRecommend ? currentRecommendations + 1 : currentRecommendations;
-        const newRecommendationPercentage = newRecommendations / newTotal * 100;
-        updatedReviewInfo = {
-          totalReviews: newTotal,
-          averageRating: updateAverage(
-            currentReviewInfo.averageRating,
-            newReview.overallRating
-          ),
-          cleanliness: updateAverage(
-            currentReviewInfo.cleanliness,
-            newReview.cleanliness
-          ),
-          facilities: updateAverage(
-            currentReviewInfo.facilities,
-            newReview.facilities
-          ),
-          staffFriendliness: updateAverage(
-            currentReviewInfo.staffFriendliness,
-            newReview.staffFriendliness
-          ),
-          waitingTime: updateAverage(
-            currentReviewInfo.waitingTime,
-            newReview.waitingTime
-          ),
-          accessibility: updateAverage(
-            currentReviewInfo.accessibility,
-            newReview.accessibility
-          ),
-          recommendationPercentage: Math.round(newRecommendationPercentage * 10) / 10
-        };
-      }
-    } else {
-      updatedReviewInfo = { ...currentReviewInfo };
-    }
-    await (0, import_firestore41.updateDoc)((0, import_firestore41.doc)(this.db, CLINICS_COLLECTION, clinicId), {
-      reviewInfo: updatedReviewInfo,
-      updatedAt: (0, import_firestore41.serverTimestamp)()
-    });
-    return updatedReviewInfo;
-  }
-  /**
-   * Updates the review info for a practitioner
-   * @param practitionerId The ID of the practitioner to update
-   * @param newReview Optional new review being added or removed
-   * @param isRemoval Whether this update is for a review removal
-   * @returns The updated practitioner review info
-   */
-  async updatePractitionerReviewInfo(practitionerId, newReview, isRemoval = false) {
-    const practitionerDoc = await (0, import_firestore41.getDoc)(
-      (0, import_firestore41.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId)
-    );
-    if (!practitionerDoc.exists()) {
-      throw new Error(`Practitioner with ID ${practitionerId} not found`);
-    }
-    const practitionerData = practitionerDoc.data();
-    const currentReviewInfo = practitionerData.reviewInfo || {
-      totalReviews: 0,
-      averageRating: 0,
-      knowledgeAndExpertise: 0,
-      communicationSkills: 0,
-      bedSideManner: 0,
-      thoroughness: 0,
-      trustworthiness: 0,
-      recommendationPercentage: 0
-    };
-    if (currentReviewInfo.totalReviews === 0 && !newReview) {
-      await (0, import_firestore41.updateDoc)((0, import_firestore41.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId), {
-        reviewInfo: currentReviewInfo,
-        updatedAt: (0, import_firestore41.serverTimestamp)()
-      });
-      return currentReviewInfo;
-    }
-    let updatedReviewInfo;
-    if (newReview) {
-      const oldTotal = currentReviewInfo.totalReviews;
-      const newTotal = isRemoval ? oldTotal - 1 : oldTotal + 1;
-      if (newTotal === 0) {
-        updatedReviewInfo = {
-          totalReviews: 0,
-          averageRating: 0,
-          knowledgeAndExpertise: 0,
-          communicationSkills: 0,
-          bedSideManner: 0,
-          thoroughness: 0,
-          trustworthiness: 0,
-          recommendationPercentage: 0
-        };
-      } else {
-        const updateAverage = (currentAvg, newValue) => {
-          const currentSum = currentAvg * oldTotal;
-          const newSum = isRemoval ? currentSum - newValue : currentSum + newValue;
-          const newAvg = newSum / newTotal;
-          return Math.round(newAvg * 10) / 10;
-        };
-        const currentRecommendations = currentReviewInfo.recommendationPercentage / 100 * oldTotal;
-        const newRecommendations = isRemoval ? newReview.wouldRecommend ? currentRecommendations - 1 : currentRecommendations : newReview.wouldRecommend ? currentRecommendations + 1 : currentRecommendations;
-        const newRecommendationPercentage = newRecommendations / newTotal * 100;
-        updatedReviewInfo = {
-          totalReviews: newTotal,
-          averageRating: updateAverage(
-            currentReviewInfo.averageRating,
-            newReview.overallRating
-          ),
-          knowledgeAndExpertise: updateAverage(
-            currentReviewInfo.knowledgeAndExpertise,
-            newReview.knowledgeAndExpertise
-          ),
-          communicationSkills: updateAverage(
-            currentReviewInfo.communicationSkills,
-            newReview.communicationSkills
-          ),
-          bedSideManner: updateAverage(
-            currentReviewInfo.bedSideManner,
-            newReview.bedSideManner
-          ),
-          thoroughness: updateAverage(
-            currentReviewInfo.thoroughness,
-            newReview.thoroughness
-          ),
-          trustworthiness: updateAverage(
-            currentReviewInfo.trustworthiness,
-            newReview.trustworthiness
-          ),
-          recommendationPercentage: Math.round(newRecommendationPercentage * 10) / 10
-        };
-      }
-    } else {
-      updatedReviewInfo = { ...currentReviewInfo };
-    }
-    await (0, import_firestore41.updateDoc)((0, import_firestore41.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId), {
-      reviewInfo: updatedReviewInfo,
-      updatedAt: (0, import_firestore41.serverTimestamp)()
-    });
-    await this.updateDoctorInfoInProcedures(
-      practitionerId,
-      updatedReviewInfo.averageRating
-    );
-    return updatedReviewInfo;
-  }
-  /**
-   * Updates the review info for a procedure
-   * @param procedureId The ID of the procedure to update
-   * @param newReview Optional new review being added or removed
-   * @param isRemoval Whether this update is for a review removal
-   * @returns The updated procedure review info
-   */
-  async updateProcedureReviewInfo(procedureId, newReview, isRemoval = false) {
-    const procedureDoc = await (0, import_firestore41.getDoc)(
-      (0, import_firestore41.doc)(this.db, PROCEDURES_COLLECTION, procedureId)
-    );
-    if (!procedureDoc.exists()) {
-      throw new Error(`Procedure with ID ${procedureId} not found`);
-    }
-    const procedureData = procedureDoc.data();
-    const currentReviewInfo = procedureData.reviewInfo || {
-      totalReviews: 0,
-      averageRating: 0,
-      effectivenessOfTreatment: 0,
-      outcomeExplanation: 0,
-      painManagement: 0,
-      followUpCare: 0,
-      valueForMoney: 0,
-      recommendationPercentage: 0
-    };
-    if (currentReviewInfo.totalReviews === 0 && !newReview) {
-      await (0, import_firestore41.updateDoc)((0, import_firestore41.doc)(this.db, PROCEDURES_COLLECTION, procedureId), {
-        reviewInfo: currentReviewInfo,
-        updatedAt: (0, import_firestore41.serverTimestamp)()
-      });
-      return currentReviewInfo;
-    }
-    let updatedReviewInfo;
-    if (newReview) {
-      const oldTotal = currentReviewInfo.totalReviews;
-      const newTotal = isRemoval ? oldTotal - 1 : oldTotal + 1;
-      if (newTotal === 0) {
-        updatedReviewInfo = {
-          totalReviews: 0,
-          averageRating: 0,
-          effectivenessOfTreatment: 0,
-          outcomeExplanation: 0,
-          painManagement: 0,
-          followUpCare: 0,
-          valueForMoney: 0,
-          recommendationPercentage: 0
-        };
-      } else {
-        const updateAverage = (currentAvg, newValue) => {
-          const currentSum = currentAvg * oldTotal;
-          const newSum = isRemoval ? currentSum - newValue : currentSum + newValue;
-          const newAvg = newSum / newTotal;
-          return Math.round(newAvg * 10) / 10;
-        };
-        const currentRecommendations = currentReviewInfo.recommendationPercentage / 100 * oldTotal;
-        const newRecommendations = isRemoval ? newReview.wouldRecommend ? currentRecommendations - 1 : currentRecommendations : newReview.wouldRecommend ? currentRecommendations + 1 : currentRecommendations;
-        const newRecommendationPercentage = newRecommendations / newTotal * 100;
-        updatedReviewInfo = {
-          totalReviews: newTotal,
-          averageRating: updateAverage(
-            currentReviewInfo.averageRating,
-            newReview.overallRating
-          ),
-          effectivenessOfTreatment: updateAverage(
-            currentReviewInfo.effectivenessOfTreatment,
-            newReview.effectivenessOfTreatment
-          ),
-          outcomeExplanation: updateAverage(
-            currentReviewInfo.outcomeExplanation,
-            newReview.outcomeExplanation
-          ),
-          painManagement: updateAverage(
-            currentReviewInfo.painManagement,
-            newReview.painManagement
-          ),
-          followUpCare: updateAverage(
-            currentReviewInfo.followUpCare,
-            newReview.followUpCare
-          ),
-          valueForMoney: updateAverage(
-            currentReviewInfo.valueForMoney,
-            newReview.valueForMoney
-          ),
-          recommendationPercentage: Math.round(newRecommendationPercentage * 10) / 10
-        };
-      }
-    } else {
-      updatedReviewInfo = { ...currentReviewInfo };
-    }
-    await (0, import_firestore41.updateDoc)((0, import_firestore41.doc)(this.db, PROCEDURES_COLLECTION, procedureId), {
-      reviewInfo: updatedReviewInfo,
-      updatedAt: (0, import_firestore41.serverTimestamp)()
-    });
-    return updatedReviewInfo;
-  }
-  /**
-   * Updates doctorInfo rating in all procedures for a practitioner
-   * @param practitionerId The ID of the practitioner
-   * @param rating The new rating to set
-   */
-  async updateDoctorInfoInProcedures(practitionerId, rating) {
-    const q = (0, import_firestore41.query)(
-      (0, import_firestore41.collection)(this.db, PROCEDURES_COLLECTION),
-      (0, import_firestore41.where)("practitionerId", "==", practitionerId)
-    );
-    const snapshot = await (0, import_firestore41.getDocs)(q);
-    if (snapshot.empty) {
-      return;
-    }
-    const batch = (0, import_firestore41.writeBatch)(this.db);
-    snapshot.docs.forEach((docSnapshot) => {
-      const procedureRef = (0, import_firestore41.doc)(this.db, PROCEDURES_COLLECTION, docSnapshot.id);
-      batch.update(procedureRef, {
-        "doctorInfo.rating": rating,
-        updatedAt: (0, import_firestore41.serverTimestamp)()
-      });
-    });
-    await batch.commit();
-  }
-  /**
-   * Verifies a review as checked by admin/staff
-   * @param reviewId The ID of the review to verify
-   */
-  async verifyReview(reviewId) {
-    const review = await this.getReview(reviewId);
-    if (!review) {
-      throw new Error(`Review with ID ${reviewId} not found`);
-    }
-    const batch = (0, import_firestore41.writeBatch)(this.db);
-    batch.update((0, import_firestore41.doc)(this.db, REVIEWS_COLLECTION, reviewId), {
-      updatedAt: (0, import_firestore41.serverTimestamp)()
-    });
-    if (review.clinicReview) {
-      review.clinicReview.isVerified = true;
-    }
-    if (review.practitionerReview) {
-      review.practitionerReview.isVerified = true;
-    }
-    if (review.procedureReview) {
-      review.procedureReview.isVerified = true;
-    }
-    await batch.commit();
-    const updatePromises = [];
-    if (review.clinicReview) {
-      updatePromises.push(
-        this.updateClinicReviewInfo(review.clinicReview.clinicId)
-      );
-    }
-    if (review.practitionerReview) {
-      updatePromises.push(
-        this.updatePractitionerReviewInfo(
-          review.practitionerReview.practitionerId
-        )
-      );
-    }
-    if (review.procedureReview) {
-      updatePromises.push(
-        this.updateProcedureReviewInfo(review.procedureReview.procedureId)
-      );
-    }
-    await Promise.all(updatePromises);
   }
   /**
    * Calculates the average of an array of numbers
@@ -14867,63 +14535,63 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-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(),
+var import_zod25 = require("zod");
+var baseNotificationSchema = import_zod25.z.object({
+  id: import_zod25.z.string().optional(),
+  userId: import_zod25.z.string(),
+  notificationTime: import_zod25.z.any(),
   // Timestamp
-  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(),
+  notificationType: import_zod25.z.nativeEnum(NotificationType),
+  notificationTokens: import_zod25.z.array(import_zod25.z.string()),
+  status: import_zod25.z.nativeEnum(NotificationStatus),
+  createdAt: import_zod25.z.any().optional(),
   // Timestamp
-  updatedAt: import_zod24.z.any().optional(),
+  updatedAt: import_zod25.z.any().optional(),
   // Timestamp
-  title: import_zod24.z.string(),
-  body: import_zod24.z.string(),
-  isRead: import_zod24.z.boolean(),
-  userRole: import_zod24.z.nativeEnum(UserRole)
+  title: import_zod25.z.string(),
+  body: import_zod25.z.string(),
+  isRead: import_zod25.z.boolean(),
+  userRole: import_zod25.z.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
-  treatmentId: import_zod24.z.string(),
-  requirements: import_zod24.z.array(import_zod24.z.string()),
-  deadline: import_zod24.z.any()
+  notificationType: import_zod25.z.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
+  treatmentId: import_zod25.z.string(),
+  requirements: import_zod25.z.array(import_zod25.z.string()),
+  deadline: import_zod25.z.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal(
+  notificationType: import_zod25.z.literal(
     "postRequirementInstructionDue" /* POST_REQUIREMENT_INSTRUCTION_DUE */
   ),
-  treatmentId: import_zod24.z.string(),
-  requirements: import_zod24.z.array(import_zod24.z.string()),
-  deadline: import_zod24.z.any()
+  treatmentId: import_zod25.z.string(),
+  requirements: import_zod25.z.array(import_zod25.z.string()),
+  deadline: import_zod25.z.any()
   // Timestamp
 });
 var requirementInstructionDueNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
-  appointmentId: import_zod24.z.string(),
-  patientRequirementInstanceId: import_zod24.z.string(),
-  instructionId: import_zod24.z.string(),
-  originalRequirementId: import_zod24.z.string().optional()
+  notificationType: import_zod25.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
+  appointmentId: import_zod25.z.string(),
+  patientRequirementInstanceId: import_zod25.z.string(),
+  instructionId: import_zod25.z.string(),
+  originalRequirementId: import_zod25.z.string().optional()
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: import_zod24.z.string(),
-  appointmentTime: import_zod24.z.any(),
+  notificationType: import_zod25.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: import_zod25.z.string(),
+  appointmentTime: import_zod25.z.any(),
   // Timestamp
-  treatmentType: import_zod24.z.string(),
-  doctorName: import_zod24.z.string()
+  treatmentType: import_zod25.z.string(),
+  doctorName: import_zod25.z.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod24.z.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
-  appointmentId: import_zod24.z.string(),
-  appointmentStatus: import_zod24.z.string(),
-  previousStatus: import_zod24.z.string(),
-  reason: import_zod24.z.string().optional()
+  notificationType: import_zod25.z.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
+  appointmentId: import_zod25.z.string(),
+  appointmentStatus: import_zod25.z.string(),
+  previousStatus: import_zod25.z.string(),
+  reason: import_zod25.z.string().optional()
 });
-var notificationSchema = import_zod24.z.discriminatedUnion("notificationType", [
+var notificationSchema = import_zod25.z.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   requirementInstructionDueNotificationSchema,