@blackcode_sa/metaestetics-api 1.8.7 → 1.8.9

package/dist/index.js

@@ -120,166 +120,21 @@ __export(index_exports, {
   SubcategoryService: () => SubcategoryService,
   SubscriptionModel: () => SubscriptionModel,
   SyncedCalendarProvider: () => SyncedCalendarProvider,
+  SyncedCalendarsService: () => SyncedCalendarsService,
   TechnologyService: () => TechnologyService,
   TimeUnit: () => TimeUnit,
-  TimestampUtils: () => TimestampUtils,
   TreatmentBenefit: () => TreatmentBenefit,
   USERS_COLLECTION: () => USERS_COLLECTION,
   USER_FORMS_SUBCOLLECTION: () => USER_FORMS_SUBCOLLECTION,
   UserRole: () => UserRole,
   UserService: () => UserService,
-  addAllergySchema: () => addAllergySchema,
-  addBlockingConditionSchema: () => addBlockingConditionSchema,
-  addContraindicationSchema: () => addContraindicationSchema,
-  addMedicationSchema: () => addMedicationSchema,
-  addressDataSchema: () => addressDataSchema,
-  adminInfoSchema: () => adminInfoSchema,
-  adminTokenSchema: () => adminTokenSchema,
-  allergySchema: () => allergySchema,
-  allergySubtypeSchema: () => allergySubtypeSchema,
-  appointmentMediaItemSchema: () => appointmentMediaItemSchema,
-  appointmentMetadataSchema: () => appointmentMetadataSchema,
-  appointmentNotificationSchema: () => appointmentNotificationSchema,
-  appointmentReminderNotificationSchema: () => appointmentReminderNotificationSchema,
-  appointmentStatusSchema: () => appointmentStatusSchema,
-  baseNotificationSchema: () => baseNotificationSchema,
-  beforeAfterPerZoneSchema: () => beforeAfterPerZoneSchema,
-  billingPerZoneSchema: () => billingPerZoneSchema,
-  blockingConditionSchema: () => blockingConditionSchema,
-  calendarEventSchema: () => calendarEventSchema,
-  calendarEventTimeSchema: () => calendarEventTimeSchema,
-  clinicAdminOptionsSchema: () => clinicAdminOptionsSchema,
-  clinicAdminSchema: () => clinicAdminSchema,
-  clinicAdminSignupSchema: () => clinicAdminSignupSchema,
-  clinicBranchInfoSchema: () => clinicBranchInfoSchema,
-  clinicBranchSetupSchema: () => clinicBranchSetupSchema,
-  clinicContactInfoSchema: () => clinicContactInfoSchema,
-  clinicGroupSchema: () => clinicGroupSchema,
-  clinicGroupSetupSchema: () => clinicGroupSetupSchema,
-  clinicInfoSchema: () => clinicInfoSchema,
-  clinicLocationSchema: () => clinicLocationSchema,
-  clinicReviewInfoSchema: () => clinicReviewInfoSchema,
-  clinicReviewSchema: () => clinicReviewSchema,
-  clinicSchema: () => clinicSchema,
-  clinicTagsSchema: () => clinicTagsSchema,
-  contactPersonSchema: () => contactPersonSchema,
-  contraindicationSchema: () => contraindicationSchema,
-  createAdminTokenSchema: () => createAdminTokenSchema,
-  createAppointmentSchema: () => createAppointmentSchema,
-  createBlockingEventSchema: () => createBlockingEventSchema,
-  createCalendarEventSchema: () => createCalendarEventSchema,
-  createClinicAdminSchema: () => createClinicAdminSchema,
-  createClinicGroupSchema: () => createClinicGroupSchema,
-  createClinicReviewSchema: () => createClinicReviewSchema,
-  createClinicSchema: () => createClinicSchema,
-  createDefaultClinicGroupSchema: () => createDefaultClinicGroupSchema,
-  createDocumentTemplateSchema: () => createDocumentTemplateSchema,
-  createDraftPractitionerSchema: () => createDraftPractitionerSchema,
-  createFilledDocumentDataSchema: () => createFilledDocumentDataSchema,
-  createManualPatientSchema: () => createManualPatientSchema,
-  createPatientLocationInfoSchema: () => createPatientLocationInfoSchema,
-  createPatientMedicalInfoSchema: () => createPatientMedicalInfoSchema,
-  createPatientProfileSchema: () => createPatientProfileSchema,
-  createPatientSensitiveInfoSchema: () => createPatientSensitiveInfoSchema,
-  createPatientTokenSchema: () => createPatientTokenSchema,
-  createPractitionerReviewSchema: () => createPractitionerReviewSchema,
-  createPractitionerSchema: () => createPractitionerSchema,
-  createPractitionerTokenSchema: () => createPractitionerTokenSchema,
-  createProcedureReviewSchema: () => createProcedureReviewSchema,
-  createProcedureSchema: () => createProcedureSchema,
-  createReviewSchema: () => createReviewSchema,
-  createUserOptionsSchema: () => createUserOptionsSchema,
-  doctorInfoSchema: () => doctorInfoSchema,
-  documentElementSchema: () => documentElementSchema,
-  documentElementWithoutIdSchema: () => documentElementWithoutIdSchema,
-  documentTemplateSchema: () => documentTemplateSchema,
-  emailSchema: () => emailSchema,
-  emergencyContactSchema: () => emergencyContactSchema,
-  filledDocumentSchema: () => filledDocumentSchema,
-  filledDocumentStatusSchema: () => filledDocumentStatusSchema,
-  finalBillingSchema: () => finalBillingSchema,
-  finalizedDetailsSchema: () => finalizedDetailsSchema,
-  gamificationSchema: () => gamificationSchema,
   getFirebaseApp: () => getFirebaseApp,
   getFirebaseAuth: () => getFirebaseAuth,
   getFirebaseDB: () => getFirebaseDB,
   getFirebaseFunctions: () => getFirebaseFunctions,
   getFirebaseInstance: () => getFirebaseInstance,
   getFirebaseStorage: () => getFirebaseStorage,
-  initializeFirebase: () => initializeFirebase,
-  linkedFormInfoSchema: () => linkedFormInfoSchema,
-  locationDataSchema: () => locationDataSchema,
-  mediaResourceSchema: () => mediaResourceSchema,
-  mediaTypeSchema: () => mediaTypeSchema,
-  medicationSchema: () => medicationSchema,
-  notificationSchema: () => notificationSchema,
-  passwordSchema: () => passwordSchema,
-  patientClinicSchema: () => patientClinicSchema,
-  patientDoctorSchema: () => patientDoctorSchema,
-  patientInstructionStatusSchema: () => patientInstructionStatusSchema,
-  patientLocationInfoSchema: () => patientLocationInfoSchema,
-  patientMedicalInfoSchema: () => patientMedicalInfoSchema,
-  patientProfileInfoSchema: () => patientProfileInfoSchema,
-  patientProfileSchema: () => patientProfileSchema,
-  patientRequirementInstanceSchema: () => patientRequirementInstanceSchema,
-  patientRequirementInstructionSchema: () => patientRequirementInstructionSchema,
-  patientRequirementOverallStatusSchema: () => patientRequirementOverallStatusSchema,
-  patientReviewInfoSchema: () => patientReviewInfoSchema,
-  patientSensitiveInfoSchema: () => patientSensitiveInfoSchema,
-  patientTokenSchema: () => patientTokenSchema,
-  paymentStatusSchema: () => paymentStatusSchema,
-  postRequirementNotificationSchema: () => postRequirementNotificationSchema,
-  practitionerBasicInfoSchema: () => practitionerBasicInfoSchema,
-  practitionerCertificationSchema: () => practitionerCertificationSchema,
-  practitionerClinicWorkingHoursSchema: () => practitionerClinicWorkingHoursSchema,
-  practitionerProfileInfoSchema: () => practitionerProfileInfoSchema,
-  practitionerReviewInfoSchema: () => practitionerReviewInfoSchema,
-  practitionerReviewSchema: () => practitionerReviewSchema,
-  practitionerSchema: () => practitionerSchema,
-  practitionerSignupSchema: () => practitionerSignupSchema,
-  practitionerTokenSchema: () => practitionerTokenSchema,
-  practitionerWorkingHoursSchema: () => practitionerWorkingHoursSchema,
-  preRequirementNotificationSchema: () => preRequirementNotificationSchema,
-  procedureCategorizationSchema: () => procedureCategorizationSchema,
-  procedureExtendedInfoSchema: () => procedureExtendedInfoSchema,
-  procedureInfoSchema: () => procedureInfoSchema,
-  procedureReviewInfoSchema: () => procedureReviewInfoSchema,
-  procedureReviewSchema: () => procedureReviewSchema,
-  procedureSchema: () => procedureSchema,
-  procedureSummaryInfoSchema: () => procedureSummaryInfoSchema,
-  requesterInfoSchema: () => requesterInfoSchema,
-  requirementImportanceSchema: () => requirementImportanceSchema,
-  requirementInstructionDueNotificationSchema: () => requirementInstructionDueNotificationSchema,
-  rescheduleAppointmentSchema: () => rescheduleAppointmentSchema,
-  reviewSchema: () => reviewSchema,
-  searchAppointmentsSchema: () => searchAppointmentsSchema,
-  searchPatientsSchema: () => searchPatientsSchema,
-  sharedClinicContactInfoSchema: () => sharedClinicContactInfoSchema,
-  sharedClinicLocationSchema: () => sharedClinicLocationSchema,
-  syncedCalendarEventSchema: () => syncedCalendarEventSchema,
-  timeSlotSchema: () => timeSlotSchema2,
-  timestampSchema: () => timestampSchema,
-  updateAllergySchema: () => updateAllergySchema,
-  updateAppointmentSchema: () => updateAppointmentSchema,
-  updateBlockingConditionSchema: () => updateBlockingConditionSchema,
-  updateBlockingEventSchema: () => updateBlockingEventSchema,
-  updateCalendarEventSchema: () => updateCalendarEventSchema,
-  updateClinicAdminSchema: () => updateClinicAdminSchema,
-  updateClinicGroupSchema: () => updateClinicGroupSchema,
-  updateClinicSchema: () => updateClinicSchema,
-  updateContraindicationSchema: () => updateContraindicationSchema,
-  updateDocumentTemplateSchema: () => updateDocumentTemplateSchema,
-  updateFilledDocumentDataSchema: () => updateFilledDocumentDataSchema,
-  updateMedicationSchema: () => updateMedicationSchema,
-  updatePatientInstructionStatusSchema: () => updatePatientInstructionStatusSchema,
-  updatePatientMedicalInfoSchema: () => updatePatientMedicalInfoSchema,
-  updateProcedureSchema: () => updateProcedureSchema,
-  updateVitalStatsSchema: () => updateVitalStatsSchema,
-  userRoleSchema: () => userRoleSchema,
-  userRolesSchema: () => userRolesSchema,
-  userSchema: () => userSchema,
-  vitalStatsSchema: () => vitalStatsSchema,
-  workingHoursSchema: () => workingHoursSchema
+  initializeFirebase: () => initializeFirebase
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -582,14 +437,14 @@ var updateFilledDocumentDataSchema = import_zod.z.object({
 });
 
 // src/backoffice/types/static/pricing.types.ts
-var PricingMeasure = /* @__PURE__ */ ((PricingMeasure3) => {
-  PricingMeasure3["PER_ML"] = "per_ml";
-  PricingMeasure3["PER_ZONE"] = "per_zone";
-  PricingMeasure3["PER_AREA"] = "per_area";
-  PricingMeasure3["PER_SESSION"] = "per_session";
-  PricingMeasure3["PER_TREATMENT"] = "per_treatment";
-  PricingMeasure3["PER_PACKAGE"] = "per_package";
-  return PricingMeasure3;
+var PricingMeasure = /* @__PURE__ */ ((PricingMeasure2) => {
+  PricingMeasure2["PER_ML"] = "per_ml";
+  PricingMeasure2["PER_ZONE"] = "per_zone";
+  PricingMeasure2["PER_AREA"] = "per_area";
+  PricingMeasure2["PER_SESSION"] = "per_session";
+  PricingMeasure2["PER_TREATMENT"] = "per_treatment";
+  PricingMeasure2["PER_PACKAGE"] = "per_package";
+  return PricingMeasure2;
 })(PricingMeasure || {});
 var Currency = /* @__PURE__ */ ((Currency2) => {
   Currency2["EUR"] = "EUR";
@@ -4054,8 +3909,8 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
   return querySnapshot.docs.map((doc37) => doc37.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
   const updatedData = {
@@ -4070,15 +3925,15 @@ async function updateClinicAdmin(db, adminId, data) {
   return updatedAdmin;
 }
 async function deleteClinicAdmin(db, adminId) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
   await (0, import_firestore10.deleteDoc)((0, import_firestore10.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
   if (requesterId && requesterId !== adminId) {
@@ -4086,22 +3941,22 @@ async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicServ
     if (!requester) {
       throw new Error("Requester admin not found");
     }
-    if (!requester.isGroupOwner || requester.clinicGroupId !== admin2.clinicGroupId) {
+    if (!requester.isGroupOwner || requester.clinicGroupId !== admin.clinicGroupId) {
       throw new Error("Only group owner can add clinics to other admins");
     }
   }
-  if (admin2.clinicsManaged.includes(clinicId)) {
+  if (admin.clinicsManaged.includes(clinicId)) {
     return;
   }
   await updateClinicAdmin(db, adminId, {
-    clinicsManaged: [...admin2.clinicsManaged, clinicId]
+    clinicsManaged: [...admin.clinicsManaged, clinicId]
   });
   if (clinicService) {
     const clinic = await clinicService.getClinic(clinicId);
     if (clinic) {
       await updateClinicAdmin(db, adminId, {
         clinicsManagedInfo: [
-          ...admin2.clinicsManagedInfo,
+          ...admin.clinicsManagedInfo,
           {
             id: clinic.id,
             featuredPhoto: clinic.featuredPhotos[0] || "",
@@ -4116,8 +3971,8 @@ async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicServ
   }
 }
 async function removeClinicFromManaged(db, adminId, clinicId, requesterId) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
   if (requesterId && requesterId !== adminId) {
@@ -4125,53 +3980,53 @@ async function removeClinicFromManaged(db, adminId, clinicId, requesterId) {
     if (!requester) {
       throw new Error("Requester admin not found");
     }
-    if (!requester.isGroupOwner || requester.clinicGroupId !== admin2.clinicGroupId) {
+    if (!requester.isGroupOwner || requester.clinicGroupId !== admin.clinicGroupId) {
       throw new Error("Only group owner can remove clinics from other admins");
     }
   }
-  if (!admin2.clinicsManaged.includes(clinicId)) {
+  if (!admin.clinicsManaged.includes(clinicId)) {
     return;
   }
   await updateClinicAdmin(db, adminId, {
-    clinicsManaged: admin2.clinicsManaged.filter((id) => id !== clinicId),
-    clinicsManagedInfo: admin2.clinicsManagedInfo.filter(
+    clinicsManaged: admin.clinicsManaged.filter((id) => id !== clinicId),
+    clinicsManagedInfo: admin.clinicsManagedInfo.filter(
       (info) => info.id !== clinicId
     )
   });
 }
 async function getManagedClinics(db, adminId, clinicService) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  if (admin2.clinicsManaged.length === 0) {
+  if (admin.clinicsManaged.length === 0) {
     return [];
   }
   return clinicService.getClinicsByAdmin(adminId);
 }
 async function getActiveManagedClinics(db, adminId, clinicService) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  if (admin2.clinicsManaged.length === 0) {
+  if (admin.clinicsManaged.length === 0) {
     return [];
   }
   return clinicService.getActiveClinicsByAdmin(adminId);
 }
 async function syncOwnerClinics(db, adminId, clinicService, clinicGroupService) {
-  const admin2 = await getClinicAdmin(db, adminId);
-  if (!admin2) {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  if (!admin2.isGroupOwner) {
+  if (!admin.isGroupOwner) {
     return;
   }
-  const group = await clinicGroupService.getClinicGroup(admin2.clinicGroupId);
+  const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
   if (!group) {
     throw new Error("Clinic group not found");
   }
-  const clinics = await clinicService.getClinicsByGroup(admin2.clinicGroupId);
+  const clinics = await clinicService.getClinicsByGroup(admin.clinicGroupId);
   await updateClinicAdmin(db, adminId, {
     clinicsManaged: clinics.map((clinic) => clinic.id),
     clinicsManagedInfo: clinics.map((clinic) => ({
@@ -8307,20 +8162,20 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
   }
   try {
     console.log("[CLINIC] Checking admin permissions");
-    const admin2 = await clinicAdminService.getClinicAdmin(adminId);
-    if (!admin2) {
+    const admin = await clinicAdminService.getClinicAdmin(adminId);
+    if (!admin) {
       console.error("[CLINIC] Admin not found", { adminId });
       throw new Error("Admin not found");
     }
-    const hasPermission = admin2.isGroupOwner && admin2.clinicGroupId === clinic.clinicGroupId || admin2.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
+    const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
     if (!hasPermission) {
       console.error(
         "[CLINIC] Admin does not have permission to update this clinic",
         {
           adminId,
           clinicId,
-          isGroupOwner: admin2.isGroupOwner,
-          clinicsManaged: admin2.clinicsManaged,
+          isGroupOwner: admin.isGroupOwner,
+          clinicsManaged: admin.clinicsManaged,
           isClinicAdmin: clinic.admins && clinic.admins.includes(adminId)
         }
       );
@@ -8470,13 +8325,13 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
   return updatedClinic;
 }
 async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService, clinicGroupService) {
-  const admin2 = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin2) {
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
     throw new Error("Admin not found");
   }
-  let clinicIds = [...admin2.clinicsManaged];
-  if (admin2.isGroupOwner && options.includeGroupClinics) {
-    const group = await clinicGroupService.getClinicGroup(admin2.clinicGroupId);
+  let clinicIds = [...admin.clinicsManaged];
+  if (admin.isGroupOwner && options.includeGroupClinics) {
+    const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
     if (group) {
       clinicIds = [.../* @__PURE__ */ new Set([...clinicIds, ...group.clinics])];
     }
@@ -8611,11 +8466,11 @@ async function addTags(db, clinicId, adminId, newTags, clinicAdminService, app)
   if (!clinic) {
     throw new Error("Clinic not found");
   }
-  const admin2 = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin2) {
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
     throw new Error("Admin not found");
   }
-  const hasPermission = admin2.isGroupOwner && admin2.clinicGroupId === clinic.clinicGroupId || admin2.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
+  const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
   if (!hasPermission) {
     throw new Error("Admin does not have permission to update this clinic");
   }
@@ -8636,11 +8491,11 @@ async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminServic
   if (!clinic) {
     throw new Error("Clinic not found");
   }
-  const admin2 = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin2) {
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
     throw new Error("Admin not found");
   }
-  const hasPermission = admin2.isGroupOwner && admin2.clinicGroupId === clinic.clinicGroupId || admin2.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
+  const hasPermission = admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId || admin.clinicsManaged.includes(clinicId) && clinic.admins && clinic.admins.includes(adminId);
   if (!hasPermission) {
     throw new Error("Admin does not have permission to update this clinic");
   }
@@ -15670,579 +15525,9 @@ var ReviewService = class extends BaseService {
   }
 };
 
-// src/validations/calendar.schema.ts
-var import_zod27 = require("zod");
-var import_firestore48 = require("firebase/firestore");
-
-// src/validations/profile-info.schema.ts
-var import_zod26 = require("zod");
-var import_firestore47 = require("firebase/firestore");
-var clinicBranchInfoSchema = import_zod26.z.object({
-  id: import_zod26.z.string(),
-  featuredPhoto: import_zod26.z.string(),
-  name: import_zod26.z.string(),
-  description: import_zod26.z.string(),
-  location: clinicLocationSchema,
-  contactInfo: clinicContactInfoSchema
-});
-var practitionerProfileInfoSchema = import_zod26.z.object({
-  id: import_zod26.z.string(),
-  practitionerPhoto: import_zod26.z.string().nullable(),
-  name: import_zod26.z.string(),
-  email: import_zod26.z.string().email(),
-  phone: import_zod26.z.string().nullable(),
-  certification: practitionerCertificationSchema
-});
-var patientProfileInfoSchema = import_zod26.z.object({
-  id: import_zod26.z.string(),
-  fullName: import_zod26.z.string(),
-  email: import_zod26.z.string().email(),
-  phone: import_zod26.z.string().nullable(),
-  dateOfBirth: import_zod26.z.instanceof(import_firestore47.Timestamp),
-  gender: import_zod26.z.nativeEnum(Gender)
-});
-
-// src/validations/calendar.schema.ts
-var MIN_APPOINTMENT_DURATION2 = 15;
-var calendarEventTimeSchema = import_zod27.z.object({
-  start: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp)),
-  end: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp))
-}).refine(
-  (data) => {
-    const startDate = data.start instanceof import_firestore48.Timestamp ? data.start.toDate() : data.start;
-    const endDate = data.end instanceof import_firestore48.Timestamp ? data.end.toDate() : data.end;
-    return startDate < endDate;
-  },
-  {
-    message: "End time must be after start time",
-    path: ["end"]
-  }
-).refine(
-  (data) => {
-    const startDate = data.start instanceof import_firestore48.Timestamp ? data.start.toDate() : data.start;
-    return startDate > /* @__PURE__ */ new Date();
-  },
-  {
-    message: "Appointment must be scheduled in the future",
-    path: ["start"]
-  }
-);
-var timeSlotSchema2 = import_zod27.z.object({
-  start: import_zod27.z.date(),
-  end: import_zod27.z.date(),
-  isAvailable: import_zod27.z.boolean()
-}).refine((data) => data.start < data.end, {
-  message: "End time must be after start time",
-  path: ["end"]
-});
-var syncedCalendarEventSchema = import_zod27.z.object({
-  eventId: import_zod27.z.string(),
-  syncedCalendarProvider: import_zod27.z.nativeEnum(SyncedCalendarProvider),
-  syncedAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp))
-});
-var procedureInfoSchema = import_zod27.z.object({
-  name: import_zod27.z.string(),
-  description: import_zod27.z.string(),
-  duration: import_zod27.z.number().min(MIN_APPOINTMENT_DURATION2),
-  price: import_zod27.z.number().min(0),
-  currency: import_zod27.z.nativeEnum(Currency)
-});
-var procedureCategorizationSchema = import_zod27.z.object({
-  procedureFamily: import_zod27.z.string(),
-  // Replace with proper enum when available
-  procedureCategory: import_zod27.z.string(),
-  // Replace with proper enum when available
-  procedureSubcategory: import_zod27.z.string(),
-  // Replace with proper enum when available
-  procedureTechnology: import_zod27.z.string(),
-  // Replace with proper enum when available
-  procedureProduct: import_zod27.z.string()
-  // Replace with proper enum when available
-});
-var createCalendarEventSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  clinicBranchId: import_zod27.z.string().nullable().optional(),
-  clinicBranchInfo: clinicBranchInfoSchema.nullable().optional(),
-  practitionerProfileId: import_zod27.z.string().nullable().optional(),
-  practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod27.z.string().nullable().optional(),
-  patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod27.z.string().nullable().optional(),
-  procedureInfo: procedureInfoSchema.nullable().optional(),
-  procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: import_zod27.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod27.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod27.z.string(),
-  eventLocation: clinicLocationSchema.optional(),
-  eventTime: calendarEventTimeSchema,
-  description: import_zod27.z.string().optional(),
-  status: import_zod27.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod27.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod27.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod27.z.any(),
-  // FieldValue for server timestamp
-  updatedAt: import_zod27.z.any()
-  // FieldValue for server timestamp
-});
-var updateCalendarEventSchema = import_zod27.z.object({
-  syncedCalendarEventId: import_zod27.z.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: import_zod27.z.string().nullable().optional(),
-  eventName: import_zod27.z.string().optional(),
-  eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod27.z.string().optional(),
-  status: import_zod27.z.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: import_zod27.z.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: import_zod27.z.nativeEnum(CalendarEventType).optional(),
-  updatedAt: import_zod27.z.any()
-  // FieldValue for server timestamp
-});
-var calendarEventSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  clinicBranchId: import_zod27.z.string().nullable().optional(),
-  clinicBranchInfo: clinicBranchInfoSchema.nullable().optional(),
-  // Will be replaced with proper clinic info schema
-  practitionerProfileId: import_zod27.z.string().nullable().optional(),
-  practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod27.z.string().nullable().optional(),
-  patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod27.z.string().nullable().optional(),
-  procedureInfo: procedureInfoSchema.nullable().optional(),
-  procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: import_zod27.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod27.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod27.z.string(),
-  eventLocation: clinicLocationSchema.optional(),
-  eventTime: calendarEventTimeSchema,
-  description: import_zod27.z.string().optional(),
-  status: import_zod27.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod27.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod27.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp)),
-  updatedAt: import_zod27.z.instanceof(Date).or(import_zod27.z.instanceof(import_firestore48.Timestamp))
-});
-var createBlockingEventSchema = import_zod27.z.object({
-  entityType: import_zod27.z.enum(["practitioner", "clinic"]),
-  entityId: import_zod27.z.string().min(1, "Entity ID is required"),
-  eventName: import_zod27.z.string().min(1, "Event name is required").max(200, "Event name too long"),
-  eventTime: calendarEventTimeSchema,
-  eventType: import_zod27.z.enum([
-    "blocking" /* BLOCKING */,
-    "break" /* BREAK */,
-    "free_day" /* FREE_DAY */,
-    "other" /* OTHER */
-  ]),
-  description: import_zod27.z.string().max(1e3, "Description too long").optional()
-});
-var updateBlockingEventSchema = import_zod27.z.object({
-  entityType: import_zod27.z.enum(["practitioner", "clinic"]),
-  entityId: import_zod27.z.string().min(1, "Entity ID is required"),
-  eventId: import_zod27.z.string().min(1, "Event ID is required"),
-  eventName: import_zod27.z.string().min(1, "Event name is required").max(200, "Event name too long").optional(),
-  eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod27.z.string().max(1e3, "Description too long").optional()
-});
-
-// src/validations/notification.schema.ts
-var import_zod28 = require("zod");
-var baseNotificationSchema = import_zod28.z.object({
-  id: import_zod28.z.string().optional(),
-  userId: import_zod28.z.string(),
-  notificationTime: import_zod28.z.any(),
-  // Timestamp
-  notificationType: import_zod28.z.nativeEnum(NotificationType),
-  notificationTokens: import_zod28.z.array(import_zod28.z.string()),
-  status: import_zod28.z.nativeEnum(NotificationStatus),
-  createdAt: import_zod28.z.any().optional(),
-  // Timestamp
-  updatedAt: import_zod28.z.any().optional(),
-  // Timestamp
-  title: import_zod28.z.string(),
-  body: import_zod28.z.string(),
-  isRead: import_zod28.z.boolean(),
-  userRole: import_zod28.z.nativeEnum(UserRole)
-});
-var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod28.z.literal("preRequirementInstructionDue" /* PRE_REQUIREMENT_INSTRUCTION_DUE */),
-  treatmentId: import_zod28.z.string(),
-  requirements: import_zod28.z.array(import_zod28.z.string()),
-  deadline: import_zod28.z.any()
-  // Timestamp
-});
-var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod28.z.literal(
-    "postRequirementInstructionDue" /* POST_REQUIREMENT_INSTRUCTION_DUE */
-  ),
-  treatmentId: import_zod28.z.string(),
-  requirements: import_zod28.z.array(import_zod28.z.string()),
-  deadline: import_zod28.z.any()
-  // Timestamp
-});
-var requirementInstructionDueNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod28.z.literal("requirementInstructionDue" /* REQUIREMENT_INSTRUCTION_DUE */),
-  appointmentId: import_zod28.z.string(),
-  patientRequirementInstanceId: import_zod28.z.string(),
-  instructionId: import_zod28.z.string(),
-  originalRequirementId: import_zod28.z.string().optional()
-});
-var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod28.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: import_zod28.z.string(),
-  appointmentTime: import_zod28.z.any(),
-  // Timestamp
-  treatmentType: import_zod28.z.string(),
-  doctorName: import_zod28.z.string()
-});
-var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod28.z.literal("appointmentStatusChange" /* APPOINTMENT_STATUS_CHANGE */),
-  appointmentId: import_zod28.z.string(),
-  appointmentStatus: import_zod28.z.string(),
-  previousStatus: import_zod28.z.string(),
-  reason: import_zod28.z.string().optional()
-});
-var notificationSchema = import_zod28.z.discriminatedUnion("notificationType", [
-  preRequirementNotificationSchema,
-  postRequirementNotificationSchema,
-  requirementInstructionDueNotificationSchema,
-  appointmentReminderNotificationSchema,
-  appointmentNotificationSchema
-]);
-
-// src/validations/patient/patient-requirements.schema.ts
-var import_zod30 = require("zod");
-
-// src/backoffice/validations/schemas.ts
-var import_zod29 = require("zod");
-
-// src/backoffice/types/static/treatment-benefit.types.ts
-var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
-  TreatmentBenefit2["WRINKLE_REDUCTION"] = "wrinkle_reduction";
-  TreatmentBenefit2["SKIN_TIGHTENING"] = "skin_tightening";
-  TreatmentBenefit2["COLLAGEN_PRODUCTION"] = "collagen_production";
-  TreatmentBenefit2["ACNE_REDUCTION"] = "acne_reduction";
-  TreatmentBenefit2["SCAR_REDUCTION"] = "scar_reduction";
-  TreatmentBenefit2["PIGMENTATION_IMPROVEMENT"] = "pigmentation_improvement";
-  TreatmentBenefit2["HAIR_REMOVAL"] = "hair_removal";
-  TreatmentBenefit2["MUSCLE_TONING"] = "muscle_toning";
-  TreatmentBenefit2["FAT_REDUCTION"] = "fat_reduction";
-  TreatmentBenefit2["CELLULITE_REDUCTION"] = "cellulite_reduction";
-  TreatmentBenefit2["SKIN_REJUVENATION"] = "skin_rejuvenation";
-  TreatmentBenefit2["PORE_REDUCTION"] = "pore_reduction";
-  TreatmentBenefit2["TEXTURE_IMPROVEMENT"] = "texture_improvement";
-  TreatmentBenefit2["HYDRATION_BOOST"] = "hydration_boost";
-  TreatmentBenefit2["CIRCULATION_IMPROVEMENT"] = "circulation_improvement";
-  return TreatmentBenefit2;
-})(TreatmentBenefit || {});
-
-// src/backoffice/types/requirement.types.ts
-var TimeUnit = /* @__PURE__ */ ((TimeUnit2) => {
-  TimeUnit2["HOURS"] = "hours";
-  TimeUnit2["DAYS"] = "days";
-  return TimeUnit2;
-})(TimeUnit || {});
-var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
-  RequirementType2["PRE"] = "pre";
-  RequirementType2["POST"] = "post";
-  return RequirementType2;
-})(RequirementType || {});
-
-// src/backoffice/validations/schemas.ts
-var blockingConditionSchemaBackoffice = import_zod29.z.nativeEnum(BlockingCondition);
-var contraindicationSchemaBackoffice = import_zod29.z.nativeEnum(Contraindication);
-var treatmentBenefitSchemaBackoffice = import_zod29.z.nativeEnum(TreatmentBenefit);
-var procedureFamilySchemaBackoffice = import_zod29.z.nativeEnum(ProcedureFamily);
-var timeUnitSchemaBackoffice = import_zod29.z.nativeEnum(TimeUnit);
-var requirementTypeSchema = import_zod29.z.nativeEnum(RequirementType);
-var certificationLevelSchema = import_zod29.z.nativeEnum(CertificationLevel);
-var certificationSpecialtySchema = import_zod29.z.nativeEnum(
-  CertificationSpecialty
-);
-var certificationRequirementSchema = import_zod29.z.object({
-  minimumLevel: certificationLevelSchema,
-  requiredSpecialties: import_zod29.z.array(certificationSpecialtySchema).max(5, "Maximum 5 specialties allowed").optional()
-});
-var timeframeSchema = import_zod29.z.object({
-  duration: import_zod29.z.number().min(1, "Duration must be positive"),
-  unit: timeUnitSchemaBackoffice,
-  notifyAt: import_zod29.z.array(import_zod29.z.number()).min(1, "At least one notification point is required")
-});
-var requirementSchema = import_zod29.z.object({
-  name: import_zod29.z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: import_zod29.z.string().min(1, "Description is required"),
-  type: requirementTypeSchema,
-  timeframe: timeframeSchema,
-  importance: import_zod29.z.enum(["low", "medium", "high"]),
-  isActive: import_zod29.z.boolean().default(true)
-});
-var technologyRequirementsSchema = import_zod29.z.object({
-  pre: import_zod29.z.array(requirementSchema),
-  post: import_zod29.z.array(requirementSchema)
-});
-var technologySchema = import_zod29.z.object({
-  name: import_zod29.z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: import_zod29.z.string().max(1e3, "Description is too long").optional(),
-  technicalDetails: import_zod29.z.string().max(2e3, "Technical details are too long").optional(),
-  family: procedureFamilySchemaBackoffice,
-  categoryId: import_zod29.z.string().min(1, "Category ID is required"),
-  subcategoryId: import_zod29.z.string().min(1, "Subcategory ID is required"),
-  requirements: technologyRequirementsSchema.default({
-    pre: [],
-    post: []
-  }),
-  blockingConditions: import_zod29.z.array(blockingConditionSchemaBackoffice),
-  contraindications: import_zod29.z.array(contraindicationSchemaBackoffice),
-  documentationTemplates: import_zod29.z.array(documentTemplateSchema),
-  benefits: import_zod29.z.array(treatmentBenefitSchemaBackoffice),
-  certificationRequirement: certificationRequirementSchema,
-  isActive: import_zod29.z.boolean().default(true)
-});
-var categorySchema = import_zod29.z.object({
-  name: import_zod29.z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: import_zod29.z.string().optional(),
-  family: procedureFamilySchemaBackoffice,
-  isActive: import_zod29.z.boolean().default(true)
-});
-var subcategorySchema = import_zod29.z.object({
-  name: import_zod29.z.string().min(1, "Name is required").max(100, "Name is too long"),
-  description: import_zod29.z.string().optional(),
-  categoryId: import_zod29.z.string().min(1, "Category ID is required"),
-  isActive: import_zod29.z.boolean().default(true)
-});
-var categoryUpdateSchema = categorySchema.partial();
-var subcategoryUpdateSchema = subcategorySchema.partial();
-var technologyUpdateSchema = technologySchema.partial();
-var requirementUpdateSchema = requirementSchema.partial();
-
-// src/validations/patient/patient-requirements.schema.ts
-var patientInstructionStatusSchema = import_zod30.z.nativeEnum(
-  PatientInstructionStatus
-);
-var patientRequirementInstructionSchema = import_zod30.z.object({
-  instructionId: import_zod30.z.string().min(1, "Instruction ID is required."),
-  instructionText: import_zod30.z.string().min(1, "Instruction text is required."),
-  dueTime: import_zod30.z.any(),
-  // Firestore Timestamp
-  actionableWindow: import_zod30.z.number().default(1),
-  status: patientInstructionStatusSchema,
-  originalNotifyAtValue: import_zod30.z.number(),
-  originalTimeframeUnit: timeUnitSchemaBackoffice,
-  // Use the correctly imported timeUnitSchema
-  notificationId: import_zod30.z.string().optional(),
-  actionTakenAt: import_zod30.z.any().optional().nullable(),
-  // Firestore Timestamp or null
-  updatedAt: import_zod30.z.any()
-  // Firestore Timestamp
-});
-var patientRequirementOverallStatusSchema = import_zod30.z.nativeEnum(
-  PatientRequirementOverallStatus
-);
-var requirementImportanceSchema = import_zod30.z.enum(["low", "medium", "high"]);
-var patientRequirementInstanceSchema = import_zod30.z.object({
-  id: import_zod30.z.string().min(1, "Instance ID is required."),
-  patientId: import_zod30.z.string().min(1, "Patient ID is required."),
-  appointmentId: import_zod30.z.string().min(1, "Appointment ID is required."),
-  originalRequirementId: import_zod30.z.string().min(1, "Original Requirement ID is required."),
-  requirementType: requirementTypeSchema,
-  requirementName: import_zod30.z.string().min(1, "Requirement name is required."),
-  requirementDescription: import_zod30.z.string(),
-  requirementImportance: requirementImportanceSchema,
-  // Use the locally defined schema
-  overallStatus: patientRequirementOverallStatusSchema,
-  instructions: import_zod30.z.array(patientRequirementInstructionSchema).min(1, "At least one instruction is required."),
-  createdAt: import_zod30.z.any(),
-  // Firestore Timestamp
-  updatedAt: import_zod30.z.any()
-  // Firestore Timestamp
-});
-var updatePatientInstructionStatusSchema = import_zod30.z.object({
-  status: import_zod30.z.literal("actionTaken" /* ACTION_TAKEN */),
-  actionTakenAt: import_zod30.z.any()
-  // Should be a Timestamp from the server
-});
-
-// src/utils/TimestampUtils.ts
-var admin = __toESM(require("firebase-admin"));
-var import_firestore49 = require("firebase/firestore");
-var IS_SERVER_ENV = process.env.NODE_ENV === "production" || process.env.FUNCTIONS_EMULATOR === "true" || process.env.FIREBASE_CONFIG !== void 0;
-var TimestampUtils = class {
-  /**
-   * Enables server mode where admin timestamps are preserved when saving
-   * to Firestore via the admin SDK
-   */
-  static enableServerMode() {
-    this.serverMode = true;
-  }
-  /**
-   * Disables server mode - use this only for client-side or mixed environments
-   */
-  static disableServerMode() {
-    this.serverMode = false;
-  }
-  /**
-   * Converts an admin Firestore Timestamp to a client Firestore Timestamp
-   * In server mode, returns the original admin timestamp for storage consistency
-   *
-   * @param adminTimestamp - Admin SDK Timestamp (from firebase-admin)
-   * @returns A client SDK Timestamp (from firebase/firestore) with same seconds/nanoseconds,
-   *          or the original admin timestamp in server mode,
-   *          or null if input is null
-   */
-  static adminToClient(adminTimestamp) {
-    if (!adminTimestamp) return null;
-    if (this.serverMode) {
-      return adminTimestamp;
-    }
-    return new import_firestore49.Timestamp(
-      adminTimestamp.seconds,
-      adminTimestamp.nanoseconds
-    );
-  }
-  /**
-   * Converts a client Firestore Timestamp to an admin Firestore Timestamp
-   * @param clientTimestamp - Client SDK Timestamp (from firebase/firestore)
-   * @returns An admin SDK Timestamp (from firebase-admin) with same seconds/nanoseconds or null if input is null
-   */
-  static clientToAdmin(clientTimestamp) {
-    if (!clientTimestamp) return null;
-    return new admin.firestore.Timestamp(
-      clientTimestamp.seconds,
-      clientTimestamp.nanoseconds
-    );
-  }
-  /**
-   * Creates a timestamp for the current time in the appropriate format based on environment
-   * @returns A timestamp for the current time (admin timestamp in server mode, client in client mode)
-   */
-  static nowAsTimestamp() {
-    const now = admin.firestore.Timestamp.now();
-    if (this.serverMode) {
-      return now;
-    }
-    return this.adminToClient(now);
-  }
-  /**
-   * @deprecated Use nowAsTimestamp() instead for better cross-environment compatibility
-   */
-  static nowAsClient() {
-    const now = admin.firestore.Timestamp.now();
-    return this.adminToClient(now);
-  }
-  /**
-   * Converts a Date object to a timestamp in the appropriate format based on environment
-   * @param date - JavaScript Date object
-   * @returns A timestamp (admin timestamp in server mode, client in client mode) or null if input is null
-   */
-  static dateToTimestamp(date) {
-    if (!date) return null;
-    if (this.serverMode) {
-      return admin.firestore.Timestamp.fromDate(date);
-    }
-    return import_firestore49.Timestamp.fromDate(date);
-  }
-  /**
-   * @deprecated Use dateToTimestamp() instead for better cross-environment compatibility
-   */
-  static dateToClientTimestamp(date) {
-    if (!date) return null;
-    return import_firestore49.Timestamp.fromDate(date);
-  }
-  /**
-   * @deprecated Use dateToTimestamp() instead for better cross-environment compatibility
-   */
-  static dateToAdminTimestamp(date) {
-    if (!date) return null;
-    return admin.firestore.Timestamp.fromDate(date);
-  }
-  /**
-   * Gets a server timestamp field value for use in create/update operations
-   * Works in both admin and client environments
-   */
-  static serverTimestamp() {
-    if (this.serverMode) {
-      return admin.firestore.FieldValue.serverTimestamp();
-    }
-    throw new Error("Server timestamp in client mode not implemented");
-  }
-  /**
-   * For objects with mixed timestamp types, ensures all timestamps are
-   * in the correct format for the current environment
-   */
-  static normalizeTimestamps(obj) {
-    if (!obj || typeof obj !== "object") {
-      return obj;
-    }
-    if (obj instanceof admin.firestore.Timestamp) {
-      return this.serverMode ? obj : this.adminToClient(obj);
-    }
-    if (obj instanceof import_firestore49.Timestamp && this.serverMode) {
-      return this.clientToAdmin(obj);
-    }
-    if (Array.isArray(obj)) {
-      return obj.map((item) => this.normalizeTimestamps(item));
-    }
-    const result = { ...obj };
-    for (const key in result) {
-      if (Object.prototype.hasOwnProperty.call(result, key)) {
-        result[key] = this.normalizeTimestamps(result[key]);
-      }
-    }
-    return result;
-  }
-  /**
-   * @deprecated Use normalizeTimestamps() instead for better cross-environment compatibility
-   */
-  static convertObjectTimestampsAdminToClient(obj) {
-    if (!obj || typeof obj !== "object") {
-      return obj;
-    }
-    if (obj instanceof admin.firestore.Timestamp) {
-      return this.adminToClient(obj);
-    }
-    if (Array.isArray(obj)) {
-      return obj.map(
-        (item) => this.convertObjectTimestampsAdminToClient(item)
-      );
-    }
-    const result = { ...obj };
-    for (const key in result) {
-      if (Object.prototype.hasOwnProperty.call(result, key)) {
-        result[key] = this.convertObjectTimestampsAdminToClient(result[key]);
-      }
-    }
-    return result;
-  }
-  /**
-   * @deprecated Use normalizeTimestamps() instead for better cross-environment compatibility
-   */
-  static convertObjectTimestampsClientToAdmin(obj) {
-    if (!obj || typeof obj !== "object") {
-      return obj;
-    }
-    if (obj instanceof import_firestore49.Timestamp) {
-      return this.clientToAdmin(obj);
-    }
-    if (Array.isArray(obj)) {
-      return obj.map(
-        (item) => this.convertObjectTimestampsClientToAdmin(item)
-      );
-    }
-    const result = { ...obj };
-    for (const key in result) {
-      if (Object.prototype.hasOwnProperty.call(result, key)) {
-        result[key] = this.convertObjectTimestampsClientToAdmin(result[key]);
-      }
-    }
-    return result;
-  }
-};
-/**
- * Flag to force server mode where admin timestamps are preserved
- * This should be true in Cloud Functions environments
- */
-TimestampUtils.serverMode = IS_SERVER_ENV;
-
 // src/config/firebase.ts
 var import_app = require("firebase/app");
-var import_firestore50 = require("firebase/firestore");
+var import_firestore47 = require("firebase/firestore");
 var import_auth9 = require("firebase/auth");
 var import_analytics = require("firebase/analytics");
 var import_react_native = require("react-native");
@@ -16252,7 +15537,7 @@ var firebaseInstance = null;
 var initializeFirebase = (config) => {
   if (!firebaseInstance) {
     const app = (0, import_app.initializeApp)(config);
-    const db = (0, import_firestore50.getFirestore)(app);
+    const db = (0, import_firestore47.getFirestore)(app);
     const auth = (0, import_auth9.getAuth)(app);
     const storage = (0, import_storage4.getStorage)(app);
     const functions = (0, import_functions2.getFunctions)(app);
@@ -16294,7 +15579,7 @@ var getFirebaseFunctions = async () => {
 };
 
 // src/backoffice/services/brand.service.ts
-var import_firestore51 = require("firebase/firestore");
+var import_firestore48 = require("firebase/firestore");
 
 // src/backoffice/types/brand.types.ts
 var BRANDS_COLLECTION = "brands";
@@ -16305,7 +15590,7 @@ var BrandService = class extends BaseService {
    * Gets reference to brands collection
    */
   getBrandsRef() {
-    return (0, import_firestore51.collection)(this.db, BRANDS_COLLECTION);
+    return (0, import_firestore48.collection)(this.db, BRANDS_COLLECTION);
   }
   /**
    * Creates a new brand
@@ -16318,15 +15603,15 @@ var BrandService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore51.addDoc)(this.getBrandsRef(), newBrand);
+    const docRef = await (0, import_firestore48.addDoc)(this.getBrandsRef(), newBrand);
     return { id: docRef.id, ...newBrand };
   }
   /**
    * Gets all active brands
    */
   async getAll() {
-    const q = (0, import_firestore51.query)(this.getBrandsRef(), (0, import_firestore51.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore51.getDocs)(q);
+    const q = (0, import_firestore48.query)(this.getBrandsRef(), (0, import_firestore48.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore48.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16342,8 +15627,8 @@ var BrandService = class extends BaseService {
       ...brand,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore51.doc)(this.getBrandsRef(), brandId);
-    await (0, import_firestore51.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore48.doc)(this.getBrandsRef(), brandId);
+    await (0, import_firestore48.updateDoc)(docRef, updateData);
     return this.getById(brandId);
   }
   /**
@@ -16358,8 +15643,8 @@ var BrandService = class extends BaseService {
    * Gets a brand by ID
    */
   async getById(brandId) {
-    const docRef = (0, import_firestore51.doc)(this.getBrandsRef(), brandId);
-    const docSnap = await (0, import_firestore51.getDoc)(docRef);
+    const docRef = (0, import_firestore48.doc)(this.getBrandsRef(), brandId);
+    const docSnap = await (0, import_firestore48.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -16369,7 +15654,7 @@ var BrandService = class extends BaseService {
 };
 
 // src/backoffice/services/category.service.ts
-var import_firestore52 = require("firebase/firestore");
+var import_firestore49 = require("firebase/firestore");
 
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
@@ -16380,7 +15665,7 @@ var CategoryService = class extends BaseService {
    * Referenca na Firestore kolekciju kategorija
    */
   get categoriesRef() {
-    return (0, import_firestore52.collection)(this.db, CATEGORIES_COLLECTION);
+    return (0, import_firestore49.collection)(this.db, CATEGORIES_COLLECTION);
   }
   /**
    * Kreira novu kategoriju u sistemu
@@ -16395,7 +15680,7 @@ var CategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore52.addDoc)(this.categoriesRef, newCategory);
+    const docRef = await (0, import_firestore49.addDoc)(this.categoriesRef, newCategory);
     return { id: docRef.id, ...newCategory };
   }
   /**
@@ -16403,8 +15688,8 @@ var CategoryService = class extends BaseService {
    * @returns Lista aktivnih kategorija
    */
   async getAll() {
-    const q = (0, import_firestore52.query)(this.categoriesRef, (0, import_firestore52.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore52.getDocs)(q);
+    const q = (0, import_firestore49.query)(this.categoriesRef, (0, import_firestore49.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore49.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16418,12 +15703,12 @@ var CategoryService = class extends BaseService {
    * @returns Lista kategorija koje pripadaju traženoj familiji
    */
   async getAllByFamily(family) {
-    const q = (0, import_firestore52.query)(
+    const q = (0, import_firestore49.query)(
       this.categoriesRef,
-      (0, import_firestore52.where)("family", "==", family),
-      (0, import_firestore52.where)("isActive", "==", true)
+      (0, import_firestore49.where)("family", "==", family),
+      (0, import_firestore49.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore52.getDocs)(q);
+    const snapshot = await (0, import_firestore49.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16442,8 +15727,8 @@ var CategoryService = class extends BaseService {
       ...category,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore52.doc)(this.categoriesRef, id);
-    await (0, import_firestore52.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore49.doc)(this.categoriesRef, id);
+    await (0, import_firestore49.updateDoc)(docRef, updateData);
     return this.getById(id);
   }
   /**
@@ -16459,8 +15744,8 @@ var CategoryService = class extends BaseService {
    * @returns Kategorija ili null ako ne postoji
    */
   async getById(id) {
-    const docRef = (0, import_firestore52.doc)(this.categoriesRef, id);
-    const docSnap = await (0, import_firestore52.getDoc)(docRef);
+    const docRef = (0, import_firestore49.doc)(this.categoriesRef, id);
+    const docSnap = await (0, import_firestore49.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -16470,7 +15755,7 @@ var CategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/subcategory.service.ts
-var import_firestore53 = require("firebase/firestore");
+var import_firestore50 = require("firebase/firestore");
 
 // src/backoffice/types/subcategory.types.ts
 var SUBCATEGORIES_COLLECTION = "subcategories";
@@ -16482,7 +15767,7 @@ var SubcategoryService = class extends BaseService {
    * @param categoryId - ID roditeljske kategorije
    */
   getSubcategoriesRef(categoryId) {
-    return (0, import_firestore53.collection)(
+    return (0, import_firestore50.collection)(
       this.db,
       CATEGORIES_COLLECTION,
       categoryId,
@@ -16504,7 +15789,7 @@ var SubcategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore53.addDoc)(
+    const docRef = await (0, import_firestore50.addDoc)(
       this.getSubcategoriesRef(categoryId),
       newSubcategory
     );
@@ -16516,11 +15801,11 @@ var SubcategoryService = class extends BaseService {
    * @returns Lista aktivnih podkategorija
    */
   async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore53.query)(
+    const q = (0, import_firestore50.query)(
       this.getSubcategoriesRef(categoryId),
-      (0, import_firestore53.where)("isActive", "==", true)
+      (0, import_firestore50.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore53.getDocs)(q);
+    const snapshot = await (0, import_firestore50.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16540,8 +15825,8 @@ var SubcategoryService = class extends BaseService {
       ...subcategory,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore53.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await (0, import_firestore53.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore50.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    await (0, import_firestore50.updateDoc)(docRef, updateData);
     return this.getById(categoryId, subcategoryId);
   }
   /**
@@ -16559,8 +15844,8 @@ var SubcategoryService = class extends BaseService {
    * @returns Podkategorija ili null ako ne postoji
    */
   async getById(categoryId, subcategoryId) {
-    const docRef = (0, import_firestore53.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await (0, import_firestore53.getDoc)(docRef);
+    const docRef = (0, import_firestore50.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await (0, import_firestore50.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -16570,7 +15855,7 @@ var SubcategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/technology.service.ts
-var import_firestore54 = require("firebase/firestore");
+var import_firestore51 = require("firebase/firestore");
 var DEFAULT_CERTIFICATION_REQUIREMENT = {
   minimumLevel: "aesthetician" /* AESTHETICIAN */,
   requiredSpecialties: []
@@ -16580,7 +15865,7 @@ var TechnologyService = class extends BaseService {
    * Vraća referencu na Firestore kolekciju tehnologija
    */
   getTechnologiesRef() {
-    return (0, import_firestore54.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    return (0, import_firestore51.collection)(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
    * Kreira novu tehnologiju
@@ -16603,7 +15888,7 @@ var TechnologyService = class extends BaseService {
       benefits: technology.benefits || [],
       certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT
     };
-    const docRef = await (0, import_firestore54.addDoc)(this.getTechnologiesRef(), newTechnology);
+    const docRef = await (0, import_firestore51.addDoc)(this.getTechnologiesRef(), newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
   /**
@@ -16611,8 +15896,8 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAll() {
-    const q = (0, import_firestore54.query)(this.getTechnologiesRef(), (0, import_firestore54.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore54.getDocs)(q);
+    const q = (0, import_firestore51.query)(this.getTechnologiesRef(), (0, import_firestore51.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore51.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16626,12 +15911,12 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByFamily(family) {
-    const q = (0, import_firestore54.query)(
+    const q = (0, import_firestore51.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore54.where)("isActive", "==", true),
-      (0, import_firestore54.where)("family", "==", family)
+      (0, import_firestore51.where)("isActive", "==", true),
+      (0, import_firestore51.where)("family", "==", family)
     );
-    const snapshot = await (0, import_firestore54.getDocs)(q);
+    const snapshot = await (0, import_firestore51.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16645,12 +15930,12 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore54.query)(
+    const q = (0, import_firestore51.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore54.where)("isActive", "==", true),
-      (0, import_firestore54.where)("categoryId", "==", categoryId)
+      (0, import_firestore51.where)("isActive", "==", true),
+      (0, import_firestore51.where)("categoryId", "==", categoryId)
     );
-    const snapshot = await (0, import_firestore54.getDocs)(q);
+    const snapshot = await (0, import_firestore51.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16664,12 +15949,12 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllBySubcategoryId(subcategoryId) {
-    const q = (0, import_firestore54.query)(
+    const q = (0, import_firestore51.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore54.where)("isActive", "==", true),
-      (0, import_firestore54.where)("subcategoryId", "==", subcategoryId)
+      (0, import_firestore51.where)("isActive", "==", true),
+      (0, import_firestore51.where)("subcategoryId", "==", subcategoryId)
     );
-    const snapshot = await (0, import_firestore54.getDocs)(q);
+    const snapshot = await (0, import_firestore51.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -16688,8 +15973,8 @@ var TechnologyService = class extends BaseService {
       ...technology,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, updateData);
     return this.getById(technologyId);
   }
   /**
@@ -16707,8 +15992,8 @@ var TechnologyService = class extends BaseService {
    * @returns Tehnologija ili null ako ne postoji
    */
   async getById(technologyId) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    const docSnap = await (0, import_firestore54.getDoc)(docRef);
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    const docSnap = await (0, import_firestore51.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -16722,10 +16007,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore54.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore54.arrayUnion)(requirement),
+    await (0, import_firestore51.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore51.arrayUnion)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16737,10 +16022,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore54.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore54.arrayRemove)(requirement),
+    await (0, import_firestore51.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore51.arrayRemove)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16777,9 +16062,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore54.arrayUnion)(condition),
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore51.arrayUnion)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16791,9 +16076,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore54.arrayRemove)(condition),
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore51.arrayRemove)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16805,9 +16090,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
-      contraindications: (0, import_firestore54.arrayUnion)(contraindication),
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
+      contraindications: (0, import_firestore51.arrayUnion)(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16819,9 +16104,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
-      contraindications: (0, import_firestore54.arrayRemove)(contraindication),
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
+      contraindications: (0, import_firestore51.arrayRemove)(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16833,9 +16118,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
-      benefits: (0, import_firestore54.arrayUnion)(benefit),
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
+      benefits: (0, import_firestore51.arrayUnion)(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16847,9 +16132,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
-      benefits: (0, import_firestore54.arrayRemove)(benefit),
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
+      benefits: (0, import_firestore51.arrayRemove)(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -16888,8 +16173,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = (0, import_firestore54.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore54.updateDoc)(docRef, {
+    const docRef = (0, import_firestore51.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore51.updateDoc)(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -16989,7 +16274,7 @@ var TechnologyService = class extends BaseService {
 };
 
 // src/backoffice/services/product.service.ts
-var import_firestore55 = require("firebase/firestore");
+var import_firestore52 = require("firebase/firestore");
 
 // src/backoffice/types/product.types.ts
 var PRODUCTS_COLLECTION = "products";
@@ -17002,7 +16287,7 @@ var ProductService = class extends BaseService {
    * @returns Firestore collection reference
    */
   getProductsRef(technologyId) {
-    return (0, import_firestore55.collection)(
+    return (0, import_firestore52.collection)(
       this.db,
       TECHNOLOGIES_COLLECTION,
       technologyId,
@@ -17022,7 +16307,7 @@ var ProductService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const productRef = await (0, import_firestore55.addDoc)(
+    const productRef = await (0, import_firestore52.addDoc)(
       this.getProductsRef(technologyId),
       newProduct
     );
@@ -17032,11 +16317,11 @@ var ProductService = class extends BaseService {
    * Gets all products for a technology
    */
   async getAllByTechnology(technologyId) {
-    const q = (0, import_firestore55.query)(
+    const q = (0, import_firestore52.query)(
       this.getProductsRef(technologyId),
-      (0, import_firestore55.where)("isActive", "==", true)
+      (0, import_firestore52.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore55.getDocs)(q);
+    const snapshot = await (0, import_firestore52.getDocs)(q);
     return snapshot.docs.map(
       (doc37) => ({
         id: doc37.id,
@@ -17048,16 +16333,16 @@ var ProductService = class extends BaseService {
    * Gets all products for a brand by filtering through all technologies
    */
   async getAllByBrand(brandId) {
-    const allTechnologiesRef = (0, import_firestore55.collection)(this.db, TECHNOLOGIES_COLLECTION);
-    const technologiesSnapshot = await (0, import_firestore55.getDocs)(allTechnologiesRef);
+    const allTechnologiesRef = (0, import_firestore52.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await (0, import_firestore52.getDocs)(allTechnologiesRef);
     const products = [];
     for (const techDoc of technologiesSnapshot.docs) {
-      const q = (0, import_firestore55.query)(
+      const q = (0, import_firestore52.query)(
         this.getProductsRef(techDoc.id),
-        (0, import_firestore55.where)("brandId", "==", brandId),
-        (0, import_firestore55.where)("isActive", "==", true)
+        (0, import_firestore52.where)("brandId", "==", brandId),
+        (0, import_firestore52.where)("isActive", "==", true)
       );
-      const snapshot = await (0, import_firestore55.getDocs)(q);
+      const snapshot = await (0, import_firestore52.getDocs)(q);
       products.push(
         ...snapshot.docs.map(
           (doc37) => ({
@@ -17077,8 +16362,8 @@ var ProductService = class extends BaseService {
       ...product,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore55.doc)(this.getProductsRef(technologyId), productId);
-    await (0, import_firestore55.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore52.doc)(this.getProductsRef(technologyId), productId);
+    await (0, import_firestore52.updateDoc)(docRef, updateData);
     return this.getById(technologyId, productId);
   }
   /**
@@ -17093,8 +16378,8 @@ var ProductService = class extends BaseService {
    * Gets a product by ID
    */
   async getById(technologyId, productId) {
-    const docRef = (0, import_firestore55.doc)(this.getProductsRef(technologyId), productId);
-    const docSnap = await (0, import_firestore55.getDoc)(docRef);
+    const docRef = (0, import_firestore52.doc)(this.getProductsRef(technologyId), productId);
+    const docSnap = await (0, import_firestore52.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -17102,6 +16387,38 @@ var ProductService = class extends BaseService {
     };
   }
 };
+
+// src/backoffice/types/static/treatment-benefit.types.ts
+var TreatmentBenefit = /* @__PURE__ */ ((TreatmentBenefit2) => {
+  TreatmentBenefit2["WRINKLE_REDUCTION"] = "wrinkle_reduction";
+  TreatmentBenefit2["SKIN_TIGHTENING"] = "skin_tightening";
+  TreatmentBenefit2["COLLAGEN_PRODUCTION"] = "collagen_production";
+  TreatmentBenefit2["ACNE_REDUCTION"] = "acne_reduction";
+  TreatmentBenefit2["SCAR_REDUCTION"] = "scar_reduction";
+  TreatmentBenefit2["PIGMENTATION_IMPROVEMENT"] = "pigmentation_improvement";
+  TreatmentBenefit2["HAIR_REMOVAL"] = "hair_removal";
+  TreatmentBenefit2["MUSCLE_TONING"] = "muscle_toning";
+  TreatmentBenefit2["FAT_REDUCTION"] = "fat_reduction";
+  TreatmentBenefit2["CELLULITE_REDUCTION"] = "cellulite_reduction";
+  TreatmentBenefit2["SKIN_REJUVENATION"] = "skin_rejuvenation";
+  TreatmentBenefit2["PORE_REDUCTION"] = "pore_reduction";
+  TreatmentBenefit2["TEXTURE_IMPROVEMENT"] = "texture_improvement";
+  TreatmentBenefit2["HYDRATION_BOOST"] = "hydration_boost";
+  TreatmentBenefit2["CIRCULATION_IMPROVEMENT"] = "circulation_improvement";
+  return TreatmentBenefit2;
+})(TreatmentBenefit || {});
+
+// src/backoffice/types/requirement.types.ts
+var TimeUnit = /* @__PURE__ */ ((TimeUnit2) => {
+  TimeUnit2["HOURS"] = "hours";
+  TimeUnit2["DAYS"] = "days";
+  return TimeUnit2;
+})(TimeUnit || {});
+var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
+  RequirementType2["PRE"] = "pre";
+  RequirementType2["POST"] = "post";
+  return RequirementType2;
+})(RequirementType || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   APPOINTMENTS_COLLECTION,
@@ -17194,164 +16511,19 @@ var ProductService = class extends BaseService {
   SubcategoryService,
   SubscriptionModel,
   SyncedCalendarProvider,
+  SyncedCalendarsService,
   TechnologyService,
   TimeUnit,
-  TimestampUtils,
   TreatmentBenefit,
   USERS_COLLECTION,
   USER_FORMS_SUBCOLLECTION,
   UserRole,
   UserService,
-  addAllergySchema,
-  addBlockingConditionSchema,
-  addContraindicationSchema,
-  addMedicationSchema,
-  addressDataSchema,
-  adminInfoSchema,
-  adminTokenSchema,
-  allergySchema,
-  allergySubtypeSchema,
-  appointmentMediaItemSchema,
-  appointmentMetadataSchema,
-  appointmentNotificationSchema,
-  appointmentReminderNotificationSchema,
-  appointmentStatusSchema,
-  baseNotificationSchema,
-  beforeAfterPerZoneSchema,
-  billingPerZoneSchema,
-  blockingConditionSchema,
-  calendarEventSchema,
-  calendarEventTimeSchema,
-  clinicAdminOptionsSchema,
-  clinicAdminSchema,
-  clinicAdminSignupSchema,
-  clinicBranchInfoSchema,
-  clinicBranchSetupSchema,
-  clinicContactInfoSchema,
-  clinicGroupSchema,
-  clinicGroupSetupSchema,
-  clinicInfoSchema,
-  clinicLocationSchema,
-  clinicReviewInfoSchema,
-  clinicReviewSchema,
-  clinicSchema,
-  clinicTagsSchema,
-  contactPersonSchema,
-  contraindicationSchema,
-  createAdminTokenSchema,
-  createAppointmentSchema,
-  createBlockingEventSchema,
-  createCalendarEventSchema,
-  createClinicAdminSchema,
-  createClinicGroupSchema,
-  createClinicReviewSchema,
-  createClinicSchema,
-  createDefaultClinicGroupSchema,
-  createDocumentTemplateSchema,
-  createDraftPractitionerSchema,
-  createFilledDocumentDataSchema,
-  createManualPatientSchema,
-  createPatientLocationInfoSchema,
-  createPatientMedicalInfoSchema,
-  createPatientProfileSchema,
-  createPatientSensitiveInfoSchema,
-  createPatientTokenSchema,
-  createPractitionerReviewSchema,
-  createPractitionerSchema,
-  createPractitionerTokenSchema,
-  createProcedureReviewSchema,
-  createProcedureSchema,
-  createReviewSchema,
-  createUserOptionsSchema,
-  doctorInfoSchema,
-  documentElementSchema,
-  documentElementWithoutIdSchema,
-  documentTemplateSchema,
-  emailSchema,
-  emergencyContactSchema,
-  filledDocumentSchema,
-  filledDocumentStatusSchema,
-  finalBillingSchema,
-  finalizedDetailsSchema,
-  gamificationSchema,
   getFirebaseApp,
   getFirebaseAuth,
   getFirebaseDB,
   getFirebaseFunctions,
   getFirebaseInstance,
   getFirebaseStorage,
-  initializeFirebase,
-  linkedFormInfoSchema,
-  locationDataSchema,
-  mediaResourceSchema,
-  mediaTypeSchema,
-  medicationSchema,
-  notificationSchema,
-  passwordSchema,
-  patientClinicSchema,
-  patientDoctorSchema,
-  patientInstructionStatusSchema,
-  patientLocationInfoSchema,
-  patientMedicalInfoSchema,
-  patientProfileInfoSchema,
-  patientProfileSchema,
-  patientRequirementInstanceSchema,
-  patientRequirementInstructionSchema,
-  patientRequirementOverallStatusSchema,
-  patientReviewInfoSchema,
-  patientSensitiveInfoSchema,
-  patientTokenSchema,
-  paymentStatusSchema,
-  postRequirementNotificationSchema,
-  practitionerBasicInfoSchema,
-  practitionerCertificationSchema,
-  practitionerClinicWorkingHoursSchema,
-  practitionerProfileInfoSchema,
-  practitionerReviewInfoSchema,
-  practitionerReviewSchema,
-  practitionerSchema,
-  practitionerSignupSchema,
-  practitionerTokenSchema,
-  practitionerWorkingHoursSchema,
-  preRequirementNotificationSchema,
-  procedureCategorizationSchema,
-  procedureExtendedInfoSchema,
-  procedureInfoSchema,
-  procedureReviewInfoSchema,
-  procedureReviewSchema,
-  procedureSchema,
-  procedureSummaryInfoSchema,
-  requesterInfoSchema,
-  requirementImportanceSchema,
-  requirementInstructionDueNotificationSchema,
-  rescheduleAppointmentSchema,
-  reviewSchema,
-  searchAppointmentsSchema,
-  searchPatientsSchema,
-  sharedClinicContactInfoSchema,
-  sharedClinicLocationSchema,
-  syncedCalendarEventSchema,
-  timeSlotSchema,
-  timestampSchema,
-  updateAllergySchema,
-  updateAppointmentSchema,
-  updateBlockingConditionSchema,
-  updateBlockingEventSchema,
-  updateCalendarEventSchema,
-  updateClinicAdminSchema,
-  updateClinicGroupSchema,
-  updateClinicSchema,
-  updateContraindicationSchema,
-  updateDocumentTemplateSchema,
-  updateFilledDocumentDataSchema,
-  updateMedicationSchema,
-  updatePatientInstructionStatusSchema,
-  updatePatientMedicalInfoSchema,
-  updateProcedureSchema,
-  updateVitalStatsSchema,
-  userRoleSchema,
-  userRolesSchema,
-  userSchema,
-  vitalStatsSchema,
-  workingHoursSchema
+  initializeFirebase
 });