@blackcode_sa/metaestetics-api 1.5.34 → 1.5.36

package/dist/index.js

@@ -30,9 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  APPOINTMENTS_COLLECTION: () => APPOINTMENTS_COLLECTION,
   AUTH_ERRORS: () => AUTH_ERRORS,
   AdminTokenStatus: () => AdminTokenStatus,
   AllergyType: () => AllergyType,
+  AppointmentService: () => AppointmentService,
+  AppointmentStatus: () => AppointmentStatus,
   AuthService: () => AuthService,
   BlockingCondition: () => BlockingCondition,
   BrandService: () => BrandService,
@@ -82,6 +85,7 @@ __export(index_exports, {
   PRACTITIONERS_COLLECTION: () => PRACTITIONERS_COLLECTION,
   PROCEDURES_COLLECTION: () => PROCEDURES_COLLECTION,
   PatientService: () => PatientService,
+  PaymentStatus: () => PaymentStatus,
   PracticeType: () => PracticeType,
   PractitionerService: () => PractitionerService,
   PractitionerStatus: () => PractitionerStatus,
@@ -196,6 +200,7 @@ __export(index_exports, {
   procedureSummaryInfoSchema: () => procedureSummaryInfoSchema,
   requesterInfoSchema: () => requesterInfoSchema,
   reviewSchema: () => reviewSchema,
+  searchAppointmentsSchema: () => searchAppointmentsSchema,
   searchPatientsSchema: () => searchPatientsSchema,
   syncedCalendarEventSchema: () => syncedCalendarEventSchema,
   timeSlotSchema: () => timeSlotSchema2,
@@ -220,6 +225,109 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/validations/appointment.schema.ts
+var import_zod = require("zod");
+
+// src/types/appointment/index.ts
+var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
+  AppointmentStatus2["SCHEDULED"] = "scheduled";
+  AppointmentStatus2["CONFIRMED"] = "confirmed";
+  AppointmentStatus2["CHECKED_IN"] = "checked_in";
+  AppointmentStatus2["IN_PROGRESS"] = "in_progress";
+  AppointmentStatus2["COMPLETED"] = "completed";
+  AppointmentStatus2["CANCELED_PATIENT"] = "canceled_patient";
+  AppointmentStatus2["CANCELED_CLINIC"] = "canceled_clinic";
+  AppointmentStatus2["NO_SHOW"] = "no_show";
+  AppointmentStatus2["RESCHEDULED"] = "rescheduled";
+  return AppointmentStatus2;
+})(AppointmentStatus || {});
+var PaymentStatus = /* @__PURE__ */ ((PaymentStatus3) => {
+  PaymentStatus3["UNPAID"] = "unpaid";
+  PaymentStatus3["PAID"] = "paid";
+  PaymentStatus3["PARTIALLY_PAID"] = "partially_paid";
+  PaymentStatus3["REFUNDED"] = "refunded";
+  PaymentStatus3["NOT_APPLICABLE"] = "not_applicable";
+  return PaymentStatus3;
+})(PaymentStatus || {});
+var APPOINTMENTS_COLLECTION = "appointments";
+
+// src/validations/appointment.schema.ts
+var createAppointmentSchema = import_zod.z.object({
+  calendarEventId: import_zod.z.string().min(1, "Calendar event ID is required"),
+  clinicBranchId: import_zod.z.string().min(1, "Clinic branch ID is required"),
+  practitionerId: import_zod.z.string().min(1, "Practitioner ID is required"),
+  patientId: import_zod.z.string().min(1, "Patient ID is required"),
+  procedureId: import_zod.z.string().min(1, "Procedure ID is required"),
+  appointmentStartTime: import_zod.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
+    "Appointment start time must be a valid timestamp"
+  ),
+  appointmentEndTime: import_zod.z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
+    "Appointment end time must be a valid timestamp"
+  ),
+  cost: import_zod.z.number().min(0, "Cost must be a non-negative number"),
+  currency: import_zod.z.string().min(1, "Currency is required"),
+  patientNotes: import_zod.z.string().nullable().optional(),
+  initialStatus: import_zod.z.nativeEnum(AppointmentStatus, {
+    errorMap: () => ({ message: "Invalid appointment status" })
+  }),
+  initialPaymentStatus: import_zod.z.nativeEnum(PaymentStatus, {
+    errorMap: () => ({ message: "Invalid payment status" })
+  }).optional().default("unpaid" /* UNPAID */)
+});
+var updateAppointmentSchema = import_zod.z.object({
+  status: import_zod.z.nativeEnum(AppointmentStatus, {
+    errorMap: () => ({ message: "Invalid appointment status" })
+  }).optional(),
+  confirmationTime: import_zod.z.any().refine(
+    (val) => val === null || val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
+    "Confirmation time must be a valid timestamp or null"
+  ).optional(),
+  actualDurationMinutes: import_zod.z.number().positive("Duration must be positive").optional(),
+  cancellationReason: import_zod.z.string().nullable().optional(),
+  canceledBy: import_zod.z.enum(["patient", "clinic", "practitioner", "system"]).optional(),
+  internalNotes: import_zod.z.string().nullable().optional(),
+  paymentStatus: import_zod.z.nativeEnum(PaymentStatus, {
+    errorMap: () => ({ message: "Invalid payment status" })
+  }).optional(),
+  paymentTransactionId: import_zod.z.string().nullable().optional(),
+  completedPreRequirements: import_zod.z.array(import_zod.z.string()).optional(),
+  completedPostRequirements: import_zod.z.array(import_zod.z.string()).optional()
+}).refine(
+  (data) => {
+    if (data.status === "canceled_clinic" /* CANCELED_CLINIC */ || data.status === "canceled_patient" /* CANCELED_PATIENT */) {
+      return !!data.cancellationReason && !!data.canceledBy;
+    }
+    return true;
+  },
+  {
+    message: "Cancellation reason and canceled by must be provided when canceling an appointment",
+    path: ["status"]
+  }
+);
+var searchAppointmentsSchema = import_zod.z.object({
+  patientId: import_zod.z.string().optional(),
+  practitionerId: import_zod.z.string().optional(),
+  clinicBranchId: import_zod.z.string().optional(),
+  startDate: import_zod.z.date().optional(),
+  endDate: import_zod.z.date().optional(),
+  status: import_zod.z.union([
+    import_zod.z.nativeEnum(AppointmentStatus),
+    import_zod.z.array(import_zod.z.nativeEnum(AppointmentStatus))
+  ]).optional(),
+  limit: import_zod.z.number().positive().optional(),
+  startAfter: import_zod.z.any().optional()
+}).refine(
+  (data) => {
+    return !!(data.patientId || data.practitionerId || data.clinicBranchId);
+  },
+  {
+    message: "At least one of patientId, practitionerId, or clinicBranchId must be provided",
+    path: ["searchCriteria"]
+  }
+);
+
 // src/config/firebase.ts
 var import_app = require("firebase/app");
 var import_firestore = require("firebase/firestore");
@@ -355,86 +463,86 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/validations/schemas.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/validations/documentation-templates/template.schema.ts
-var import_zod = require("zod");
-var baseElementSchema = import_zod.z.object({
-  id: import_zod.z.string().optional(),
+var import_zod2 = require("zod");
+var baseElementSchema = import_zod2.z.object({
+  id: import_zod2.z.string().optional(),
   // Make id optional so we can omit it later
-  type: import_zod.z.nativeEnum(DocumentElementType),
-  required: import_zod.z.boolean().optional()
+  type: import_zod2.z.nativeEnum(DocumentElementType),
+  required: import_zod2.z.boolean().optional()
 });
 var headingElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("heading" /* HEADING */),
-  text: import_zod.z.string().min(1).max(200),
-  level: import_zod.z.nativeEnum(HeadingLevel)
+  type: import_zod2.z.literal("heading" /* HEADING */),
+  text: import_zod2.z.string().min(1).max(200),
+  level: import_zod2.z.nativeEnum(HeadingLevel)
 });
 var paragraphElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("paragraph" /* PARAGRAPH */),
-  text: import_zod.z.string().min(1).max(5e3)
+  type: import_zod2.z.literal("paragraph" /* PARAGRAPH */),
+  text: import_zod2.z.string().min(1).max(5e3)
 });
 var listElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("list" /* LIST */),
-  items: import_zod.z.array(import_zod.z.string().min(1).max(500)).min(1).max(100),
-  listType: import_zod.z.nativeEnum(ListType)
+  type: import_zod2.z.literal("list" /* LIST */),
+  items: import_zod2.z.array(import_zod2.z.string().min(1).max(500)).min(1).max(100),
+  listType: import_zod2.z.nativeEnum(ListType)
 });
 var dynamicTextElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("dynamic_text" /* DYNAMIC_TEXT */),
-  text: import_zod.z.string().min(1).max(5e3)
+  type: import_zod2.z.literal("dynamic_text" /* DYNAMIC_TEXT */),
+  text: import_zod2.z.string().min(1).max(5e3)
 });
 var binaryChoiceElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("binary_choice" /* BINARY_CHOICE */),
-  question: import_zod.z.string().min(1).max(500),
-  defaultValue: import_zod.z.boolean().optional()
+  type: import_zod2.z.literal("binary_choice" /* BINARY_CHOICE */),
+  question: import_zod2.z.string().min(1).max(500),
+  defaultValue: import_zod2.z.boolean().optional()
 });
 var multipleChoiceElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("multiple_choice" /* MULTIPLE_CHOICE */),
-  question: import_zod.z.string().min(1).max(500),
-  options: import_zod.z.array(import_zod.z.string().min(1).max(200)).min(2).max(50),
-  defaultValues: import_zod.z.array(import_zod.z.string()).optional()
+  type: import_zod2.z.literal("multiple_choice" /* MULTIPLE_CHOICE */),
+  question: import_zod2.z.string().min(1).max(500),
+  options: import_zod2.z.array(import_zod2.z.string().min(1).max(200)).min(2).max(50),
+  defaultValues: import_zod2.z.array(import_zod2.z.string()).optional()
 });
 var singleChoiceElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("single_choice" /* SINGLE_CHOICE */),
-  question: import_zod.z.string().min(1).max(500),
-  options: import_zod.z.array(import_zod.z.string().min(1).max(200)).min(2).max(50),
-  defaultValue: import_zod.z.string().optional()
+  type: import_zod2.z.literal("single_choice" /* SINGLE_CHOICE */),
+  question: import_zod2.z.string().min(1).max(500),
+  options: import_zod2.z.array(import_zod2.z.string().min(1).max(200)).min(2).max(50),
+  defaultValue: import_zod2.z.string().optional()
 });
 var ratingScaleElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("rating_scale" /* RATING_SCALE */),
-  question: import_zod.z.string().min(1).max(500),
-  min: import_zod.z.number().int().min(0).max(10),
-  max: import_zod.z.number().int().min(1).max(10),
-  labels: import_zod.z.record(import_zod.z.string()).optional(),
-  defaultValue: import_zod.z.number().int().optional()
+  type: import_zod2.z.literal("rating_scale" /* RATING_SCALE */),
+  question: import_zod2.z.string().min(1).max(500),
+  min: import_zod2.z.number().int().min(0).max(10),
+  max: import_zod2.z.number().int().min(1).max(10),
+  labels: import_zod2.z.record(import_zod2.z.string()).optional(),
+  defaultValue: import_zod2.z.number().int().optional()
 });
 var textInputElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("text_input" /* TEXT_INPUT */),
-  label: import_zod.z.string().min(1).max(200),
-  placeholder: import_zod.z.string().max(200).optional(),
-  multiline: import_zod.z.boolean().optional(),
-  defaultValue: import_zod.z.string().optional()
+  type: import_zod2.z.literal("text_input" /* TEXT_INPUT */),
+  label: import_zod2.z.string().min(1).max(200),
+  placeholder: import_zod2.z.string().max(200).optional(),
+  multiline: import_zod2.z.boolean().optional(),
+  defaultValue: import_zod2.z.string().optional()
 });
 var datePickerElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("date_picker" /* DATE_PICKER */),
-  label: import_zod.z.string().min(1).max(200),
-  defaultValue: import_zod.z.string().optional()
+  type: import_zod2.z.literal("date_picker" /* DATE_PICKER */),
+  label: import_zod2.z.string().min(1).max(200),
+  defaultValue: import_zod2.z.string().optional()
   // ISO date string
 });
 var signatureElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("signature" /* SIGNATURE */),
-  label: import_zod.z.string().min(1).max(200)
+  type: import_zod2.z.literal("signature" /* SIGNATURE */),
+  label: import_zod2.z.string().min(1).max(200)
 });
 var fileUploadElementSchema = baseElementSchema.extend({
-  type: import_zod.z.literal("file_upload" /* FILE_UPLOAD */),
-  label: import_zod.z.string().min(1).max(200),
-  allowedFileTypes: import_zod.z.array(import_zod.z.string()).optional(),
-  maxFileSizeMB: import_zod.z.number().positive().optional()
+  type: import_zod2.z.literal("file_upload" /* FILE_UPLOAD */),
+  label: import_zod2.z.string().min(1).max(200),
+  allowedFileTypes: import_zod2.z.array(import_zod2.z.string()).optional(),
+  maxFileSizeMB: import_zod2.z.number().positive().optional()
 });
-var documentElementSchema = import_zod.z.discriminatedUnion("type", [
+var documentElementSchema = import_zod2.z.discriminatedUnion("type", [
   headingElementSchema,
   paragraphElementSchema,
   listElementSchema,
@@ -448,7 +556,7 @@ var documentElementSchema = import_zod.z.discriminatedUnion("type", [
   signatureElementSchema,
   fileUploadElementSchema
 ]);
-var documentElementWithoutIdSchema = import_zod.z.discriminatedUnion("type", [
+var documentElementWithoutIdSchema = import_zod2.z.discriminatedUnion("type", [
   headingElementSchema.omit({ id: true }),
   paragraphElementSchema.omit({ id: true }),
   listElementSchema.omit({ id: true }),
@@ -462,50 +570,50 @@ var documentElementWithoutIdSchema = import_zod.z.discriminatedUnion("type", [
   signatureElementSchema.omit({ id: true }),
   fileUploadElementSchema.omit({ id: true })
 ]);
-var createDocumentTemplateSchema = import_zod.z.object({
-  title: import_zod.z.string().min(1).max(200),
-  description: import_zod.z.string().max(1e3).optional(),
-  elements: import_zod.z.array(documentElementWithoutIdSchema).min(1).max(100),
-  tags: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20).optional()
+var createDocumentTemplateSchema = import_zod2.z.object({
+  title: import_zod2.z.string().min(1).max(200),
+  description: import_zod2.z.string().max(1e3).optional(),
+  elements: import_zod2.z.array(documentElementWithoutIdSchema).min(1).max(100),
+  tags: import_zod2.z.array(import_zod2.z.string().min(1).max(50)).max(20).optional()
 });
-var updateDocumentTemplateSchema = import_zod.z.object({
-  title: import_zod.z.string().min(1).max(200).optional(),
-  description: import_zod.z.string().max(1e3).optional(),
-  elements: import_zod.z.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
-  tags: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20).optional(),
-  isActive: import_zod.z.boolean().optional()
+var updateDocumentTemplateSchema = import_zod2.z.object({
+  title: import_zod2.z.string().min(1).max(200).optional(),
+  description: import_zod2.z.string().max(1e3).optional(),
+  elements: import_zod2.z.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
+  tags: import_zod2.z.array(import_zod2.z.string().min(1).max(50)).max(20).optional(),
+  isActive: import_zod2.z.boolean().optional()
 });
-var documentTemplateSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  title: import_zod.z.string().min(1).max(200),
-  description: import_zod.z.string().max(1e3).optional(),
-  createdAt: import_zod.z.number(),
-  updatedAt: import_zod.z.number(),
-  createdBy: import_zod.z.string(),
-  elements: import_zod.z.array(documentElementSchema),
-  tags: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20).optional(),
-  version: import_zod.z.number().int().positive(),
-  isActive: import_zod.z.boolean()
+var documentTemplateSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  title: import_zod2.z.string().min(1).max(200),
+  description: import_zod2.z.string().max(1e3).optional(),
+  createdAt: import_zod2.z.number(),
+  updatedAt: import_zod2.z.number(),
+  createdBy: import_zod2.z.string(),
+  elements: import_zod2.z.array(documentElementSchema),
+  tags: import_zod2.z.array(import_zod2.z.string().min(1).max(50)).max(20).optional(),
+  version: import_zod2.z.number().int().positive(),
+  isActive: import_zod2.z.boolean()
 });
 
 // src/validations/schemas.ts
-var emailSchema = import_zod2.z.string().email("Invalid email format").min(5, "Email must be at least 5 characters").max(255, "Email must be less than 255 characters");
-var passwordSchema = import_zod2.z.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
+var emailSchema = import_zod3.z.string().email("Invalid email format").min(5, "Email must be at least 5 characters").max(255, "Email must be less than 255 characters");
+var passwordSchema = import_zod3.z.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
   /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d\w\W]{8,}$/,
   "Password must contain at least one uppercase letter, one lowercase letter, and one number"
 );
-var userRoleSchema = import_zod2.z.nativeEnum(UserRole);
-var userRolesSchema = import_zod2.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = import_zod2.z.custom((data) => {
+var userRoleSchema = import_zod3.z.nativeEnum(UserRole);
+var userRolesSchema = import_zod3.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
+var timestampSchema = import_zod3.z.custom((data) => {
   if (data && typeof data === "object" && "isEqual" in data) {
     return true;
   }
   return data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data;
 }, "Must be a Timestamp object or serverTimestamp");
-var clinicAdminOptionsSchema = import_zod2.z.object({
-  isGroupOwner: import_zod2.z.boolean(),
-  groupToken: import_zod2.z.string().optional(),
-  groupId: import_zod2.z.string().optional()
+var clinicAdminOptionsSchema = import_zod3.z.object({
+  isGroupOwner: import_zod3.z.boolean(),
+  groupToken: import_zod3.z.string().optional(),
+  groupId: import_zod3.z.string().optional()
 }).refine(
   (data) => {
     if (!data.isGroupOwner && (!data.groupToken || !data.groupId)) {
@@ -520,20 +628,20 @@ var clinicAdminOptionsSchema = import_zod2.z.object({
     message: "Invalid clinic admin options configuration"
   }
 );
-var createUserOptionsSchema = import_zod2.z.object({
+var createUserOptionsSchema = import_zod3.z.object({
   clinicAdminData: clinicAdminOptionsSchema.optional()
 });
-var userSchema = import_zod2.z.object({
-  uid: import_zod2.z.string(),
-  email: import_zod2.z.string().email().nullable(),
-  roles: import_zod2.z.array(userRoleSchema),
-  isAnonymous: import_zod2.z.boolean(),
+var userSchema = import_zod3.z.object({
+  uid: import_zod3.z.string(),
+  email: import_zod3.z.string().email().nullable(),
+  roles: import_zod3.z.array(userRoleSchema),
+  isAnonymous: import_zod3.z.boolean(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema,
   lastLoginAt: timestampSchema,
-  patientProfile: import_zod2.z.string().optional(),
-  practitionerProfile: import_zod2.z.string().optional(),
-  adminProfile: import_zod2.z.string().optional()
+  patientProfile: import_zod3.z.string().optional(),
+  practitionerProfile: import_zod3.z.string().optional(),
+  adminProfile: import_zod3.z.string().optional()
 });
 
 // src/errors/auth.errors.ts
@@ -880,7 +988,7 @@ var USER_ERRORS = {
 };
 
 // src/services/user.service.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // src/services/patient/patient.service.ts
 var import_firestore9 = require("firebase/firestore");
@@ -888,7 +996,7 @@ var import_firestore9 = require("firebase/firestore");
 // src/services/patient/utils/profile.utils.ts
 var import_firestore6 = require("firebase/firestore");
 var import_storage2 = require("firebase/storage");
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/types/patient/medical-info.types.ts
 var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
@@ -917,11 +1025,11 @@ var Gender = /* @__PURE__ */ ((Gender2) => {
 })(Gender || {});
 
 // src/validations/patient.schema.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var import_firestore2 = require("firebase/firestore");
 
 // src/validations/patient/medical-info.schema.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/types/patient/allergies.ts
 var AllergyType = /* @__PURE__ */ ((AllergyType2) => {
@@ -1010,71 +1118,71 @@ var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
 })(Contraindication || {});
 
 // src/validations/common.schema.ts
-var import_zod3 = require("zod");
-var timestampSchema2 = import_zod3.z.object({
-  seconds: import_zod3.z.number(),
-  nanoseconds: import_zod3.z.number()
+var import_zod4 = require("zod");
+var timestampSchema2 = import_zod4.z.object({
+  seconds: import_zod4.z.number(),
+  nanoseconds: import_zod4.z.number()
 });
 
 // src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = import_zod4.z.union([
-  import_zod4.z.nativeEnum(MedicationAllergySubtype),
-  import_zod4.z.nativeEnum(FoodAllergySubtype),
-  import_zod4.z.nativeEnum(EnvironmentalAllergySubtype),
-  import_zod4.z.nativeEnum(CosmeticAllergySubtype),
-  import_zod4.z.literal("other")
+var allergySubtypeSchema = import_zod5.z.union([
+  import_zod5.z.nativeEnum(MedicationAllergySubtype),
+  import_zod5.z.nativeEnum(FoodAllergySubtype),
+  import_zod5.z.nativeEnum(EnvironmentalAllergySubtype),
+  import_zod5.z.nativeEnum(CosmeticAllergySubtype),
+  import_zod5.z.literal("other")
 ]);
-var allergySchema = import_zod4.z.object({
-  type: import_zod4.z.nativeEnum(AllergyType),
+var allergySchema = import_zod5.z.object({
+  type: import_zod5.z.nativeEnum(AllergyType),
   subtype: allergySubtypeSchema,
-  name: import_zod4.z.string().optional(),
-  severity: import_zod4.z.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: import_zod4.z.string().optional(),
+  name: import_zod5.z.string().optional(),
+  severity: import_zod5.z.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: import_zod5.z.string().optional(),
   diagnosed: timestampSchema2.optional(),
-  notes: import_zod4.z.string().optional()
+  notes: import_zod5.z.string().optional()
 });
-var vitalStatsSchema = import_zod4.z.object({
-  height: import_zod4.z.number().positive().optional(),
-  weight: import_zod4.z.number().positive().optional(),
-  bloodType: import_zod4.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: import_zod4.z.object({
-    systolic: import_zod4.z.number().min(70).max(200),
-    diastolic: import_zod4.z.number().min(40).max(130),
+var vitalStatsSchema = import_zod5.z.object({
+  height: import_zod5.z.number().positive().optional(),
+  weight: import_zod5.z.number().positive().optional(),
+  bloodType: import_zod5.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: import_zod5.z.object({
+    systolic: import_zod5.z.number().min(70).max(200),
+    diastolic: import_zod5.z.number().min(40).max(130),
     lastMeasured: timestampSchema2
   }).optional()
 });
-var blockingConditionSchema = import_zod4.z.object({
-  condition: import_zod4.z.nativeEnum(BlockingCondition),
+var blockingConditionSchema = import_zod5.z.object({
+  condition: import_zod5.z.nativeEnum(BlockingCondition),
   diagnosedAt: timestampSchema2,
-  notes: import_zod4.z.string().optional(),
-  isActive: import_zod4.z.boolean()
+  notes: import_zod5.z.string().optional(),
+  isActive: import_zod5.z.boolean()
 });
-var contraindicationSchema = import_zod4.z.object({
-  condition: import_zod4.z.nativeEnum(Contraindication),
+var contraindicationSchema = import_zod5.z.object({
+  condition: import_zod5.z.nativeEnum(Contraindication),
   lastOccurrence: timestampSchema2,
-  frequency: import_zod4.z.enum(["rare", "occasional", "frequent"]),
-  notes: import_zod4.z.string().optional(),
-  isActive: import_zod4.z.boolean()
+  frequency: import_zod5.z.enum(["rare", "occasional", "frequent"]),
+  notes: import_zod5.z.string().optional(),
+  isActive: import_zod5.z.boolean()
 });
-var medicationSchema = import_zod4.z.object({
-  name: import_zod4.z.string().min(1),
-  dosage: import_zod4.z.string().min(1),
-  frequency: import_zod4.z.string().min(1),
+var medicationSchema = import_zod5.z.object({
+  name: import_zod5.z.string().min(1),
+  dosage: import_zod5.z.string().min(1),
+  frequency: import_zod5.z.string().min(1),
   startDate: timestampSchema2,
   endDate: timestampSchema2.optional(),
-  prescribedBy: import_zod4.z.string().optional()
+  prescribedBy: import_zod5.z.string().optional()
 });
-var patientMedicalInfoSchema = import_zod4.z.object({
-  patientId: import_zod4.z.string(),
+var patientMedicalInfoSchema = import_zod5.z.object({
+  patientId: import_zod5.z.string(),
   vitalStats: vitalStatsSchema,
-  blockingConditions: import_zod4.z.array(blockingConditionSchema),
-  contraindications: import_zod4.z.array(contraindicationSchema),
-  allergies: import_zod4.z.array(allergySchema),
-  currentMedications: import_zod4.z.array(medicationSchema),
-  emergencyNotes: import_zod4.z.string().optional(),
+  blockingConditions: import_zod5.z.array(blockingConditionSchema),
+  contraindications: import_zod5.z.array(contraindicationSchema),
+  allergies: import_zod5.z.array(allergySchema),
+  currentMedications: import_zod5.z.array(medicationSchema),
+  emergencyNotes: import_zod5.z.string().optional(),
   lastUpdated: timestampSchema2,
-  updatedBy: import_zod4.z.string(),
-  verifiedBy: import_zod4.z.string().optional(),
+  updatedBy: import_zod5.z.string(),
+  verifiedBy: import_zod5.z.string().optional(),
   verifiedAt: timestampSchema2.optional()
 });
 var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
@@ -1088,141 +1196,141 @@ var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
 var updateVitalStatsSchema = vitalStatsSchema;
 var addAllergySchema = allergySchema;
 var updateAllergySchema = allergySchema.partial().extend({
-  allergyIndex: import_zod4.z.number().min(0)
+  allergyIndex: import_zod5.z.number().min(0)
 });
 var addBlockingConditionSchema = blockingConditionSchema;
 var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: import_zod4.z.number().min(0)
+  conditionIndex: import_zod5.z.number().min(0)
 });
 var addContraindicationSchema = contraindicationSchema;
 var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: import_zod4.z.number().min(0)
+  contraindicationIndex: import_zod5.z.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
 var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: import_zod4.z.number().min(0)
+  medicationIndex: import_zod5.z.number().min(0)
 });
 
 // src/validations/patient.schema.ts
-var locationDataSchema = import_zod5.z.object({
-  latitude: import_zod5.z.number().min(-90).max(90),
-  longitude: import_zod5.z.number().min(-180).max(180),
-  geohash: import_zod5.z.string().optional()
+var locationDataSchema = import_zod6.z.object({
+  latitude: import_zod6.z.number().min(-90).max(90),
+  longitude: import_zod6.z.number().min(-180).max(180),
+  geohash: import_zod6.z.string().optional()
 });
-var addressDataSchema = import_zod5.z.object({
-  address: import_zod5.z.string(),
-  city: import_zod5.z.string(),
-  country: import_zod5.z.string(),
-  postalCode: import_zod5.z.string()
+var addressDataSchema = import_zod6.z.object({
+  address: import_zod6.z.string(),
+  city: import_zod6.z.string(),
+  country: import_zod6.z.string(),
+  postalCode: import_zod6.z.string()
 });
-var emergencyContactSchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  relationship: import_zod5.z.string(),
-  phoneNumber: import_zod5.z.string(),
-  isNotifiable: import_zod5.z.boolean()
+var emergencyContactSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  relationship: import_zod6.z.string(),
+  phoneNumber: import_zod6.z.string(),
+  isNotifiable: import_zod6.z.boolean()
 });
-var gamificationSchema = import_zod5.z.object({
-  level: import_zod5.z.number(),
-  points: import_zod5.z.number()
+var gamificationSchema = import_zod6.z.object({
+  level: import_zod6.z.number(),
+  points: import_zod6.z.number()
 });
-var patientLocationInfoSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string(),
-  userRef: import_zod5.z.string(),
+var patientLocationInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
+  userRef: import_zod6.z.string(),
   locationData: locationDataSchema,
-  createdAt: import_zod5.z.instanceof(import_firestore2.Timestamp),
-  updatedAt: import_zod5.z.instanceof(import_firestore2.Timestamp)
+  createdAt: import_zod6.z.instanceof(import_firestore2.Timestamp),
+  updatedAt: import_zod6.z.instanceof(import_firestore2.Timestamp)
 });
-var createPatientLocationInfoSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string(),
-  userRef: import_zod5.z.string(),
+var createPatientLocationInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
+  userRef: import_zod6.z.string(),
   locationData: locationDataSchema
 });
-var patientSensitiveInfoSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string(),
-  userRef: import_zod5.z.string(),
-  photoUrl: import_zod5.z.string().optional(),
-  firstName: import_zod5.z.string().min(2),
-  lastName: import_zod5.z.string().min(2),
-  dateOfBirth: import_zod5.z.instanceof(import_firestore2.Timestamp).nullable(),
-  gender: import_zod5.z.nativeEnum(Gender),
-  email: import_zod5.z.string().email().optional(),
-  phoneNumber: import_zod5.z.string().optional(),
-  alternativePhoneNumber: import_zod5.z.string().optional(),
+var patientSensitiveInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
+  userRef: import_zod6.z.string(),
+  photoUrl: import_zod6.z.string().optional(),
+  firstName: import_zod6.z.string().min(2),
+  lastName: import_zod6.z.string().min(2),
+  dateOfBirth: import_zod6.z.instanceof(import_firestore2.Timestamp).nullable(),
+  gender: import_zod6.z.nativeEnum(Gender),
+  email: import_zod6.z.string().email().optional(),
+  phoneNumber: import_zod6.z.string().optional(),
+  alternativePhoneNumber: import_zod6.z.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod5.z.array(emergencyContactSchema).optional(),
-  createdAt: import_zod5.z.instanceof(import_firestore2.Timestamp),
-  updatedAt: import_zod5.z.instanceof(import_firestore2.Timestamp)
+  emergencyContacts: import_zod6.z.array(emergencyContactSchema).optional(),
+  createdAt: import_zod6.z.instanceof(import_firestore2.Timestamp),
+  updatedAt: import_zod6.z.instanceof(import_firestore2.Timestamp)
 });
-var patientDoctorSchema = import_zod5.z.object({
-  userRef: import_zod5.z.string(),
-  assignedAt: import_zod5.z.instanceof(import_firestore2.Timestamp),
-  assignedBy: import_zod5.z.string().optional(),
-  isActive: import_zod5.z.boolean(),
-  notes: import_zod5.z.string().optional()
+var patientDoctorSchema = import_zod6.z.object({
+  userRef: import_zod6.z.string(),
+  assignedAt: import_zod6.z.instanceof(import_firestore2.Timestamp),
+  assignedBy: import_zod6.z.string().optional(),
+  isActive: import_zod6.z.boolean(),
+  notes: import_zod6.z.string().optional()
 });
-var patientClinicSchema = import_zod5.z.object({
-  clinicId: import_zod5.z.string(),
-  assignedAt: import_zod5.z.instanceof(import_firestore2.Timestamp),
-  assignedBy: import_zod5.z.string().optional(),
-  isActive: import_zod5.z.boolean(),
-  notes: import_zod5.z.string().optional()
+var patientClinicSchema = import_zod6.z.object({
+  clinicId: import_zod6.z.string(),
+  assignedAt: import_zod6.z.instanceof(import_firestore2.Timestamp),
+  assignedBy: import_zod6.z.string().optional(),
+  isActive: import_zod6.z.boolean(),
+  notes: import_zod6.z.string().optional()
 });
-var patientProfileSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  userRef: import_zod5.z.string(),
-  displayName: import_zod5.z.string(),
-  profilePhoto: import_zod5.z.string().url().nullable(),
+var patientProfileSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  userRef: import_zod6.z.string(),
+  displayName: import_zod6.z.string(),
+  profilePhoto: import_zod6.z.string().url().nullable(),
   gamification: gamificationSchema,
-  expoTokens: import_zod5.z.array(import_zod5.z.string()),
-  isActive: import_zod5.z.boolean(),
-  isVerified: import_zod5.z.boolean(),
-  doctors: import_zod5.z.array(patientDoctorSchema),
-  clinics: import_zod5.z.array(patientClinicSchema),
-  doctorIds: import_zod5.z.array(import_zod5.z.string()),
-  clinicIds: import_zod5.z.array(import_zod5.z.string()),
-  createdAt: import_zod5.z.instanceof(import_firestore2.Timestamp),
-  updatedAt: import_zod5.z.instanceof(import_firestore2.Timestamp)
+  expoTokens: import_zod6.z.array(import_zod6.z.string()),
+  isActive: import_zod6.z.boolean(),
+  isVerified: import_zod6.z.boolean(),
+  doctors: import_zod6.z.array(patientDoctorSchema),
+  clinics: import_zod6.z.array(patientClinicSchema),
+  doctorIds: import_zod6.z.array(import_zod6.z.string()),
+  clinicIds: import_zod6.z.array(import_zod6.z.string()),
+  createdAt: import_zod6.z.instanceof(import_firestore2.Timestamp),
+  updatedAt: import_zod6.z.instanceof(import_firestore2.Timestamp)
 });
-var createPatientProfileSchema = import_zod5.z.object({
-  userRef: import_zod5.z.string(),
-  displayName: import_zod5.z.string(),
-  profilePhoto: import_zod5.z.string().url().nullable().optional(),
-  expoTokens: import_zod5.z.array(import_zod5.z.string()),
+var createPatientProfileSchema = import_zod6.z.object({
+  userRef: import_zod6.z.string(),
+  displayName: import_zod6.z.string(),
+  profilePhoto: import_zod6.z.string().url().nullable().optional(),
+  expoTokens: import_zod6.z.array(import_zod6.z.string()),
   gamification: gamificationSchema.optional(),
-  isActive: import_zod5.z.boolean(),
-  isVerified: import_zod5.z.boolean(),
-  doctors: import_zod5.z.array(patientDoctorSchema).optional(),
-  clinics: import_zod5.z.array(patientClinicSchema).optional(),
-  doctorIds: import_zod5.z.array(import_zod5.z.string()).optional(),
-  clinicIds: import_zod5.z.array(import_zod5.z.string()).optional()
+  isActive: import_zod6.z.boolean(),
+  isVerified: import_zod6.z.boolean(),
+  doctors: import_zod6.z.array(patientDoctorSchema).optional(),
+  clinics: import_zod6.z.array(patientClinicSchema).optional(),
+  doctorIds: import_zod6.z.array(import_zod6.z.string()).optional(),
+  clinicIds: import_zod6.z.array(import_zod6.z.string()).optional()
 });
-var createPatientSensitiveInfoSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string(),
-  userRef: import_zod5.z.string(),
-  photoUrl: import_zod5.z.string().optional(),
-  firstName: import_zod5.z.string().min(2),
-  lastName: import_zod5.z.string().min(2),
-  dateOfBirth: import_zod5.z.instanceof(import_firestore2.Timestamp).nullable(),
-  gender: import_zod5.z.nativeEnum(Gender),
-  email: import_zod5.z.string().email().optional(),
-  phoneNumber: import_zod5.z.string().optional(),
-  alternativePhoneNumber: import_zod5.z.string().optional(),
+var createPatientSensitiveInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
+  userRef: import_zod6.z.string(),
+  photoUrl: import_zod6.z.string().optional(),
+  firstName: import_zod6.z.string().min(2),
+  lastName: import_zod6.z.string().min(2),
+  dateOfBirth: import_zod6.z.instanceof(import_firestore2.Timestamp).nullable(),
+  gender: import_zod6.z.nativeEnum(Gender),
+  email: import_zod6.z.string().email().optional(),
+  phoneNumber: import_zod6.z.string().optional(),
+  alternativePhoneNumber: import_zod6.z.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod5.z.array(emergencyContactSchema).optional()
+  emergencyContacts: import_zod6.z.array(emergencyContactSchema).optional()
 });
-var searchPatientsSchema = import_zod5.z.object({
-  clinicId: import_zod5.z.string().optional(),
-  practitionerId: import_zod5.z.string().optional()
+var searchPatientsSchema = import_zod6.z.object({
+  clinicId: import_zod6.z.string().optional(),
+  practitionerId: import_zod6.z.string().optional()
 }).refine((data) => data.clinicId || data.practitionerId, {
   message: "At least one of clinicId or practitionerId must be provided",
   path: []
   // Optional: specify a path like ['clinicId'] or ['practitionerId']
 });
-var requesterInfoSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  role: import_zod5.z.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: import_zod5.z.string().optional(),
-  associatedPractitionerId: import_zod5.z.string().optional()
+var requesterInfoSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  role: import_zod6.z.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: import_zod6.z.string().optional(),
+  associatedPractitionerId: import_zod6.z.string().optional()
 }).refine(
   (data) => {
     if (data.role === "clinic_admin") {
@@ -1243,7 +1351,7 @@ var import_firestore4 = require("firebase/firestore");
 
 // src/services/patient/utils/sensitive.utils.ts
 var import_firestore3 = require("firebase/firestore");
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
   try {
     if (data.userRef !== requesterUserId) {
@@ -1268,7 +1376,7 @@ var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
     }
     return createdDoc.data();
   } catch (error) {
-    if (error instanceof import_zod6.z.ZodError) {
+    if (error instanceof import_zod7.z.ZodError) {
       throw new Error("Invalid sensitive info data: " + error.message);
     }
     throw error;
@@ -1501,9 +1609,9 @@ var addAllergyUtil = async (db, patientId, data, userRef) => {
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1519,9 +1627,9 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }
@@ -1546,9 +1654,9 @@ var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1564,9 +1672,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
     throw new Error("Invalid blocking condition index");
   }
@@ -1591,9 +1699,9 @@ var addContraindicationUtil = async (db, patientId, data, userRef) => {
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1609,9 +1717,9 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
     throw new Error("Invalid contraindication index");
   }
@@ -1636,9 +1744,9 @@ var addMedicationUtil = async (db, patientId, data, userRef) => {
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -1654,9 +1762,9 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc29 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await (0, import_firestore5.getDoc)(getMedicalInfoDocRef(db, patientId));
+  if (!doc30.exists()) throw new Error("Medical info not found");
+  const medicalInfo = doc30.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
     throw new Error("Invalid medication index");
   }
@@ -1746,7 +1854,7 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
     return patientDoc.data();
   } catch (error) {
     console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
-    if (error instanceof import_zod7.z.ZodError) {
+    if (error instanceof import_zod8.z.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
@@ -1934,7 +2042,7 @@ var searchPatientsUtil = async (db, params, requester) => {
   try {
     const finalQuery = (0, import_firestore6.query)(patientsCollectionRef, ...constraints);
     const querySnapshot = await (0, import_firestore6.getDocs)(finalQuery);
-    const patients = querySnapshot.docs.map((doc29) => doc29.data());
+    const patients = querySnapshot.docs.map((doc30) => doc30.data());
     console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
     return patients;
   } catch (error) {
@@ -1958,8 +2066,8 @@ var getAllPatientsUtil = async (db, options) => {
     }
     const patientsSnapshot = await (0, import_firestore6.getDocs)(q);
     const patients = [];
-    patientsSnapshot.forEach((doc29) => {
-      patients.push(doc29.data());
+    patientsSnapshot.forEach((doc30) => {
+      patients.push(doc30.data());
     });
     console.log(`[getAllPatientsUtil] Found ${patients.length} patients`);
     return patients;
@@ -1973,7 +2081,7 @@ var getAllPatientsUtil = async (db, options) => {
 
 // src/services/patient/utils/location.utils.ts
 var import_firestore7 = require("firebase/firestore");
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_geofire_common = require("geofire-common");
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -2012,7 +2120,7 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof import_zod8.z.ZodError) {
+    if (error instanceof import_zod9.z.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -2506,11 +2614,11 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 })(SubscriptionModel || {});
 
 // src/validations/clinic.schema.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var import_firestore11 = require("firebase/firestore");
 
 // src/validations/practitioner.schema.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var import_firestore10 = require("firebase/firestore");
 
 // src/backoffice/types/static/certification.types.ts
@@ -2554,128 +2662,128 @@ var PractitionerTokenStatus = /* @__PURE__ */ ((PractitionerTokenStatus2) => {
 })(PractitionerTokenStatus || {});
 
 // src/validations/reviews.schema.ts
-var import_zod9 = require("zod");
-var baseReviewSchema = import_zod9.z.object({
-  id: import_zod9.z.string().min(1),
-  patientId: import_zod9.z.string().min(1),
-  fullReviewId: import_zod9.z.string().min(1),
-  createdAt: import_zod9.z.date(),
-  updatedAt: import_zod9.z.date(),
-  comment: import_zod9.z.string().min(1).max(2e3),
-  isVerified: import_zod9.z.boolean(),
-  isPublished: import_zod9.z.boolean()
+var import_zod10 = require("zod");
+var baseReviewSchema = import_zod10.z.object({
+  id: import_zod10.z.string().min(1),
+  patientId: import_zod10.z.string().min(1),
+  fullReviewId: import_zod10.z.string().min(1),
+  createdAt: import_zod10.z.date(),
+  updatedAt: import_zod10.z.date(),
+  comment: import_zod10.z.string().min(1).max(2e3),
+  isVerified: import_zod10.z.boolean(),
+  isPublished: import_zod10.z.boolean()
 });
-var baseReviewCreateSchema = import_zod9.z.object({
-  patientId: import_zod9.z.string().min(1),
-  comment: import_zod9.z.string().min(1).max(2e3),
-  isVerified: import_zod9.z.boolean().default(false),
-  isPublished: import_zod9.z.boolean().default(true)
+var baseReviewCreateSchema = import_zod10.z.object({
+  patientId: import_zod10.z.string().min(1),
+  comment: import_zod10.z.string().min(1).max(2e3),
+  isVerified: import_zod10.z.boolean().default(false),
+  isPublished: import_zod10.z.boolean().default(true)
 });
 var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: import_zod9.z.string().min(1),
-  cleanliness: import_zod9.z.number().min(1).max(5),
-  facilities: import_zod9.z.number().min(1).max(5),
-  staffFriendliness: import_zod9.z.number().min(1).max(5),
-  waitingTime: import_zod9.z.number().min(1).max(5),
-  accessibility: import_zod9.z.number().min(1).max(5),
-  overallRating: import_zod9.z.number().min(1).max(5),
-  wouldRecommend: import_zod9.z.boolean()
+  clinicId: import_zod10.z.string().min(1),
+  cleanliness: import_zod10.z.number().min(1).max(5),
+  facilities: import_zod10.z.number().min(1).max(5),
+  staffFriendliness: import_zod10.z.number().min(1).max(5),
+  waitingTime: import_zod10.z.number().min(1).max(5),
+  accessibility: import_zod10.z.number().min(1).max(5),
+  overallRating: import_zod10.z.number().min(1).max(5),
+  wouldRecommend: import_zod10.z.boolean()
 });
 var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: import_zod9.z.string().min(1),
-  cleanliness: import_zod9.z.number().min(1).max(5),
-  facilities: import_zod9.z.number().min(1).max(5),
-  staffFriendliness: import_zod9.z.number().min(1).max(5),
-  waitingTime: import_zod9.z.number().min(1).max(5),
-  accessibility: import_zod9.z.number().min(1).max(5),
-  wouldRecommend: import_zod9.z.boolean()
+  clinicId: import_zod10.z.string().min(1),
+  cleanliness: import_zod10.z.number().min(1).max(5),
+  facilities: import_zod10.z.number().min(1).max(5),
+  staffFriendliness: import_zod10.z.number().min(1).max(5),
+  waitingTime: import_zod10.z.number().min(1).max(5),
+  accessibility: import_zod10.z.number().min(1).max(5),
+  wouldRecommend: import_zod10.z.boolean()
 });
 var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: import_zod9.z.string().min(1),
-  knowledgeAndExpertise: import_zod9.z.number().min(1).max(5),
-  communicationSkills: import_zod9.z.number().min(1).max(5),
-  bedSideManner: import_zod9.z.number().min(1).max(5),
-  thoroughness: import_zod9.z.number().min(1).max(5),
-  trustworthiness: import_zod9.z.number().min(1).max(5),
-  overallRating: import_zod9.z.number().min(1).max(5),
-  wouldRecommend: import_zod9.z.boolean()
+  practitionerId: import_zod10.z.string().min(1),
+  knowledgeAndExpertise: import_zod10.z.number().min(1).max(5),
+  communicationSkills: import_zod10.z.number().min(1).max(5),
+  bedSideManner: import_zod10.z.number().min(1).max(5),
+  thoroughness: import_zod10.z.number().min(1).max(5),
+  trustworthiness: import_zod10.z.number().min(1).max(5),
+  overallRating: import_zod10.z.number().min(1).max(5),
+  wouldRecommend: import_zod10.z.boolean()
 });
 var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: import_zod9.z.string().min(1),
-  knowledgeAndExpertise: import_zod9.z.number().min(1).max(5),
-  communicationSkills: import_zod9.z.number().min(1).max(5),
-  bedSideManner: import_zod9.z.number().min(1).max(5),
-  thoroughness: import_zod9.z.number().min(1).max(5),
-  trustworthiness: import_zod9.z.number().min(1).max(5),
-  wouldRecommend: import_zod9.z.boolean()
+  practitionerId: import_zod10.z.string().min(1),
+  knowledgeAndExpertise: import_zod10.z.number().min(1).max(5),
+  communicationSkills: import_zod10.z.number().min(1).max(5),
+  bedSideManner: import_zod10.z.number().min(1).max(5),
+  thoroughness: import_zod10.z.number().min(1).max(5),
+  trustworthiness: import_zod10.z.number().min(1).max(5),
+  wouldRecommend: import_zod10.z.boolean()
 });
 var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: import_zod9.z.string().min(1),
-  effectivenessOfTreatment: import_zod9.z.number().min(1).max(5),
-  outcomeExplanation: import_zod9.z.number().min(1).max(5),
-  painManagement: import_zod9.z.number().min(1).max(5),
-  followUpCare: import_zod9.z.number().min(1).max(5),
-  valueForMoney: import_zod9.z.number().min(1).max(5),
-  overallRating: import_zod9.z.number().min(1).max(5),
-  wouldRecommend: import_zod9.z.boolean()
+  procedureId: import_zod10.z.string().min(1),
+  effectivenessOfTreatment: import_zod10.z.number().min(1).max(5),
+  outcomeExplanation: import_zod10.z.number().min(1).max(5),
+  painManagement: import_zod10.z.number().min(1).max(5),
+  followUpCare: import_zod10.z.number().min(1).max(5),
+  valueForMoney: import_zod10.z.number().min(1).max(5),
+  overallRating: import_zod10.z.number().min(1).max(5),
+  wouldRecommend: import_zod10.z.boolean()
 });
 var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: import_zod9.z.string().min(1),
-  effectivenessOfTreatment: import_zod9.z.number().min(1).max(5),
-  outcomeExplanation: import_zod9.z.number().min(1).max(5),
-  painManagement: import_zod9.z.number().min(1).max(5),
-  followUpCare: import_zod9.z.number().min(1).max(5),
-  valueForMoney: import_zod9.z.number().min(1).max(5),
-  wouldRecommend: import_zod9.z.boolean()
+  procedureId: import_zod10.z.string().min(1),
+  effectivenessOfTreatment: import_zod10.z.number().min(1).max(5),
+  outcomeExplanation: import_zod10.z.number().min(1).max(5),
+  painManagement: import_zod10.z.number().min(1).max(5),
+  followUpCare: import_zod10.z.number().min(1).max(5),
+  valueForMoney: import_zod10.z.number().min(1).max(5),
+  wouldRecommend: import_zod10.z.boolean()
 });
-var clinicReviewInfoSchema = import_zod9.z.object({
-  totalReviews: import_zod9.z.number().min(0),
-  averageRating: import_zod9.z.number().min(0).max(5),
-  cleanliness: import_zod9.z.number().min(0).max(5),
-  facilities: import_zod9.z.number().min(0).max(5),
-  staffFriendliness: import_zod9.z.number().min(0).max(5),
-  waitingTime: import_zod9.z.number().min(0).max(5),
-  accessibility: import_zod9.z.number().min(0).max(5),
-  recommendationPercentage: import_zod9.z.number().min(0).max(100)
+var clinicReviewInfoSchema = import_zod10.z.object({
+  totalReviews: import_zod10.z.number().min(0),
+  averageRating: import_zod10.z.number().min(0).max(5),
+  cleanliness: import_zod10.z.number().min(0).max(5),
+  facilities: import_zod10.z.number().min(0).max(5),
+  staffFriendliness: import_zod10.z.number().min(0).max(5),
+  waitingTime: import_zod10.z.number().min(0).max(5),
+  accessibility: import_zod10.z.number().min(0).max(5),
+  recommendationPercentage: import_zod10.z.number().min(0).max(100)
 });
-var practitionerReviewInfoSchema = import_zod9.z.object({
-  totalReviews: import_zod9.z.number().min(0),
-  averageRating: import_zod9.z.number().min(0).max(5),
-  knowledgeAndExpertise: import_zod9.z.number().min(0).max(5),
-  communicationSkills: import_zod9.z.number().min(0).max(5),
-  bedSideManner: import_zod9.z.number().min(0).max(5),
-  thoroughness: import_zod9.z.number().min(0).max(5),
-  trustworthiness: import_zod9.z.number().min(0).max(5),
-  recommendationPercentage: import_zod9.z.number().min(0).max(100)
+var practitionerReviewInfoSchema = import_zod10.z.object({
+  totalReviews: import_zod10.z.number().min(0),
+  averageRating: import_zod10.z.number().min(0).max(5),
+  knowledgeAndExpertise: import_zod10.z.number().min(0).max(5),
+  communicationSkills: import_zod10.z.number().min(0).max(5),
+  bedSideManner: import_zod10.z.number().min(0).max(5),
+  thoroughness: import_zod10.z.number().min(0).max(5),
+  trustworthiness: import_zod10.z.number().min(0).max(5),
+  recommendationPercentage: import_zod10.z.number().min(0).max(100)
 });
-var procedureReviewInfoSchema = import_zod9.z.object({
-  totalReviews: import_zod9.z.number().min(0),
-  averageRating: import_zod9.z.number().min(0).max(5),
-  effectivenessOfTreatment: import_zod9.z.number().min(0).max(5),
-  outcomeExplanation: import_zod9.z.number().min(0).max(5),
-  painManagement: import_zod9.z.number().min(0).max(5),
-  followUpCare: import_zod9.z.number().min(0).max(5),
-  valueForMoney: import_zod9.z.number().min(0).max(5),
-  recommendationPercentage: import_zod9.z.number().min(0).max(100)
+var procedureReviewInfoSchema = import_zod10.z.object({
+  totalReviews: import_zod10.z.number().min(0),
+  averageRating: import_zod10.z.number().min(0).max(5),
+  effectivenessOfTreatment: import_zod10.z.number().min(0).max(5),
+  outcomeExplanation: import_zod10.z.number().min(0).max(5),
+  painManagement: import_zod10.z.number().min(0).max(5),
+  followUpCare: import_zod10.z.number().min(0).max(5),
+  valueForMoney: import_zod10.z.number().min(0).max(5),
+  recommendationPercentage: import_zod10.z.number().min(0).max(100)
 });
-var reviewSchema = import_zod9.z.object({
-  id: import_zod9.z.string().min(1),
-  appointmentId: import_zod9.z.string().min(1),
-  patientId: import_zod9.z.string().min(1),
-  createdAt: import_zod9.z.date(),
-  updatedAt: import_zod9.z.date(),
+var reviewSchema = import_zod10.z.object({
+  id: import_zod10.z.string().min(1),
+  appointmentId: import_zod10.z.string().min(1),
+  patientId: import_zod10.z.string().min(1),
+  createdAt: import_zod10.z.date(),
+  updatedAt: import_zod10.z.date(),
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
-  overallComment: import_zod9.z.string().min(1).max(2e3),
-  overallRating: import_zod9.z.number().min(1).max(5)
+  overallComment: import_zod10.z.string().min(1).max(2e3),
+  overallRating: import_zod10.z.number().min(1).max(5)
 });
-var createReviewSchema = import_zod9.z.object({
-  patientId: import_zod9.z.string().min(1),
+var createReviewSchema = import_zod10.z.object({
+  patientId: import_zod10.z.string().min(1),
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: import_zod9.z.string().min(1).max(2e3)
+  overallComment: import_zod10.z.string().min(1).max(2e3)
 }).refine(
   (data) => {
     return data.clinicReview || data.practitionerReview || data.procedureReview;
@@ -2713,34 +2821,34 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
 })(Currency || {});
 
 // src/validations/practitioner.schema.ts
-var practitionerBasicInfoSchema = import_zod10.z.object({
-  firstName: import_zod10.z.string().min(2).max(50),
-  lastName: import_zod10.z.string().min(2).max(50),
-  title: import_zod10.z.string().min(2).max(100),
-  email: import_zod10.z.string().email(),
-  phoneNumber: import_zod10.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  gender: import_zod10.z.enum(["male", "female", "other"]),
-  profileImageUrl: import_zod10.z.string().url().optional(),
-  bio: import_zod10.z.string().max(1e3).optional(),
-  languages: import_zod10.z.array(import_zod10.z.string()).min(1)
+var practitionerBasicInfoSchema = import_zod11.z.object({
+  firstName: import_zod11.z.string().min(2).max(50),
+  lastName: import_zod11.z.string().min(2).max(50),
+  title: import_zod11.z.string().min(2).max(100),
+  email: import_zod11.z.string().email(),
+  phoneNumber: import_zod11.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
+  dateOfBirth: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  gender: import_zod11.z.enum(["male", "female", "other"]),
+  profileImageUrl: import_zod11.z.string().url().optional(),
+  bio: import_zod11.z.string().max(1e3).optional(),
+  languages: import_zod11.z.array(import_zod11.z.string()).min(1)
 });
-var practitionerCertificationSchema = import_zod10.z.object({
-  level: import_zod10.z.nativeEnum(CertificationLevel),
-  specialties: import_zod10.z.array(import_zod10.z.nativeEnum(CertificationSpecialty)),
-  licenseNumber: import_zod10.z.string().min(3).max(50),
-  issuingAuthority: import_zod10.z.string().min(2).max(100),
-  issueDate: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  expiryDate: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()).optional(),
-  verificationStatus: import_zod10.z.enum(["pending", "verified", "rejected"])
+var practitionerCertificationSchema = import_zod11.z.object({
+  level: import_zod11.z.nativeEnum(CertificationLevel),
+  specialties: import_zod11.z.array(import_zod11.z.nativeEnum(CertificationSpecialty)),
+  licenseNumber: import_zod11.z.string().min(3).max(50),
+  issuingAuthority: import_zod11.z.string().min(2).max(100),
+  issueDate: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  expiryDate: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()).optional(),
+  verificationStatus: import_zod11.z.enum(["pending", "verified", "rejected"])
 });
-var timeSlotSchema = import_zod10.z.object({
-  start: import_zod10.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
-  end: import_zod10.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
+var timeSlotSchema = import_zod11.z.object({
+  start: import_zod11.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: import_zod11.z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
 }).nullable();
-var practitionerWorkingHoursSchema = import_zod10.z.object({
-  practitionerId: import_zod10.z.string().min(1),
-  clinicId: import_zod10.z.string().min(1),
+var practitionerWorkingHoursSchema = import_zod11.z.object({
+  practitionerId: import_zod11.z.string().min(1),
+  clinicId: import_zod11.z.string().min(1),
   monday: timeSlotSchema,
   tuesday: timeSlotSchema,
   wednesday: timeSlotSchema,
@@ -2748,12 +2856,12 @@ var practitionerWorkingHoursSchema = import_zod10.z.object({
   friday: timeSlotSchema,
   saturday: timeSlotSchema,
   sunday: timeSlotSchema,
-  createdAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  updatedAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date())
+  createdAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  updatedAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date())
 });
-var practitionerClinicWorkingHoursSchema = import_zod10.z.object({
-  clinicId: import_zod10.z.string().min(1),
-  workingHours: import_zod10.z.object({
+var practitionerClinicWorkingHoursSchema = import_zod11.z.object({
+  clinicId: import_zod11.z.string().min(1),
+  workingHours: import_zod11.z.object({
     monday: timeSlotSchema,
     tuesday: timeSlotSchema,
     wednesday: timeSlotSchema,
@@ -2762,114 +2870,114 @@ var practitionerClinicWorkingHoursSchema = import_zod10.z.object({
     saturday: timeSlotSchema,
     sunday: timeSlotSchema
   }),
-  isActive: import_zod10.z.boolean(),
-  createdAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  updatedAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date())
+  isActive: import_zod11.z.boolean(),
+  createdAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  updatedAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date())
 });
-var procedureSummaryInfoSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  name: import_zod10.z.string().min(1),
-  description: import_zod10.z.string().optional(),
-  photo: import_zod10.z.string().optional(),
-  family: import_zod10.z.nativeEnum(ProcedureFamily),
-  categoryName: import_zod10.z.string(),
-  subcategoryName: import_zod10.z.string(),
-  technologyName: import_zod10.z.string(),
-  price: import_zod10.z.number().nonnegative(),
-  pricingMeasure: import_zod10.z.nativeEnum(PricingMeasure),
-  currency: import_zod10.z.nativeEnum(Currency),
-  duration: import_zod10.z.number().int().positive(),
-  clinicId: import_zod10.z.string().min(1),
-  clinicName: import_zod10.z.string().min(1),
-  practitionerId: import_zod10.z.string().min(1),
-  practitionerName: import_zod10.z.string().min(1)
+var procedureSummaryInfoSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  name: import_zod11.z.string().min(1),
+  description: import_zod11.z.string().optional(),
+  photo: import_zod11.z.string().optional(),
+  family: import_zod11.z.nativeEnum(ProcedureFamily),
+  categoryName: import_zod11.z.string(),
+  subcategoryName: import_zod11.z.string(),
+  technologyName: import_zod11.z.string(),
+  price: import_zod11.z.number().nonnegative(),
+  pricingMeasure: import_zod11.z.nativeEnum(PricingMeasure),
+  currency: import_zod11.z.nativeEnum(Currency),
+  duration: import_zod11.z.number().int().positive(),
+  clinicId: import_zod11.z.string().min(1),
+  clinicName: import_zod11.z.string().min(1),
+  practitionerId: import_zod11.z.string().min(1),
+  practitionerName: import_zod11.z.string().min(1)
 });
-var practitionerSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  userRef: import_zod10.z.string().min(1),
+var practitionerSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  userRef: import_zod11.z.string().min(1),
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
-  clinics: import_zod10.z.array(import_zod10.z.string()),
-  clinicWorkingHours: import_zod10.z.array(practitionerClinicWorkingHoursSchema),
-  clinicsInfo: import_zod10.z.array(clinicInfoSchema),
-  procedures: import_zod10.z.array(import_zod10.z.string()),
-  proceduresInfo: import_zod10.z.array(procedureSummaryInfoSchema),
+  clinics: import_zod11.z.array(import_zod11.z.string()),
+  clinicWorkingHours: import_zod11.z.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: import_zod11.z.array(clinicInfoSchema),
+  procedures: import_zod11.z.array(import_zod11.z.string()),
+  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema),
   reviewInfo: practitionerReviewInfoSchema,
-  isActive: import_zod10.z.boolean(),
-  isVerified: import_zod10.z.boolean(),
-  status: import_zod10.z.nativeEnum(PractitionerStatus),
-  createdAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  updatedAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date())
+  isActive: import_zod11.z.boolean(),
+  isVerified: import_zod11.z.boolean(),
+  status: import_zod11.z.nativeEnum(PractitionerStatus),
+  createdAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  updatedAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date())
 });
-var createPractitionerSchema = import_zod10.z.object({
-  userRef: import_zod10.z.string().min(1),
+var createPractitionerSchema = import_zod11.z.object({
+  userRef: import_zod11.z.string().min(1),
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
-  clinics: import_zod10.z.array(import_zod10.z.string()).optional(),
-  clinicWorkingHours: import_zod10.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod10.z.array(clinicInfoSchema).optional(),
-  proceduresInfo: import_zod10.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod10.z.boolean(),
-  isVerified: import_zod10.z.boolean(),
-  status: import_zod10.z.nativeEnum(PractitionerStatus).optional()
+  clinics: import_zod11.z.array(import_zod11.z.string()).optional(),
+  clinicWorkingHours: import_zod11.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod11.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod11.z.boolean(),
+  isVerified: import_zod11.z.boolean(),
+  status: import_zod11.z.nativeEnum(PractitionerStatus).optional()
 });
-var createDraftPractitionerSchema = import_zod10.z.object({
+var createDraftPractitionerSchema = import_zod11.z.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
-  clinics: import_zod10.z.array(import_zod10.z.string()).optional(),
-  clinicWorkingHours: import_zod10.z.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: import_zod10.z.array(clinicInfoSchema).optional(),
-  proceduresInfo: import_zod10.z.array(procedureSummaryInfoSchema).optional(),
-  isActive: import_zod10.z.boolean().optional().default(false),
-  isVerified: import_zod10.z.boolean().optional().default(false)
+  clinics: import_zod11.z.array(import_zod11.z.string()).optional(),
+  clinicWorkingHours: import_zod11.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: import_zod11.z.array(clinicInfoSchema).optional(),
+  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema).optional(),
+  isActive: import_zod11.z.boolean().optional().default(false),
+  isVerified: import_zod11.z.boolean().optional().default(false)
 });
-var practitionerTokenSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  token: import_zod10.z.string().min(6),
-  practitionerId: import_zod10.z.string().min(1),
-  email: import_zod10.z.string().email(),
-  clinicId: import_zod10.z.string().min(1),
-  status: import_zod10.z.nativeEnum(PractitionerTokenStatus),
-  createdBy: import_zod10.z.string().min(1),
-  createdAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  expiresAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()),
-  usedBy: import_zod10.z.string().optional(),
-  usedAt: import_zod10.z.instanceof(import_firestore10.Timestamp).or(import_zod10.z.date()).optional()
+var practitionerTokenSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  token: import_zod11.z.string().min(6),
+  practitionerId: import_zod11.z.string().min(1),
+  email: import_zod11.z.string().email(),
+  clinicId: import_zod11.z.string().min(1),
+  status: import_zod11.z.nativeEnum(PractitionerTokenStatus),
+  createdBy: import_zod11.z.string().min(1),
+  createdAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  expiresAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()),
+  usedBy: import_zod11.z.string().optional(),
+  usedAt: import_zod11.z.instanceof(import_firestore10.Timestamp).or(import_zod11.z.date()).optional()
 });
-var createPractitionerTokenSchema = import_zod10.z.object({
-  practitionerId: import_zod10.z.string().min(1),
-  email: import_zod10.z.string().email(),
-  clinicId: import_zod10.z.string().min(1),
-  expiresAt: import_zod10.z.date().optional()
+var createPractitionerTokenSchema = import_zod11.z.object({
+  practitionerId: import_zod11.z.string().min(1),
+  email: import_zod11.z.string().email(),
+  clinicId: import_zod11.z.string().min(1),
+  expiresAt: import_zod11.z.date().optional()
 });
 
 // src/validations/clinic.schema.ts
-var clinicContactInfoSchema = import_zod11.z.object({
-  email: import_zod11.z.string().email(),
-  phoneNumber: import_zod11.z.string(),
-  alternativePhoneNumber: import_zod11.z.string().nullable().optional(),
-  website: import_zod11.z.string().nullable().optional()
+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()
 });
-var clinicLocationSchema = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  city: import_zod11.z.string(),
-  country: import_zod11.z.string(),
-  postalCode: import_zod11.z.string(),
-  latitude: import_zod11.z.number().min(-90).max(90),
-  longitude: import_zod11.z.number().min(-180).max(180),
-  geohash: import_zod11.z.string().nullable().optional()
+var 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 workingHoursTimeSchema = import_zod11.z.object({
-  open: import_zod11.z.string(),
-  close: import_zod11.z.string(),
-  breaks: import_zod11.z.array(
-    import_zod11.z.object({
-      start: import_zod11.z.string(),
-      end: import_zod11.z.string()
+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()
     })
   ).optional()
 });
-var workingHoursSchema = import_zod11.z.object({
+var workingHoursSchema = import_zod12.z.object({
   monday: workingHoursTimeSchema.nullable(),
   tuesday: workingHoursTimeSchema.nullable(),
   wednesday: workingHoursTimeSchema.nullable(),
@@ -2878,235 +2986,235 @@ var workingHoursSchema = import_zod11.z.object({
   saturday: workingHoursTimeSchema.nullable(),
   sunday: workingHoursTimeSchema.nullable()
 });
-var clinicTagsSchema = import_zod11.z.object({
-  tags: import_zod11.z.array(import_zod11.z.nativeEnum(ClinicTag))
+var clinicTagsSchema = import_zod12.z.object({
+  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag))
 });
-var contactPersonSchema = import_zod11.z.object({
-  firstName: import_zod11.z.string(),
-  lastName: import_zod11.z.string(),
-  title: import_zod11.z.string().nullable().optional(),
-  email: import_zod11.z.string().email(),
-  phoneNumber: import_zod11.z.string().nullable().optional()
+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 adminInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  email: import_zod11.z.string().email()
+var adminInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  email: import_zod12.z.string().email()
 });
-var clinicInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  featuredPhoto: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
+var clinicInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  featuredPhoto: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var doctorInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
-  photo: import_zod11.z.string(),
-  rating: import_zod11.z.number().min(0).max(5),
-  services: import_zod11.z.array(import_zod11.z.string())
+var doctorInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
+  photo: import_zod12.z.string(),
+  rating: import_zod12.z.number().min(0).max(5),
+  services: import_zod12.z.array(import_zod12.z.string())
   // List of procedure IDs practitioner offers
 });
-var clinicAdminSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  userRef: import_zod11.z.string(),
-  clinicGroupId: import_zod11.z.string(),
-  isGroupOwner: import_zod11.z.boolean(),
-  clinicsManaged: import_zod11.z.array(import_zod11.z.string()),
-  clinicsManagedInfo: import_zod11.z.array(clinicInfoSchema),
+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),
   contactInfo: contactPersonSchema,
-  roleTitle: import_zod11.z.string(),
-  createdAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
-  updatedAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
-  isActive: import_zod11.z.boolean()
+  roleTitle: import_zod12.z.string(),
+  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore11.Timestamp)),
+  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore11.Timestamp)),
+  isActive: import_zod12.z.boolean()
 });
-var adminTokenSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  token: import_zod11.z.string(),
-  email: import_zod11.z.string().email().optional().nullable(),
-  status: import_zod11.z.nativeEnum(AdminTokenStatus),
-  usedByUserRef: import_zod11.z.string().optional(),
-  createdAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
+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_firestore11.Timestamp)),
   // Timestamp
-  expiresAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp))
+  expiresAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore11.Timestamp))
   // Timestamp
 });
-var createAdminTokenSchema = import_zod11.z.object({
-  expiresInDays: import_zod11.z.number().min(1).max(30).optional(),
-  email: import_zod11.z.string().email().optional().nullable()
+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 clinicGroupSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
+var clinicGroupSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  clinics: import_zod11.z.array(import_zod11.z.string()),
-  clinicsInfo: import_zod11.z.array(clinicInfoSchema),
-  admins: import_zod11.z.array(import_zod11.z.string()),
-  adminsInfo: import_zod11.z.array(adminInfoSchema),
-  adminTokens: import_zod11.z.array(adminTokenSchema),
-  ownerId: import_zod11.z.string().nullable(),
-  createdAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
+  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_firestore11.Timestamp)),
   // Timestamp
-  updatedAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
+  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore11.Timestamp)),
   // Timestamp
-  isActive: import_zod11.z.boolean(),
-  logo: import_zod11.z.string().optional().nullable(),
-  practiceType: import_zod11.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod11.z.array(import_zod11.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod11.z.nativeEnum(SubscriptionModel),
-  calendarSyncEnabled: import_zod11.z.boolean().optional(),
-  autoConfirmAppointments: import_zod11.z.boolean().optional(),
-  businessIdentificationNumber: import_zod11.z.string().optional().nullable()
+  isActive: import_zod12.z.boolean(),
+  logo: import_zod12.z.string().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()
 });
-var clinicSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  clinicGroupId: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().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(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod11.z.array(import_zod11.z.nativeEnum(ClinicTag)),
-  featuredPhotos: import_zod11.z.array(import_zod11.z.string()),
-  coverPhoto: import_zod11.z.string().nullable(),
-  photosWithTags: import_zod11.z.array(
-    import_zod11.z.object({
-      url: import_zod11.z.string(),
-      tag: import_zod11.z.string()
+  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)),
+  featuredPhotos: import_zod12.z.array(import_zod12.z.string()),
+  coverPhoto: import_zod12.z.string().nullable(),
+  photosWithTags: import_zod12.z.array(
+    import_zod12.z.object({
+      url: import_zod12.z.string(),
+      tag: import_zod12.z.string()
     })
   ).optional(),
-  doctors: import_zod11.z.array(import_zod11.z.string()),
+  doctors: import_zod12.z.array(import_zod12.z.string()),
   // List of practitioner IDs
-  doctorsInfo: import_zod11.z.array(doctorInfoSchema),
+  doctorsInfo: import_zod12.z.array(doctorInfoSchema),
   // Aggregated doctor info
-  procedures: import_zod11.z.array(import_zod11.z.string()),
+  procedures: import_zod12.z.array(import_zod12.z.string()),
   // List of procedure IDs offered by clinic
-  proceduresInfo: import_zod11.z.array(procedureSummaryInfoSchema),
+  proceduresInfo: import_zod12.z.array(procedureSummaryInfoSchema),
   // Use the correct schema for aggregated procedure info
   // services: z.array(z.string()), // Likely deprecated, procedures covers this
   // servicesInfo: z.array(serviceInfoSchema), // Deprecated, use proceduresInfo
   reviewInfo: clinicReviewInfoSchema,
-  admins: import_zod11.z.array(import_zod11.z.string()),
-  createdAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
+  admins: import_zod12.z.array(import_zod12.z.string()),
+  createdAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore11.Timestamp)),
   // Timestamp
-  updatedAt: import_zod11.z.instanceof(Date).or(import_zod11.z.instanceof(import_firestore11.Timestamp)),
+  updatedAt: import_zod12.z.instanceof(Date).or(import_zod12.z.instanceof(import_firestore11.Timestamp)),
   // Timestamp
-  isActive: import_zod11.z.boolean(),
-  isVerified: import_zod11.z.boolean(),
-  logo: import_zod11.z.string().optional()
+  isActive: import_zod12.z.boolean(),
+  isVerified: import_zod12.z.boolean(),
+  logo: import_zod12.z.string().optional()
 });
-var createClinicAdminSchema = import_zod11.z.object({
-  userRef: import_zod11.z.string(),
-  clinicGroupId: import_zod11.z.string().optional(),
-  isGroupOwner: import_zod11.z.boolean(),
-  clinicsManaged: import_zod11.z.array(import_zod11.z.string()),
+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()),
   contactInfo: contactPersonSchema,
-  roleTitle: import_zod11.z.string(),
-  isActive: import_zod11.z.boolean()
+  roleTitle: import_zod12.z.string(),
+  isActive: import_zod12.z.boolean()
   // clinicsManagedInfo is aggregated, not provided on creation
 });
-var createClinicGroupSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().optional(),
+var createClinicGroupSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  ownerId: import_zod11.z.string().nullable(),
-  isActive: import_zod11.z.boolean(),
-  logo: import_zod11.z.string().optional().nullable(),
-  practiceType: import_zod11.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod11.z.array(import_zod11.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod11.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
-  calendarSyncEnabled: import_zod11.z.boolean().optional(),
-  autoConfirmAppointments: import_zod11.z.boolean().optional(),
-  businessIdentificationNumber: import_zod11.z.string().optional().nullable()
+  ownerId: import_zod12.z.string().nullable(),
+  isActive: import_zod12.z.boolean(),
+  logo: import_zod12.z.string().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()
   // clinics, clinicsInfo, admins, adminsInfo, adminTokens are managed internally
 });
-var createClinicSchema = import_zod11.z.object({
-  clinicGroupId: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().optional(),
+var createClinicSchema = import_zod12.z.object({
+  clinicGroupId: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod11.z.array(import_zod11.z.nativeEnum(ClinicTag)),
-  coverPhoto: import_zod11.z.string().nullable(),
-  photosWithTags: import_zod11.z.array(
-    import_zod11.z.object({
-      url: import_zod11.z.string(),
-      tag: import_zod11.z.string()
+  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)),
+  coverPhoto: import_zod12.z.string().nullable(),
+  photosWithTags: import_zod12.z.array(
+    import_zod12.z.object({
+      url: import_zod12.z.string(),
+      tag: import_zod12.z.string()
     })
   ).optional(),
   // doctors, doctorsInfo, procedures, proceduresInfo are managed internally/aggregated
   // doctors: z.array(z.string()),
   // services: z.array(z.string()), // Deprecated
-  admins: import_zod11.z.array(import_zod11.z.string()),
+  admins: import_zod12.z.array(import_zod12.z.string()),
   // Should likely just be creator ID initially
-  isActive: import_zod11.z.boolean(),
-  isVerified: import_zod11.z.boolean(),
-  logo: import_zod11.z.string().optional(),
-  featuredPhotos: import_zod11.z.array(import_zod11.z.string()).optional()
+  isActive: import_zod12.z.boolean(),
+  isVerified: import_zod12.z.boolean(),
+  logo: import_zod12.z.string().optional(),
+  featuredPhotos: import_zod12.z.array(import_zod12.z.string()).optional()
 });
-var createDefaultClinicGroupSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  ownerId: import_zod11.z.string().nullable(),
+var createDefaultClinicGroupSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  ownerId: import_zod12.z.string().nullable(),
   contactPerson: contactPersonSchema,
   contactInfo: clinicContactInfoSchema,
   hqLocation: clinicLocationSchema,
-  isActive: import_zod11.z.boolean(),
-  logo: import_zod11.z.string().optional().nullable(),
-  practiceType: import_zod11.z.nativeEnum(PracticeType).optional(),
-  languages: import_zod11.z.array(import_zod11.z.nativeEnum(Language)).optional(),
-  subscriptionModel: import_zod11.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+  isActive: import_zod12.z.boolean(),
+  logo: import_zod12.z.string().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 */)
 });
-var clinicAdminSignupSchema = import_zod11.z.object({
-  email: import_zod11.z.string().email(),
-  password: import_zod11.z.string().min(8),
-  firstName: import_zod11.z.string(),
-  lastName: import_zod11.z.string(),
-  title: import_zod11.z.string(),
-  phoneNumber: import_zod11.z.string(),
-  isCreatingNewGroup: import_zod11.z.boolean(),
-  inviteToken: import_zod11.z.string().optional(),
-  clinicGroupData: import_zod11.z.object({
-    name: import_zod11.z.string(),
+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(),
     hqLocation: clinicLocationSchema,
-    logo: import_zod11.z.string().optional(),
+    logo: import_zod12.z.string().optional(),
     contactInfo: clinicContactInfoSchema,
-    subscriptionModel: import_zod11.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+    subscriptionModel: import_zod12.z.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
   }).optional()
 });
-var clinicGroupSetupSchema = import_zod11.z.object({
-  languages: import_zod11.z.array(import_zod11.z.nativeEnum(Language)),
-  practiceType: import_zod11.z.nativeEnum(PracticeType),
-  description: import_zod11.z.string(),
-  logo: import_zod11.z.string(),
-  calendarSyncEnabled: import_zod11.z.boolean(),
-  autoConfirmAppointments: import_zod11.z.boolean(),
-  businessIdentificationNumber: import_zod11.z.string().optional().nullable()
+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(),
+  logo: import_zod12.z.string(),
+  calendarSyncEnabled: import_zod12.z.boolean(),
+  autoConfirmAppointments: import_zod12.z.boolean(),
+  businessIdentificationNumber: import_zod12.z.string().optional().nullable()
 });
-var clinicBranchSetupSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
+var clinicBranchSetupSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
   location: clinicLocationSchema,
-  description: import_zod11.z.string().optional(),
+  description: import_zod12.z.string().optional(),
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: import_zod11.z.array(import_zod11.z.nativeEnum(ClinicTag)),
-  logo: import_zod11.z.string().optional(),
-  coverPhoto: import_zod11.z.string().nullable(),
-  photosWithTags: import_zod11.z.array(
-    import_zod11.z.object({
-      url: import_zod11.z.string(),
-      tag: import_zod11.z.string()
+  tags: import_zod12.z.array(import_zod12.z.nativeEnum(ClinicTag)),
+  logo: import_zod12.z.string().optional(),
+  coverPhoto: import_zod12.z.string().nullable(),
+  photosWithTags: import_zod12.z.array(
+    import_zod12.z.object({
+      url: import_zod12.z.string(),
+      tag: import_zod12.z.string()
     })
   ).optional(),
-  featuredPhotos: import_zod11.z.array(import_zod11.z.string()).optional()
+  featuredPhotos: import_zod12.z.array(import_zod12.z.string()).optional()
 });
 var updateClinicAdminSchema = createClinicAdminSchema.partial();
 var updateClinicGroupSchema = createClinicGroupSchema.partial();
@@ -3293,7 +3401,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     (0, import_firestore12.where)("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await (0, import_firestore12.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3558,7 +3666,7 @@ var ClinicAdminService = class extends BaseService {
 
 // src/services/practitioner/practitioner.service.ts
 var import_firestore13 = require("firebase/firestore");
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var import_geofire_common2 = require("geofire-common");
 var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService) {
@@ -3627,7 +3735,7 @@ var PractitionerService = class extends BaseService {
       }
       return createdPractitioner;
     } catch (error) {
-      if (error instanceof import_zod12.z.ZodError) {
+      if (error instanceof import_zod13.z.ZodError) {
         throw new Error(`Invalid practitioner data: ${error.message}`);
       }
       console.error("Error creating practitioner:", error);
@@ -3723,7 +3831,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore13.setDoc)((0, import_firestore13.doc)(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
-      if (error instanceof import_zod12.z.ZodError) {
+      if (error instanceof import_zod13.z.ZodError) {
         throw new Error("Invalid practitioner data: " + error.message);
       }
       throw error;
@@ -3776,7 +3884,7 @@ var PractitionerService = class extends BaseService {
       await (0, import_firestore13.setDoc)((0, import_firestore13.doc)(this.db, tokenPath), token);
       return token;
     } catch (error) {
-      if (error instanceof import_zod12.z.ZodError) {
+      if (error instanceof import_zod13.z.ZodError) {
         throw new Error("Invalid token data: " + error.message);
       }
       throw error;
@@ -3798,7 +3906,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore13.where)("expiresAt", ">", import_firestore13.Timestamp.now())
     );
     const querySnapshot = await (0, import_firestore13.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets a token by its string value and validates it
@@ -3881,7 +3989,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore13.where)("status", "==", "active" /* ACTIVE */)
     );
     const querySnapshot = await (0, import_firestore13.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
@@ -3893,7 +4001,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore13.where)("isActive", "==", true)
     );
     const querySnapshot = await (0, import_firestore13.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
@@ -3905,7 +4013,7 @@ var PractitionerService = class extends BaseService {
       (0, import_firestore13.where)("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await (0, import_firestore13.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Updates a practitioner
@@ -3936,7 +4044,7 @@ var PractitionerService = class extends BaseService {
       }
       return updatedPractitioner;
     } catch (error) {
-      if (error instanceof import_zod12.z.ZodError) {
+      if (error instanceof import_zod13.z.ZodError) {
         throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
       console.error(`Error updating practitioner ${practitionerId}:`, error);
@@ -4087,7 +4195,7 @@ var PractitionerService = class extends BaseService {
       );
       const querySnapshot = await (0, import_firestore13.getDocs)(q);
       const practitioners = querySnapshot.docs.map(
-        (doc29) => doc29.data()
+        (doc30) => doc30.data()
       );
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       return {
@@ -4158,8 +4266,8 @@ var PractitionerService = class extends BaseService {
       console.log(
         `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
       );
-      let practitioners = querySnapshot.docs.map((doc29) => {
-        return { ...doc29.data(), id: doc29.id };
+      let practitioners = querySnapshot.docs.map((doc30) => {
+        return { ...doc30.data(), id: doc30.id };
       });
       const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       if (filters.nameSearch && filters.nameSearch.trim() !== "") {
@@ -4413,7 +4521,7 @@ var UserService = class extends BaseService {
     ];
     const q = (0, import_firestore14.query)((0, import_firestore14.collection)(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore14.getDocs)(q);
-    const users = querySnapshot.docs.map((doc29) => doc29.data());
+    const users = querySnapshot.docs.map((doc30) => doc30.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
   /**
@@ -4464,7 +4572,7 @@ var UserService = class extends BaseService {
       });
       return this.getUserById(uid);
     } catch (error) {
-      if (error instanceof import_zod13.z.ZodError) {
+      if (error instanceof import_zod14.z.ZodError) {
         throw USER_ERRORS.VALIDATION_ERROR;
       }
       throw error;
@@ -4551,7 +4659,7 @@ var UserService = class extends BaseService {
 // src/services/clinic/utils/clinic-group.utils.ts
 var import_firestore15 = require("firebase/firestore");
 var import_geofire_common3 = require("geofire-common");
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
 var import_storage3 = require("firebase/storage");
@@ -4749,7 +4857,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     });
     return groupData;
   } catch (error) {
-    if (error instanceof import_zod14.z.ZodError) {
+    if (error instanceof import_zod15.z.ZodError) {
       console.error(
         "[CLINIC_GROUP] Zod validation error:",
         JSON.stringify(error.errors, null, 2)
@@ -4777,7 +4885,7 @@ async function getAllActiveGroups(db) {
     (0, import_firestore15.where)("isActive", "==", true)
   );
   const querySnapshot = await (0, import_firestore15.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
   console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
@@ -5154,12 +5262,12 @@ var ClinicGroupService = class extends BaseService {
 // src/services/clinic/clinic.service.ts
 var import_firestore19 = require("firebase/firestore");
 var import_geofire_common7 = require("geofire-common");
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/services/clinic/utils/clinic.utils.ts
 var import_firestore16 = require("firebase/firestore");
 var import_geofire_common4 = require("geofire-common");
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 async function getClinic(db, clinicId) {
   const docRef = (0, import_firestore16.doc)(db, CLINICS_COLLECTION, clinicId);
   const docSnap = await (0, import_firestore16.getDoc)(docRef);
@@ -5175,7 +5283,7 @@ async function getClinicsByGroup(db, groupId) {
     (0, import_firestore16.where)("isActive", "==", true)
   );
   const querySnapshot = await (0, import_firestore16.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
   console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
@@ -5369,7 +5477,7 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   }
   const q = (0, import_firestore16.query)((0, import_firestore16.collection)(db, CLINICS_COLLECTION), ...constraints);
   const querySnapshot = await (0, import_firestore16.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -5414,11 +5522,11 @@ async function getAllClinics(db, pagination, lastDoc) {
     }
     const clinicsSnapshot = await (0, import_firestore16.getDocs)(clinicsQuery);
     const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
-    const clinics = clinicsSnapshot.docs.map((doc29) => {
-      const data = doc29.data();
+    const clinics = clinicsSnapshot.docs.map((doc30) => {
+      const data = doc30.data();
       return {
         ...data,
-        id: doc29.id
+        id: doc30.id
       };
     });
     return {
@@ -5445,8 +5553,8 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
     ];
     const q = (0, import_firestore16.query)((0, import_firestore16.collection)(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore16.getDocs)(q);
-    for (const doc29 of querySnapshot.docs) {
-      const clinic = doc29.data();
+    for (const doc30 of querySnapshot.docs) {
+      const clinic = doc30.data();
       const distance = (0, import_geofire_common4.distanceBetween)(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5563,8 +5671,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = (0, import_firestore17.query)((0, import_firestore17.collection)(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await (0, import_firestore17.getDocs)(q);
-    for (const doc29 of querySnapshot.docs) {
-      const clinic = doc29.data();
+    for (const doc30 of querySnapshot.docs) {
+      const clinic = doc30.data();
       const distance = (0, import_geofire_common5.distanceBetween)(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5652,8 +5760,8 @@ async function getClinicsByFilters(db, filters) {
       console.log(
         `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
       );
-      for (const doc29 of querySnapshot.docs) {
-        const clinic = { ...doc29.data(), id: doc29.id };
+      for (const doc30 of querySnapshot.docs) {
+        const clinic = { ...doc30.data(), id: doc30.id };
         const distance = (0, import_geofire_common6.distanceBetween)(
           [center.latitude, center.longitude],
           [clinic.location.latitude, clinic.location.longitude]
@@ -5709,8 +5817,8 @@ async function getClinicsByFilters(db, filters) {
     console.log(
       `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    const clinics = querySnapshot.docs.map((doc29) => {
-      return { ...doc29.data(), id: doc29.id };
+    const clinics = querySnapshot.docs.map((doc30) => {
+      return { ...doc30.data(), id: doc30.id };
     });
     let filteredClinics = clinics;
     if (filters.center) {
@@ -5831,7 +5939,7 @@ var ClinicService = class extends BaseService {
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
     } catch (error) {
-      if (error instanceof import_zod16.z.ZodError) {
+      if (error instanceof import_zod17.z.ZodError) {
         throw new Error("Invalid clinic data: " + error.message);
       }
       console.error("Error creating clinic:", error);
@@ -5879,7 +5987,7 @@ var ClinicService = class extends BaseService {
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
-      if (error instanceof import_zod16.z.ZodError) {
+      if (error instanceof import_zod17.z.ZodError) {
         throw new Error(
           "Invalid clinic update data: " + error.errors.map((e) => `${e.path.join(".")} - ${e.message}`).join(", ")
         );
@@ -6338,7 +6446,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof import_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -6511,7 +6619,7 @@ var AuthService = class extends BaseService {
         email
       );
     } catch (error) {
-      if (error instanceof import_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6634,7 +6742,7 @@ var AuthService = class extends BaseService {
       await emailSchema.parseAsync(email);
       await (0, import_auth5.sendPasswordResetEmail)(this.auth, email);
     } catch (error) {
-      if (error instanceof import_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6673,7 +6781,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_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6760,9 +6868,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore21.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
   /**
@@ -6776,9 +6884,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore21.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
   /**
@@ -6850,9 +6958,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore21.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
   /**
@@ -6865,9 +6973,9 @@ var NotificationService = class extends BaseService {
       (0, import_firestore21.orderBy)("notificationTime", "desc")
     );
     const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
 };
@@ -6879,59 +6987,59 @@ var import_firestore22 = require("firebase/firestore");
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-var import_zod18 = require("zod");
-var createProcedureSchema = import_zod18.z.object({
-  name: import_zod18.z.string().min(1).max(200),
-  description: import_zod18.z.string().min(1).max(2e3),
-  family: import_zod18.z.nativeEnum(ProcedureFamily),
-  categoryId: import_zod18.z.string().min(1),
-  subcategoryId: import_zod18.z.string().min(1),
-  technologyId: import_zod18.z.string().min(1),
-  productId: import_zod18.z.string().min(1),
-  price: import_zod18.z.number().min(0),
-  currency: import_zod18.z.nativeEnum(Currency),
-  pricingMeasure: import_zod18.z.nativeEnum(PricingMeasure),
-  duration: import_zod18.z.number().min(1).max(480),
+var import_zod19 = require("zod");
+var createProcedureSchema = import_zod19.z.object({
+  name: import_zod19.z.string().min(1).max(200),
+  description: import_zod19.z.string().min(1).max(2e3),
+  family: import_zod19.z.nativeEnum(ProcedureFamily),
+  categoryId: import_zod19.z.string().min(1),
+  subcategoryId: import_zod19.z.string().min(1),
+  technologyId: import_zod19.z.string().min(1),
+  productId: import_zod19.z.string().min(1),
+  price: import_zod19.z.number().min(0),
+  currency: import_zod19.z.nativeEnum(Currency),
+  pricingMeasure: import_zod19.z.nativeEnum(PricingMeasure),
+  duration: import_zod19.z.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: import_zod18.z.string().min(1),
-  clinicBranchId: import_zod18.z.string().min(1)
+  practitionerId: import_zod19.z.string().min(1),
+  clinicBranchId: import_zod19.z.string().min(1)
 });
-var updateProcedureSchema = import_zod18.z.object({
-  name: import_zod18.z.string().min(3).max(100).optional(),
-  description: import_zod18.z.string().min(3).max(1e3).optional(),
-  price: import_zod18.z.number().min(0).optional(),
-  currency: import_zod18.z.nativeEnum(Currency).optional(),
-  pricingMeasure: import_zod18.z.nativeEnum(PricingMeasure).optional(),
-  duration: import_zod18.z.number().min(0).optional(),
-  isActive: import_zod18.z.boolean().optional(),
-  practitionerId: import_zod18.z.string().optional(),
-  categoryId: import_zod18.z.string().optional(),
-  subcategoryId: import_zod18.z.string().optional(),
-  technologyId: import_zod18.z.string().optional(),
-  productId: import_zod18.z.string().optional(),
-  clinicBranchId: import_zod18.z.string().optional()
+var updateProcedureSchema = import_zod19.z.object({
+  name: import_zod19.z.string().min(3).max(100).optional(),
+  description: import_zod19.z.string().min(3).max(1e3).optional(),
+  price: import_zod19.z.number().min(0).optional(),
+  currency: import_zod19.z.nativeEnum(Currency).optional(),
+  pricingMeasure: import_zod19.z.nativeEnum(PricingMeasure).optional(),
+  duration: import_zod19.z.number().min(0).optional(),
+  isActive: import_zod19.z.boolean().optional(),
+  practitionerId: import_zod19.z.string().optional(),
+  categoryId: import_zod19.z.string().optional(),
+  subcategoryId: import_zod19.z.string().optional(),
+  technologyId: import_zod19.z.string().optional(),
+  productId: import_zod19.z.string().optional(),
+  clinicBranchId: import_zod19.z.string().optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: import_zod18.z.string().min(1),
-  category: import_zod18.z.any(),
+  id: import_zod19.z.string().min(1),
+  category: import_zod19.z.any(),
   // We'll validate the full category object separately
-  subcategory: import_zod18.z.any(),
+  subcategory: import_zod19.z.any(),
   // We'll validate the full subcategory object separately
-  technology: import_zod18.z.any(),
+  technology: import_zod19.z.any(),
   // We'll validate the full technology object separately
-  product: import_zod18.z.any(),
+  product: import_zod19.z.any(),
   // We'll validate the full product object separately
-  blockingConditions: import_zod18.z.array(import_zod18.z.any()),
+  blockingConditions: import_zod19.z.array(import_zod19.z.any()),
   // We'll validate blocking conditions separately
-  treatmentBenefits: import_zod18.z.array(import_zod18.z.any()),
+  treatmentBenefits: import_zod19.z.array(import_zod19.z.any()),
   // We'll validate treatment benefits separately
-  preRequirements: import_zod18.z.array(import_zod18.z.any()),
+  preRequirements: import_zod19.z.array(import_zod19.z.any()),
   // We'll validate requirements separately
-  postRequirements: import_zod18.z.array(import_zod18.z.any()),
+  postRequirements: import_zod19.z.array(import_zod19.z.any()),
   // We'll validate requirements separately
-  certificationRequirement: import_zod18.z.any(),
+  certificationRequirement: import_zod19.z.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: import_zod18.z.array(import_zod18.z.any()),
+  documentationTemplates: import_zod19.z.array(import_zod19.z.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -6939,9 +7047,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: import_zod18.z.boolean(),
-  createdAt: import_zod18.z.date(),
-  updatedAt: import_zod18.z.date()
+  isActive: import_zod19.z.boolean(),
+  createdAt: import_zod19.z.date(),
+  updatedAt: import_zod19.z.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -7084,7 +7192,7 @@ var ProcedureService = class extends BaseService {
       (0, import_firestore22.where)("isActive", "==", true)
     );
     const snapshot = await (0, import_firestore22.getDocs)(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all procedures for a practitioner
@@ -7098,7 +7206,7 @@ var ProcedureService = class extends BaseService {
       (0, import_firestore22.where)("isActive", "==", true)
     );
     const snapshot = await (0, import_firestore22.getDocs)(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Updates a procedure
@@ -7281,20 +7389,20 @@ var ProcedureService = class extends BaseService {
       const proceduresCollection = (0, import_firestore22.collection)(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = (0, import_firestore22.query)(proceduresCollection);
       if (pagination && pagination > 0) {
-        const { limit: limit8, startAfter: startAfter8 } = await import("firebase/firestore");
+        const { limit: limit9, startAfter: startAfter9 } = await import("firebase/firestore");
         if (lastDoc) {
           proceduresQuery = (0, import_firestore22.query)(
             proceduresCollection,
             (0, import_firestore22.orderBy)("name"),
             // Use imported orderBy
-            startAfter8(lastDoc),
-            limit8(pagination)
+            startAfter9(lastDoc),
+            limit9(pagination)
           );
         } else {
           proceduresQuery = (0, import_firestore22.query)(
             proceduresCollection,
             (0, import_firestore22.orderBy)("name"),
-            limit8(pagination)
+            limit9(pagination)
           );
         }
       } else {
@@ -7302,11 +7410,11 @@ var ProcedureService = class extends BaseService {
       }
       const proceduresSnapshot = await (0, import_firestore22.getDocs)(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
-      const procedures = proceduresSnapshot.docs.map((doc29) => {
-        const data = doc29.data();
+      const procedures = proceduresSnapshot.docs.map((doc30) => {
+        const data = doc30.data();
         return {
           ...data,
-          id: doc29.id
+          id: doc30.id
           // Ensure ID is present
         };
       });
@@ -7388,8 +7496,8 @@ var ProcedureService = class extends BaseService {
           console.log(
             `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures in geo bound`
           );
-          for (const doc29 of querySnapshot.docs) {
-            const procedure = { ...doc29.data(), id: doc29.id };
+          for (const doc30 of querySnapshot.docs) {
+            const procedure = { ...doc30.data(), id: doc30.id };
             const distance = (0, import_geofire_common8.distanceBetween)(
               [center.latitude, center.longitude],
               [
@@ -7440,8 +7548,8 @@ var ProcedureService = class extends BaseService {
         console.log(
           `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures with regular query`
         );
-        const procedures = querySnapshot.docs.map((doc29) => {
-          return { ...doc29.data(), id: doc29.id };
+        const procedures = querySnapshot.docs.map((doc30) => {
+          return { ...doc30.data(), id: doc30.id };
         });
         if (filters.location) {
           const center = filters.location;
@@ -7659,9 +7767,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      templates.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      templates.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       templates,
@@ -7689,9 +7797,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      templates.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      templates.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       templates,
@@ -7718,9 +7826,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await (0, import_firestore23.getDocs)(q);
     const templates = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      templates.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      templates.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       templates,
@@ -7833,9 +7941,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await (0, import_firestore24.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      documents.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      documents.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       documents,
@@ -7862,9 +7970,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await (0, import_firestore24.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      documents.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      documents.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       documents,
@@ -7891,9 +7999,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await (0, import_firestore24.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      documents.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      documents.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       documents,
@@ -7920,9 +8028,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await (0, import_firestore24.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      documents.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      documents.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       documents,
@@ -7949,9 +8057,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await (0, import_firestore24.getDocs)(q);
     const documents = [];
     let lastVisible = null;
-    querySnapshot.forEach((doc29) => {
-      documents.push(doc29.data());
-      lastVisible = doc29;
+    querySnapshot.forEach((doc30) => {
+      documents.push(doc30.data());
+      lastVisible = doc30;
     });
     return {
       documents,
@@ -7976,42 +8084,42 @@ var SYNCED_CALENDARS_COLLECTION = "syncedCalendars";
 var import_firestore35 = require("firebase/firestore");
 
 // src/validations/calendar.schema.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var import_firestore26 = require("firebase/firestore");
 
 // src/validations/profile-info.schema.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 var import_firestore25 = require("firebase/firestore");
-var clinicInfoSchema2 = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  featuredPhoto: import_zod19.z.string(),
-  name: import_zod19.z.string(),
-  description: import_zod19.z.string(),
+var clinicInfoSchema2 = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  featuredPhoto: import_zod20.z.string(),
+  name: import_zod20.z.string(),
+  description: import_zod20.z.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var practitionerProfileInfoSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  practitionerPhoto: import_zod19.z.string().nullable(),
-  name: import_zod19.z.string(),
-  email: import_zod19.z.string().email(),
-  phone: import_zod19.z.string().nullable(),
+var practitionerProfileInfoSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  practitionerPhoto: import_zod20.z.string().nullable(),
+  name: import_zod20.z.string(),
+  email: import_zod20.z.string().email(),
+  phone: import_zod20.z.string().nullable(),
   certification: practitionerCertificationSchema
 });
-var patientProfileInfoSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  fullName: import_zod19.z.string(),
-  email: import_zod19.z.string().email(),
-  phone: import_zod19.z.string().nullable(),
-  dateOfBirth: import_zod19.z.instanceof(import_firestore25.Timestamp),
-  gender: import_zod19.z.nativeEnum(Gender)
+var patientProfileInfoSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  fullName: import_zod20.z.string(),
+  email: import_zod20.z.string().email(),
+  phone: import_zod20.z.string().nullable(),
+  dateOfBirth: import_zod20.z.instanceof(import_firestore25.Timestamp),
+  gender: import_zod20.z.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = import_zod20.z.object({
-  start: import_zod20.z.instanceof(Date).or(import_zod20.z.instanceof(import_firestore26.Timestamp)),
-  end: import_zod20.z.instanceof(Date).or(import_zod20.z.instanceof(import_firestore26.Timestamp))
+var calendarEventTimeSchema = import_zod21.z.object({
+  start: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore26.Timestamp)),
+  end: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore26.Timestamp))
 }).refine(
   (data) => {
     const startDate = data.start instanceof import_firestore26.Timestamp ? data.start.toDate() : data.start;
@@ -8032,46 +8140,46 @@ var calendarEventTimeSchema = import_zod20.z.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = import_zod20.z.object({
-  start: import_zod20.z.date(),
-  end: import_zod20.z.date(),
-  isAvailable: import_zod20.z.boolean()
+var timeSlotSchema2 = import_zod21.z.object({
+  start: import_zod21.z.date(),
+  end: import_zod21.z.date(),
+  isAvailable: import_zod21.z.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-var syncedCalendarEventSchema = import_zod20.z.object({
-  eventId: import_zod20.z.string(),
-  syncedCalendarProvider: import_zod20.z.nativeEnum(SyncedCalendarProvider),
-  syncedAt: import_zod20.z.instanceof(Date).or(import_zod20.z.instanceof(import_firestore26.Timestamp))
+var syncedCalendarEventSchema = import_zod21.z.object({
+  eventId: import_zod21.z.string(),
+  syncedCalendarProvider: import_zod21.z.nativeEnum(SyncedCalendarProvider),
+  syncedAt: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore26.Timestamp))
 });
-var procedureInfoSchema = import_zod20.z.object({
-  name: import_zod20.z.string(),
-  description: import_zod20.z.string(),
-  duration: import_zod20.z.number().min(MIN_APPOINTMENT_DURATION),
-  price: import_zod20.z.number().min(0),
-  currency: import_zod20.z.nativeEnum(Currency)
+var procedureInfoSchema = import_zod21.z.object({
+  name: import_zod21.z.string(),
+  description: import_zod21.z.string(),
+  duration: import_zod21.z.number().min(MIN_APPOINTMENT_DURATION),
+  price: import_zod21.z.number().min(0),
+  currency: import_zod21.z.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = import_zod20.z.object({
-  procedureFamily: import_zod20.z.string(),
+var procedureCategorizationSchema = import_zod21.z.object({
+  procedureFamily: import_zod21.z.string(),
   // Replace with proper enum when available
-  procedureCategory: import_zod20.z.string(),
+  procedureCategory: import_zod21.z.string(),
   // Replace with proper enum when available
-  procedureSubcategory: import_zod20.z.string(),
+  procedureSubcategory: import_zod21.z.string(),
   // Replace with proper enum when available
-  procedureTechnology: import_zod20.z.string(),
+  procedureTechnology: import_zod21.z.string(),
   // Replace with proper enum when available
-  procedureProduct: import_zod20.z.string()
+  procedureProduct: import_zod21.z.string()
   // Replace with proper enum when available
 });
-var createAppointmentSchema = import_zod20.z.object({
-  clinicId: import_zod20.z.string().min(1, "Clinic ID is required"),
-  doctorId: import_zod20.z.string().min(1, "Doctor ID is required"),
-  patientId: import_zod20.z.string().min(1, "Patient ID is required"),
-  procedureId: import_zod20.z.string().min(1, "Procedure ID is required"),
+var createAppointmentSchema2 = import_zod21.z.object({
+  clinicId: import_zod21.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod21.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod21.z.string().min(1, "Patient ID is required"),
+  procedureId: import_zod21.z.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: import_zod20.z.string().optional()
+  description: import_zod21.z.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -8080,73 +8188,73 @@ var createAppointmentSchema = import_zod20.z.object({
     message: "Invalid appointment parameters"
   }
 );
-var updateAppointmentSchema = import_zod20.z.object({
-  appointmentId: import_zod20.z.string().min(1, "Appointment ID is required"),
-  clinicId: import_zod20.z.string().min(1, "Clinic ID is required"),
-  doctorId: import_zod20.z.string().min(1, "Doctor ID is required"),
-  patientId: import_zod20.z.string().min(1, "Patient ID is required"),
+var updateAppointmentSchema2 = import_zod21.z.object({
+  appointmentId: import_zod21.z.string().min(1, "Appointment ID is required"),
+  clinicId: import_zod21.z.string().min(1, "Clinic ID is required"),
+  doctorId: import_zod21.z.string().min(1, "Doctor ID is required"),
+  patientId: import_zod21.z.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod20.z.string().optional(),
-  status: import_zod20.z.nativeEnum(CalendarEventStatus).optional()
+  description: import_zod21.z.string().optional(),
+  status: import_zod21.z.nativeEnum(CalendarEventStatus).optional()
 });
-var createCalendarEventSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  clinicBranchId: import_zod20.z.string().nullable().optional(),
-  clinicBranchInfo: import_zod20.z.any().nullable().optional(),
-  practitionerProfileId: import_zod20.z.string().nullable().optional(),
+var createCalendarEventSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  clinicBranchId: import_zod21.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod21.z.any().nullable().optional(),
+  practitionerProfileId: import_zod21.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod20.z.string().nullable().optional(),
+  patientProfileId: import_zod21.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod20.z.string().nullable().optional(),
-  appointmentId: import_zod20.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod20.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod20.z.string().min(1, "Event name is required"),
+  procedureId: import_zod21.z.string().nullable().optional(),
+  appointmentId: import_zod21.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod21.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod21.z.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: import_zod20.z.string().optional(),
-  status: import_zod20.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod20.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod20.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod20.z.any(),
+  description: import_zod21.z.string().optional(),
+  status: import_zod21.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod21.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod21.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod21.z.any(),
   // FieldValue for server timestamp
-  updatedAt: import_zod20.z.any()
+  updatedAt: import_zod21.z.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = import_zod20.z.object({
-  syncedCalendarEventId: import_zod20.z.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: import_zod20.z.string().nullable().optional(),
-  eventName: import_zod20.z.string().optional(),
+var updateCalendarEventSchema = import_zod21.z.object({
+  syncedCalendarEventId: import_zod21.z.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: import_zod21.z.string().nullable().optional(),
+  eventName: import_zod21.z.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: import_zod20.z.string().optional(),
-  status: import_zod20.z.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: import_zod20.z.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: import_zod20.z.nativeEnum(CalendarEventType).optional(),
-  updatedAt: import_zod20.z.any()
+  description: import_zod21.z.string().optional(),
+  status: import_zod21.z.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: import_zod21.z.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: import_zod21.z.nativeEnum(CalendarEventType).optional(),
+  updatedAt: import_zod21.z.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  clinicBranchId: import_zod20.z.string().nullable().optional(),
-  clinicBranchInfo: import_zod20.z.any().nullable().optional(),
+var calendarEventSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  clinicBranchId: import_zod21.z.string().nullable().optional(),
+  clinicBranchInfo: import_zod21.z.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: import_zod20.z.string().nullable().optional(),
+  practitionerProfileId: import_zod21.z.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: import_zod20.z.string().nullable().optional(),
+  patientProfileId: import_zod21.z.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: import_zod20.z.string().nullable().optional(),
+  procedureId: import_zod21.z.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: import_zod20.z.string().nullable().optional(),
-  syncedCalendarEventId: import_zod20.z.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: import_zod20.z.string(),
+  appointmentId: import_zod21.z.string().nullable().optional(),
+  syncedCalendarEventId: import_zod21.z.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: import_zod21.z.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: import_zod20.z.string().optional(),
-  status: import_zod20.z.nativeEnum(CalendarEventStatus),
-  syncStatus: import_zod20.z.nativeEnum(CalendarSyncStatus),
-  eventType: import_zod20.z.nativeEnum(CalendarEventType),
-  createdAt: import_zod20.z.instanceof(Date).or(import_zod20.z.instanceof(import_firestore26.Timestamp)),
-  updatedAt: import_zod20.z.instanceof(Date).or(import_zod20.z.instanceof(import_firestore26.Timestamp))
+  description: import_zod21.z.string().optional(),
+  status: import_zod21.z.nativeEnum(CalendarEventStatus),
+  syncStatus: import_zod21.z.nativeEnum(CalendarSyncStatus),
+  eventType: import_zod21.z.nativeEnum(CalendarEventType),
+  createdAt: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore26.Timestamp)),
+  updatedAt: import_zod21.z.instanceof(Date).or(import_zod21.z.instanceof(import_firestore26.Timestamp))
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -8448,7 +8556,7 @@ async function searchCalendarEventsUtil(db, params) {
     const finalQuery = (0, import_firestore31.query)(collectionRef, ...constraints);
     const querySnapshot = await (0, import_firestore31.getDocs)(finalQuery);
     const events = querySnapshot.docs.map(
-      (doc29) => ({ id: doc29.id, ...doc29.data() })
+      (doc30) => ({ id: doc30.id, ...doc30.data() })
     );
     return events;
   } catch (error) {
@@ -8530,7 +8638,7 @@ async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
   );
   const q = (0, import_firestore32.query)(calendarsRef, (0, import_firestore32.orderBy)("createdAt", "desc"));
   const querySnapshot = await (0, import_firestore32.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function getPatientSyncedCalendarUtil(db, patientId, calendarId) {
   const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
@@ -8547,7 +8655,7 @@ async function getPatientSyncedCalendarsUtil(db, patientId) {
   );
   const q = (0, import_firestore32.query)(calendarsRef, (0, import_firestore32.orderBy)("createdAt", "desc"));
   const querySnapshot = await (0, import_firestore32.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function getClinicSyncedCalendarUtil(db, clinicId, calendarId) {
   const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
@@ -8564,7 +8672,7 @@ async function getClinicSyncedCalendarsUtil(db, clinicId) {
   );
   const q = (0, import_firestore32.query)(calendarsRef, (0, import_firestore32.orderBy)("createdAt", "desc"));
   const querySnapshot = await (0, import_firestore32.getDocs)(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function updatePractitionerSyncedCalendarUtil(db, practitionerId, calendarId, updateData) {
   const calendarRef = getPractitionerSyncedCalendarDocRef(
@@ -9919,9 +10027,9 @@ var CalendarServiceV2 = class extends BaseService {
         (0, import_firestore35.where)("eventTime.start", "<=", import_firestore34.Timestamp.fromDate(endDate))
       );
       const eventsSnapshot = await (0, import_firestore35.getDocs)(q);
-      const events = eventsSnapshot.docs.map((doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      const events = eventsSnapshot.docs.map((doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       }));
       const calendars = await this.syncedCalendarsService.getPractitionerSyncedCalendars(
         doctorId
@@ -10188,7 +10296,7 @@ var CalendarServiceV2 = class extends BaseService {
    * @throws Error if validation fails
    */
   async validateAppointmentParams(params) {
-    await createAppointmentSchema.parseAsync(params);
+    await createAppointmentSchema2.parseAsync(params);
   }
   /**
    * Validates if the event time falls within clinic working hours
@@ -10470,7 +10578,7 @@ var CalendarServiceV2 = class extends BaseService {
    * @param params - Update parameters to validate
    */
   async validateUpdatePermissions(params) {
-    await updateAppointmentSchema.parseAsync(params);
+    await updateAppointmentSchema2.parseAsync(params);
   }
   /**
    * Gets clinic working hours for a specific date
@@ -10553,7 +10661,7 @@ var CalendarServiceV2 = class extends BaseService {
       ])
     );
     const querySnapshot = await (0, import_firestore35.getDocs)(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Calculates available time slots based on working hours, schedule and existing appointments
@@ -10684,7 +10792,7 @@ var import_firestore36 = require("firebase/firestore");
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -10790,7 +10898,7 @@ var ReviewService = class extends BaseService {
       await Promise.all(updatePromises);
       return review;
     } catch (error) {
-      if (error instanceof import_zod21.z.ZodError) {
+      if (error instanceof import_zod22.z.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -10820,7 +10928,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore36.where)("patientId", "==", patientId)
     );
     const snapshot = await (0, import_firestore36.getDocs)(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific clinic
@@ -10833,7 +10941,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore36.where)("clinicReview.clinicId", "==", clinicId)
     );
     const snapshot = await (0, import_firestore36.getDocs)(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific practitioner
@@ -10846,7 +10954,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore36.where)("practitionerReview.practitionerId", "==", practitionerId)
     );
     const snapshot = await (0, import_firestore36.getDocs)(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific procedure
@@ -10859,7 +10967,7 @@ var ReviewService = class extends BaseService {
       (0, import_firestore36.where)("procedureReview.procedureId", "==", procedureId)
     );
     const snapshot = await (0, import_firestore36.getDocs)(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific appointment
@@ -11286,94 +11394,917 @@ var ReviewService = class extends BaseService {
   }
 };
 
-// src/backoffice/services/brand.service.ts
+// src/services/appointment/appointment.service.ts
+var import_firestore38 = require("firebase/firestore");
+var import_functions = require("firebase/functions");
+
+// src/services/appointment/utils/appointment.utils.ts
 var import_firestore37 = require("firebase/firestore");
 
-// src/backoffice/types/brand.types.ts
-var BRANDS_COLLECTION = "brands";
+// src/backoffice/types/technology.types.ts
+var TECHNOLOGIES_COLLECTION = "technologies";
 
-// src/backoffice/services/brand.service.ts
-var BrandService = class extends BaseService {
-  /**
-   * Gets reference to brands collection
-   */
-  getBrandsRef() {
-    return (0, import_firestore37.collection)(this.db, BRANDS_COLLECTION);
-  }
-  /**
-   * Creates a new brand
-   */
-  async create(brand) {
-    const now = /* @__PURE__ */ new Date();
-    const newBrand = {
-      ...brand,
-      createdAt: now,
-      updatedAt: now,
-      isActive: true
+// src/services/appointment/utils/appointment.utils.ts
+async function fetchAggregatedInfoUtil(db, clinicId, practitionerId, patientId, procedureId) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  try {
+    const [clinicDoc, practitionerDoc, patientDoc, procedureDoc] = await Promise.all([
+      (0, import_firestore37.getDoc)((0, import_firestore37.doc)(db, CLINICS_COLLECTION, clinicId)),
+      (0, import_firestore37.getDoc)((0, import_firestore37.doc)(db, PRACTITIONERS_COLLECTION, practitionerId)),
+      (0, import_firestore37.getDoc)((0, import_firestore37.doc)(db, PATIENTS_COLLECTION, patientId)),
+      (0, import_firestore37.getDoc)((0, import_firestore37.doc)(db, PROCEDURES_COLLECTION, procedureId))
+    ]);
+    if (!clinicDoc.exists()) {
+      throw new Error(`Clinic with ID ${clinicId} not found`);
+    }
+    if (!practitionerDoc.exists()) {
+      throw new Error(`Practitioner with ID ${practitionerId} not found`);
+    }
+    if (!patientDoc.exists()) {
+      throw new Error(`Patient with ID ${patientId} not found`);
+    }
+    if (!procedureDoc.exists()) {
+      throw new Error(`Procedure with ID ${procedureId} not found`);
+    }
+    const clinicData = clinicDoc.data();
+    const practitionerData = practitionerDoc.data();
+    const patientData = patientDoc.data();
+    const procedureData = procedureDoc.data();
+    const clinicInfo = {
+      id: clinicId,
+      featuredPhoto: ((_a = clinicData.featuredPhotos) == null ? void 0 : _a[0]) || "",
+      name: clinicData.name,
+      description: clinicData.description || null,
+      location: clinicData.location,
+      contactInfo: clinicData.contactInfo
     };
-    const docRef = await (0, import_firestore37.addDoc)(this.getBrandsRef(), newBrand);
-    return { id: docRef.id, ...newBrand };
-  }
-  /**
-   * Gets all active brands
-   */
-  async getAll() {
-    const q = (0, import_firestore37.query)(this.getBrandsRef(), (0, import_firestore37.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore37.getDocs)(q);
-    return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
-      })
-    );
-  }
-  /**
-   * Updates a brand
-   */
-  async update(brandId, brand) {
-    const updateData = {
-      ...brand,
-      updatedAt: /* @__PURE__ */ new Date()
+    const practitionerInfo = {
+      id: practitionerId,
+      practitionerPhoto: ((_b = practitionerData.basicInfo) == null ? void 0 : _b.profileImageUrl) || null,
+      name: `${((_c = practitionerData.basicInfo) == null ? void 0 : _c.firstName) || ""} ${((_d = practitionerData.basicInfo) == null ? void 0 : _d.lastName) || ""}`.trim(),
+      email: ((_e = practitionerData.basicInfo) == null ? void 0 : _e.email) || "",
+      phone: ((_f = practitionerData.basicInfo) == null ? void 0 : _f.phoneNumber) || null,
+      certification: practitionerData.certification
     };
-    const docRef = (0, import_firestore37.doc)(this.getBrandsRef(), brandId);
-    await (0, import_firestore37.updateDoc)(docRef, updateData);
-    return this.getById(brandId);
+    const patientInfo = {
+      id: patientId,
+      fullName: patientData.displayName || "",
+      email: patientData.email || "",
+      phone: patientData.phoneNumber || null,
+      dateOfBirth: patientData.dateOfBirth || import_firestore37.Timestamp.now(),
+      gender: patientData.gender || "other"
+    };
+    const procedureInfo = {
+      id: procedureId,
+      name: procedureData.name,
+      description: procedureData.description,
+      photo: procedureData.photo || "",
+      family: procedureData.family,
+      categoryName: ((_g = procedureData.category) == null ? void 0 : _g.name) || "",
+      subcategoryName: ((_h = procedureData.subcategory) == null ? void 0 : _h.name) || "",
+      technologyName: ((_i = procedureData.technology) == null ? void 0 : _i.name) || "",
+      brandName: ((_j = procedureData.product) == null ? void 0 : _j.brand) || "",
+      productName: ((_k = procedureData.product) == null ? void 0 : _k.name) || "",
+      price: procedureData.price || 0,
+      pricingMeasure: procedureData.pricingMeasure,
+      currency: procedureData.currency,
+      duration: procedureData.duration || 0,
+      clinicId,
+      clinicName: clinicInfo.name,
+      practitionerId,
+      practitionerName: practitionerInfo.name
+    };
+    let technologyId = "";
+    if ((_l = procedureData.technology) == null ? void 0 : _l.id) {
+      technologyId = procedureData.technology.id;
+    }
+    let blockingConditions = [];
+    let contraindications = [];
+    let preProcedureRequirements = [];
+    let postProcedureRequirements = [];
+    if (technologyId) {
+      const technologyDoc = await (0, import_firestore37.getDoc)(
+        (0, import_firestore37.doc)(db, TECHNOLOGIES_COLLECTION, technologyId)
+      );
+      if (technologyDoc.exists()) {
+        const technologyData = technologyDoc.data();
+        blockingConditions = technologyData.blockingConditions || [];
+        contraindications = technologyData.contraindications || [];
+        preProcedureRequirements = ((_m = technologyData.requirements) == null ? void 0 : _m.pre) || [];
+        postProcedureRequirements = ((_n = technologyData.requirements) == null ? void 0 : _n.post) || [];
+      }
+    } else {
+      blockingConditions = procedureData.blockingConditions || [];
+      contraindications = procedureData.contraindications || [];
+      preProcedureRequirements = procedureData.preRequirements || [];
+      postProcedureRequirements = procedureData.postRequirements || [];
+    }
+    return {
+      clinicInfo,
+      practitionerInfo,
+      patientInfo,
+      procedureInfo,
+      blockingConditions,
+      contraindications,
+      preProcedureRequirements,
+      postProcedureRequirements
+    };
+  } catch (error) {
+    console.error("Error fetching aggregated info:", error);
+    throw error;
   }
-  /**
-   * Soft deletes a brand
-   */
-  async delete(brandId) {
-    await this.update(brandId, {
-      isActive: false
+}
+async function createAppointmentUtil2(db, data, aggregatedInfo, generateId2) {
+  try {
+    const appointmentId = generateId2();
+    const appointment = {
+      id: appointmentId,
+      calendarEventId: data.calendarEventId,
+      clinicBranchId: data.clinicBranchId,
+      clinicInfo: aggregatedInfo.clinicInfo,
+      practitionerId: data.practitionerId,
+      practitionerInfo: aggregatedInfo.practitionerInfo,
+      patientId: data.patientId,
+      patientInfo: aggregatedInfo.patientInfo,
+      procedureId: data.procedureId,
+      procedureInfo: aggregatedInfo.procedureInfo,
+      status: data.initialStatus,
+      bookingTime: import_firestore37.Timestamp.now(),
+      appointmentStartTime: data.appointmentStartTime,
+      appointmentEndTime: data.appointmentEndTime,
+      patientNotes: data.patientNotes || null,
+      cost: data.cost,
+      currency: data.currency,
+      paymentStatus: data.initialPaymentStatus || "unpaid" /* UNPAID */,
+      blockingConditions: aggregatedInfo.blockingConditions,
+      contraindications: aggregatedInfo.contraindications,
+      preProcedureRequirements: aggregatedInfo.preProcedureRequirements,
+      postProcedureRequirements: aggregatedInfo.postProcedureRequirements,
+      completedPreRequirements: [],
+      completedPostRequirements: [],
+      createdAt: (0, import_firestore37.serverTimestamp)(),
+      updatedAt: (0, import_firestore37.serverTimestamp)()
+    };
+    if (data.initialStatus === "confirmed" /* CONFIRMED */) {
+      appointment.confirmationTime = import_firestore37.Timestamp.now();
+    }
+    await (0, import_firestore37.setDoc)((0, import_firestore37.doc)(db, APPOINTMENTS_COLLECTION, appointmentId), appointment);
+    const calendarEventRef = (0, import_firestore37.doc)(db, CALENDAR_COLLECTION, data.calendarEventId);
+    await (0, import_firestore37.updateDoc)(calendarEventRef, {
+      appointmentId,
+      updatedAt: (0, import_firestore37.serverTimestamp)()
     });
-  }
-  /**
-   * Gets a brand by ID
-   */
-  async getById(brandId) {
-    const docRef = (0, import_firestore37.doc)(this.getBrandsRef(), brandId);
-    const docSnap = await (0, import_firestore37.getDoc)(docRef);
-    if (!docSnap.exists()) return null;
+    const now = import_firestore37.Timestamp.now();
     return {
-      id: docSnap.id,
-      ...docSnap.data()
+      ...appointment,
+      createdAt: now,
+      updatedAt: now
     };
+  } catch (error) {
+    console.error("Error creating appointment:", error);
+    throw error;
+  }
+}
+async function updateAppointmentUtil2(db, appointmentId, data) {
+  try {
+    const appointmentRef = (0, import_firestore37.doc)(db, APPOINTMENTS_COLLECTION, appointmentId);
+    const appointmentDoc = await (0, import_firestore37.getDoc)(appointmentRef);
+    if (!appointmentDoc.exists()) {
+      throw new Error(`Appointment with ID ${appointmentId} not found`);
+    }
+    const currentAppointment = appointmentDoc.data();
+    let completedPreRequirements = currentAppointment.completedPreRequirements || [];
+    let completedPostRequirements = currentAppointment.completedPostRequirements || [];
+    if (data.completedPreRequirements) {
+      const validPreReqIds = currentAppointment.preProcedureRequirements.map(
+        (req) => req.id
+      );
+      const invalidPreReqIds = data.completedPreRequirements.filter(
+        (id) => !validPreReqIds.includes(id)
+      );
+      if (invalidPreReqIds.length > 0) {
+        throw new Error(
+          `Invalid pre-requirement IDs: ${invalidPreReqIds.join(", ")}`
+        );
+      }
+      completedPreRequirements = [
+        .../* @__PURE__ */ new Set([
+          ...completedPreRequirements,
+          ...data.completedPreRequirements
+        ])
+      ];
+    }
+    if (data.completedPostRequirements) {
+      const validPostReqIds = currentAppointment.postProcedureRequirements.map(
+        (req) => req.id
+      );
+      const invalidPostReqIds = data.completedPostRequirements.filter(
+        (id) => !validPostReqIds.includes(id)
+      );
+      if (invalidPostReqIds.length > 0) {
+        throw new Error(
+          `Invalid post-requirement IDs: ${invalidPostReqIds.join(", ")}`
+        );
+      }
+      completedPostRequirements = [
+        .../* @__PURE__ */ new Set([
+          ...completedPostRequirements,
+          ...data.completedPostRequirements
+        ])
+      ];
+    }
+    const updateData = {
+      ...data,
+      completedPreRequirements,
+      completedPostRequirements,
+      updatedAt: (0, import_firestore37.serverTimestamp)()
+    };
+    Object.keys(updateData).forEach((key) => {
+      if (updateData[key] === void 0) {
+        delete updateData[key];
+      }
+    });
+    if (data.status && data.status !== currentAppointment.status) {
+      if (data.status === "confirmed" /* CONFIRMED */ && !updateData.confirmationTime) {
+        updateData.confirmationTime = import_firestore37.Timestamp.now();
+      }
+      if (currentAppointment.calendarEventId) {
+        await updateCalendarEventStatus(
+          db,
+          currentAppointment.calendarEventId,
+          data.status
+        );
+      }
+    }
+    await (0, import_firestore37.updateDoc)(appointmentRef, updateData);
+    const updatedAppointmentDoc = await (0, import_firestore37.getDoc)(appointmentRef);
+    if (!updatedAppointmentDoc.exists()) {
+      throw new Error(
+        `Failed to retrieve updated appointment ${appointmentId}`
+      );
+    }
+    return updatedAppointmentDoc.data();
+  } catch (error) {
+    console.error(`Error updating appointment ${appointmentId}:`, error);
+    throw error;
+  }
+}
+async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus) {
+  try {
+    const calendarEventRef = (0, import_firestore37.doc)(db, CALENDAR_COLLECTION, calendarEventId);
+    const calendarEventDoc = await (0, import_firestore37.getDoc)(calendarEventRef);
+    if (!calendarEventDoc.exists()) {
+      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+      return;
+    }
+    let calendarStatus;
+    switch (appointmentStatus) {
+      case "confirmed" /* CONFIRMED */:
+        calendarStatus = "confirmed";
+        break;
+      case "canceled_patient" /* CANCELED_PATIENT */:
+      case "canceled_clinic" /* CANCELED_CLINIC */:
+        calendarStatus = "canceled";
+        break;
+      case "rescheduled" /* RESCHEDULED */:
+        calendarStatus = "rescheduled";
+        break;
+      case "completed" /* COMPLETED */:
+        calendarStatus = "completed";
+        break;
+      default:
+        return;
+    }
+    await (0, import_firestore37.updateDoc)(calendarEventRef, {
+      status: calendarStatus,
+      updatedAt: (0, import_firestore37.serverTimestamp)()
+    });
+  } catch (error) {
+    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+  }
+}
+async function getAppointmentByIdUtil(db, appointmentId) {
+  try {
+    const appointmentDoc = await (0, import_firestore37.getDoc)(
+      (0, import_firestore37.doc)(db, APPOINTMENTS_COLLECTION, appointmentId)
+    );
+    if (!appointmentDoc.exists()) {
+      return null;
+    }
+    return appointmentDoc.data();
+  } catch (error) {
+    console.error(`Error getting appointment ${appointmentId}:`, error);
+    throw error;
+  }
+}
+async function searchAppointmentsUtil(db, params) {
+  try {
+    const constraints = [];
+    if (params.patientId) {
+      constraints.push((0, import_firestore37.where)("patientId", "==", params.patientId));
+    }
+    if (params.practitionerId) {
+      constraints.push((0, import_firestore37.where)("practitionerId", "==", params.practitionerId));
+    }
+    if (params.clinicBranchId) {
+      constraints.push((0, import_firestore37.where)("clinicBranchId", "==", params.clinicBranchId));
+    }
+    if (params.startDate) {
+      constraints.push(
+        (0, import_firestore37.where)(
+          "appointmentStartTime",
+          ">=",
+          import_firestore37.Timestamp.fromDate(params.startDate)
+        )
+      );
+    }
+    if (params.endDate) {
+      constraints.push(
+        (0, import_firestore37.where)("appointmentStartTime", "<=", import_firestore37.Timestamp.fromDate(params.endDate))
+      );
+    }
+    if (params.status) {
+      if (Array.isArray(params.status)) {
+        constraints.push((0, import_firestore37.where)("status", "in", params.status));
+      } else {
+        constraints.push((0, import_firestore37.where)("status", "==", params.status));
+      }
+    }
+    constraints.push((0, import_firestore37.orderBy)("appointmentStartTime", "asc"));
+    if (params.limit) {
+      constraints.push((0, import_firestore37.limit)(params.limit));
+    }
+    if (params.startAfter) {
+      constraints.push((0, import_firestore37.startAfter)(params.startAfter));
+    }
+    const q = (0, import_firestore37.query)((0, import_firestore37.collection)(db, APPOINTMENTS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore37.getDocs)(q);
+    const appointments = querySnapshot.docs.map(
+      (doc30) => doc30.data()
+    );
+    const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+    return { appointments, lastDoc };
+  } catch (error) {
+    console.error("Error searching appointments:", error);
+    throw error;
+  }
+}
+
+// src/services/appointment/appointment.service.ts
+var AppointmentService = class extends BaseService {
+  /**
+   * Creates a new AppointmentService instance.
+   *
+   * @param db Firestore instance
+   * @param auth Firebase Auth instance
+   * @param app Firebase App instance
+   * @param calendarService Calendar service instance
+   * @param patientService Patient service instance
+   * @param practitionerService Practitioner service instance
+   * @param clinicService Clinic service instance
+   */
+  constructor(db, auth, app, calendarService, patientService, practitionerService, clinicService) {
+    super(db, auth, app);
+    this.calendarService = calendarService;
+    this.patientService = patientService;
+    this.practitionerService = practitionerService;
+    this.clinicService = clinicService;
+    this.functions = (0, import_functions.getFunctions)(app, "europe-west6");
+  }
+  /**
+   * Gets available booking slots for a specific clinic, practitioner, and procedure.
+   *
+   * @param clinicId ID of the clinic
+   * @param practitionerId ID of the practitioner
+   * @param procedureId ID of the procedure
+   * @param startDate Start date of the time range to check
+   * @param endDate End date of the time range to check
+   * @returns Array of available booking slots
+   */
+  async getAvailableBookingSlots(clinicId, practitionerId, procedureId, startDate, endDate) {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting available booking slots for clinic: ${clinicId}, practitioner: ${practitionerId}, procedure: ${procedureId}`
+      );
+      if (!clinicId || !practitionerId || !procedureId || !startDate || !endDate) {
+        throw new Error(
+          "Missing required parameters for booking slots calculation"
+        );
+      }
+      if (endDate <= startDate) {
+        throw new Error("End date must be after start date");
+      }
+      const getAvailableBookingSlotsFunction = (0, import_functions.httpsCallable)(
+        this.functions,
+        "getAvailableBookingSlots"
+      );
+      const result = await getAvailableBookingSlotsFunction({
+        clinicId,
+        practitionerId,
+        procedureId,
+        timeframe: {
+          start: startDate.getTime(),
+          // Convert to timestamp
+          end: endDate.getTime()
+        }
+      });
+      const response = result.data;
+      if (!response.success) {
+        throw new Error(
+          response.error || "Failed to get available booking slots"
+        );
+      }
+      const slots = response.availableSlots.map((slot) => ({
+        start: new Date(slot.start)
+      }));
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${slots.length} available booking slots`
+      );
+      return slots;
+    } catch (error) {
+      console.error(
+        "[APPOINTMENT_SERVICE] Error getting available booking slots:",
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Creates a new appointment.
+   *
+   * @param data Data needed to create the appointment
+   * @returns The created appointment
+   */
+  async createAppointment(data) {
+    try {
+      console.log("[APPOINTMENT_SERVICE] Creating appointment");
+      const validatedData = await createAppointmentSchema.parseAsync(data);
+      const aggregatedInfo = await fetchAggregatedInfoUtil(
+        this.db,
+        validatedData.clinicBranchId,
+        validatedData.practitionerId,
+        validatedData.patientId,
+        validatedData.procedureId
+      );
+      const appointment = await createAppointmentUtil2(
+        this.db,
+        validatedData,
+        aggregatedInfo,
+        this.generateId.bind(this)
+      );
+      console.log(
+        `[APPOINTMENT_SERVICE] Appointment created with ID: ${appointment.id}`
+      );
+      return appointment;
+    } catch (error) {
+      console.error("[APPOINTMENT_SERVICE] Error creating appointment:", error);
+      throw error;
+    }
+  }
+  /**
+   * Gets an appointment by ID.
+   *
+   * @param appointmentId ID of the appointment to retrieve
+   * @returns The appointment or null if not found
+   */
+  async getAppointmentById(appointmentId) {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting appointment with ID: ${appointmentId}`
+      );
+      const appointment = await getAppointmentByIdUtil(this.db, appointmentId);
+      console.log(
+        `[APPOINTMENT_SERVICE] Appointment ${appointmentId} ${appointment ? "found" : "not found"}`
+      );
+      return appointment;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting appointment ${appointmentId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates an existing appointment.
+   *
+   * @param appointmentId ID of the appointment to update
+   * @param data Update data for the appointment
+   * @returns The updated appointment
+   */
+  async updateAppointment(appointmentId, data) {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating appointment with ID: ${appointmentId}`
+      );
+      const validatedData = await updateAppointmentSchema.parseAsync(data);
+      const updatedAppointment = await updateAppointmentUtil2(
+        this.db,
+        appointmentId,
+        validatedData
+      );
+      console.log(
+        `[APPOINTMENT_SERVICE] Appointment ${appointmentId} updated successfully`
+      );
+      return updatedAppointment;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error updating appointment ${appointmentId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Searches for appointments based on various criteria.
+   *
+   * @param params Search parameters
+   * @returns Found appointments and the last document for pagination
+   */
+  async searchAppointments(params) {
+    try {
+      console.log(
+        "[APPOINTMENT_SERVICE] Searching appointments with params:",
+        params
+      );
+      await searchAppointmentsSchema.parseAsync(params);
+      const result = await searchAppointmentsUtil(this.db, params);
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${result.appointments.length} appointments`
+      );
+      return result;
+    } catch (error) {
+      console.error(
+        "[APPOINTMENT_SERVICE] Error searching appointments:",
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Gets appointments for a specific patient.
+   *
+   * @param patientId ID of the patient
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getPatientAppointments(patientId, options) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Getting appointments for patient: ${patientId}`
+    );
+    const searchParams = {
+      patientId,
+      startDate: options == null ? void 0 : options.startDate,
+      endDate: options == null ? void 0 : options.endDate,
+      status: options == null ? void 0 : options.status,
+      limit: options == null ? void 0 : options.limit,
+      startAfter: options == null ? void 0 : options.startAfter
+    };
+    return this.searchAppointments(searchParams);
+  }
+  /**
+   * Gets appointments for a specific practitioner.
+   *
+   * @param practitionerId ID of the practitioner
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getPractitionerAppointments(practitionerId, options) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Getting appointments for practitioner: ${practitionerId}`
+    );
+    const searchParams = {
+      practitionerId,
+      startDate: options == null ? void 0 : options.startDate,
+      endDate: options == null ? void 0 : options.endDate,
+      status: options == null ? void 0 : options.status,
+      limit: options == null ? void 0 : options.limit,
+      startAfter: options == null ? void 0 : options.startAfter
+    };
+    return this.searchAppointments(searchParams);
   }
-};
-
-// src/backoffice/services/category.service.ts
-var import_firestore38 = require("firebase/firestore");
-
-// src/backoffice/types/category.types.ts
-var CATEGORIES_COLLECTION = "backoffice_categories";
-
-// src/backoffice/services/category.service.ts
-var CategoryService = class extends BaseService {
+  /**
+   * Gets appointments for a specific clinic.
+   *
+   * @param clinicBranchId ID of the clinic branch
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getClinicAppointments(clinicBranchId, options) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Getting appointments for clinic: ${clinicBranchId}`
+    );
+    const searchParams = {
+      clinicBranchId,
+      practitionerId: options == null ? void 0 : options.practitionerId,
+      startDate: options == null ? void 0 : options.startDate,
+      endDate: options == null ? void 0 : options.endDate,
+      status: options == null ? void 0 : options.status,
+      limit: options == null ? void 0 : options.limit,
+      startAfter: options == null ? void 0 : options.startAfter
+    };
+    return this.searchAppointments(searchParams);
+  }
+  /**
+   * Updates the status of an appointment.
+   *
+   * @param appointmentId ID of the appointment
+   * @param newStatus New status to set
+   * @param cancellationReason Required if canceling the appointment
+   * @param canceledBy Required if canceling the appointment
+   * @returns The updated appointment
+   */
+  async updateAppointmentStatus(appointmentId, newStatus, cancellationReason, canceledBy) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Updating status of appointment ${appointmentId} to ${newStatus}`
+    );
+    const updateData = { status: newStatus };
+    if (newStatus === "canceled_clinic" /* CANCELED_CLINIC */ || newStatus === "canceled_patient" /* CANCELED_PATIENT */) {
+      if (!cancellationReason) {
+        throw new Error(
+          "Cancellation reason is required when canceling an appointment"
+        );
+      }
+      if (!canceledBy) {
+        throw new Error(
+          "Canceled by is required when canceling an appointment"
+        );
+      }
+      updateData.cancellationReason = cancellationReason;
+      updateData.canceledBy = canceledBy;
+    }
+    if (newStatus === "confirmed" /* CONFIRMED */) {
+      updateData.confirmationTime = import_firestore38.Timestamp.now();
+    }
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Confirms an appointment.
+   *
+   * @param appointmentId ID of the appointment to confirm
+   * @returns The confirmed appointment
+   */
+  async confirmAppointment(appointmentId) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Confirming appointment: ${appointmentId}`
+    );
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "confirmed" /* CONFIRMED */
+    );
+  }
+  /**
+   * Cancels an appointment from the clinic side.
+   *
+   * @param appointmentId ID of the appointment to cancel
+   * @param reason Reason for cancellation
+   * @returns The canceled appointment
+   */
+  async cancelAppointmentByClinic(appointmentId, reason) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Canceling appointment by clinic: ${appointmentId}`
+    );
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "canceled_clinic" /* CANCELED_CLINIC */,
+      reason,
+      "clinic"
+    );
+  }
+  /**
+   * Cancels an appointment from the patient side.
+   *
+   * @param appointmentId ID of the appointment to cancel
+   * @param reason Reason for cancellation
+   * @returns The canceled appointment
+   */
+  async cancelAppointmentByPatient(appointmentId, reason) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Canceling appointment by patient: ${appointmentId}`
+    );
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "canceled_patient" /* CANCELED_PATIENT */,
+      reason,
+      "patient"
+    );
+  }
+  /**
+   * Marks an appointment as checked in.
+   *
+   * @param appointmentId ID of the appointment
+   * @returns The updated appointment
+   */
+  async checkInAppointment(appointmentId) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Checking in appointment: ${appointmentId}`
+    );
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "checked_in" /* CHECKED_IN */
+    );
+  }
+  /**
+   * Marks an appointment as in progress.
+   *
+   * @param appointmentId ID of the appointment
+   * @returns The updated appointment
+   */
+  async startAppointment(appointmentId) {
+    console.log(`[APPOINTMENT_SERVICE] Starting appointment: ${appointmentId}`);
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "in_progress" /* IN_PROGRESS */
+    );
+  }
+  /**
+   * Marks an appointment as completed.
+   *
+   * @param appointmentId ID of the appointment
+   * @param actualDurationMinutes Actual duration of the appointment in minutes
+   * @returns The updated appointment
+   */
+  async completeAppointment(appointmentId, actualDurationMinutes) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Completing appointment: ${appointmentId}`
+    );
+    const updateData = {
+      status: "completed" /* COMPLETED */,
+      actualDurationMinutes
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Marks an appointment as no-show.
+   *
+   * @param appointmentId ID of the appointment
+   * @returns The updated appointment
+   */
+  async markNoShow(appointmentId) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Marking appointment as no-show: ${appointmentId}`
+    );
+    return this.updateAppointmentStatus(
+      appointmentId,
+      "no_show" /* NO_SHOW */
+    );
+  }
+  /**
+   * Updates the payment status of an appointment.
+   *
+   * @param appointmentId ID of the appointment
+   * @param paymentStatus New payment status
+   * @param paymentTransactionId Optional transaction ID for the payment
+   * @returns The updated appointment
+   */
+  async updatePaymentStatus(appointmentId, paymentStatus, paymentTransactionId) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Updating payment status of appointment ${appointmentId} to ${paymentStatus}`
+    );
+    const updateData = {
+      paymentStatus,
+      paymentTransactionId: paymentTransactionId || null
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Marks pre-procedure requirements as completed.
+   *
+   * @param appointmentId ID of the appointment
+   * @param requirementIds IDs of the requirements to mark as completed
+   * @returns The updated appointment
+   */
+  async completePreRequirements(appointmentId, requirementIds) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Marking pre-requirements as completed for appointment: ${appointmentId}`
+    );
+    const updateData = {
+      completedPreRequirements: requirementIds
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Marks post-procedure requirements as completed.
+   *
+   * @param appointmentId ID of the appointment
+   * @param requirementIds IDs of the requirements to mark as completed
+   * @returns The updated appointment
+   */
+  async completePostRequirements(appointmentId, requirementIds) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Marking post-requirements as completed for appointment: ${appointmentId}`
+    );
+    const updateData = {
+      completedPostRequirements: requirementIds
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+  /**
+   * Updates the internal notes of an appointment.
+   *
+   * @param appointmentId ID of the appointment
+   * @param notes Updated internal notes
+   * @returns The updated appointment
+   */
+  async updateInternalNotes(appointmentId, notes) {
+    console.log(
+      `[APPOINTMENT_SERVICE] Updating internal notes for appointment: ${appointmentId}`
+    );
+    const updateData = {
+      internalNotes: notes
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+};
+
+// src/backoffice/services/brand.service.ts
+var import_firestore39 = require("firebase/firestore");
+
+// src/backoffice/types/brand.types.ts
+var BRANDS_COLLECTION = "brands";
+
+// src/backoffice/services/brand.service.ts
+var BrandService = class extends BaseService {
+  /**
+   * Gets reference to brands collection
+   */
+  getBrandsRef() {
+    return (0, import_firestore39.collection)(this.db, BRANDS_COLLECTION);
+  }
+  /**
+   * Creates a new brand
+   */
+  async create(brand) {
+    const now = /* @__PURE__ */ new Date();
+    const newBrand = {
+      ...brand,
+      createdAt: now,
+      updatedAt: now,
+      isActive: true
+    };
+    const docRef = await (0, import_firestore39.addDoc)(this.getBrandsRef(), newBrand);
+    return { id: docRef.id, ...newBrand };
+  }
+  /**
+   * Gets all active brands
+   */
+  async getAll() {
+    const q = (0, import_firestore39.query)(this.getBrandsRef(), (0, import_firestore39.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore39.getDocs)(q);
+    return snapshot.docs.map(
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
+      })
+    );
+  }
+  /**
+   * Updates a brand
+   */
+  async update(brandId, brand) {
+    const updateData = {
+      ...brand,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const docRef = (0, import_firestore39.doc)(this.getBrandsRef(), brandId);
+    await (0, import_firestore39.updateDoc)(docRef, updateData);
+    return this.getById(brandId);
+  }
+  /**
+   * Soft deletes a brand
+   */
+  async delete(brandId) {
+    await this.update(brandId, {
+      isActive: false
+    });
+  }
+  /**
+   * Gets a brand by ID
+   */
+  async getById(brandId) {
+    const docRef = (0, import_firestore39.doc)(this.getBrandsRef(), brandId);
+    const docSnap = await (0, import_firestore39.getDoc)(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data()
+    };
+  }
+};
+
+// src/backoffice/services/category.service.ts
+var import_firestore40 = require("firebase/firestore");
+
+// src/backoffice/types/category.types.ts
+var CATEGORIES_COLLECTION = "backoffice_categories";
+
+// src/backoffice/services/category.service.ts
+var CategoryService = class extends BaseService {
   /**
    * Referenca na Firestore kolekciju kategorija
    */
   get categoriesRef() {
-    return (0, import_firestore38.collection)(this.db, CATEGORIES_COLLECTION);
+    return (0, import_firestore40.collection)(this.db, CATEGORIES_COLLECTION);
   }
   /**
    * Kreira novu kategoriju u sistemu
@@ -11388,7 +12319,7 @@ var CategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore38.addDoc)(this.categoriesRef, newCategory);
+    const docRef = await (0, import_firestore40.addDoc)(this.categoriesRef, newCategory);
     return { id: docRef.id, ...newCategory };
   }
   /**
@@ -11396,12 +12327,12 @@ var CategoryService = class extends BaseService {
    * @returns Lista aktivnih kategorija
    */
   async getAll() {
-    const q = (0, import_firestore38.query)(this.categoriesRef, (0, import_firestore38.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore38.getDocs)(q);
+    const q = (0, import_firestore40.query)(this.categoriesRef, (0, import_firestore40.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore40.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11411,16 +12342,16 @@ var CategoryService = class extends BaseService {
    * @returns Lista kategorija koje pripadaju traženoj familiji
    */
   async getAllByFamily(family) {
-    const q = (0, import_firestore38.query)(
+    const q = (0, import_firestore40.query)(
       this.categoriesRef,
-      (0, import_firestore38.where)("family", "==", family),
-      (0, import_firestore38.where)("isActive", "==", true)
+      (0, import_firestore40.where)("family", "==", family),
+      (0, import_firestore40.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore38.getDocs)(q);
+    const snapshot = await (0, import_firestore40.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11435,8 +12366,8 @@ var CategoryService = class extends BaseService {
       ...category,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore38.doc)(this.categoriesRef, id);
-    await (0, import_firestore38.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore40.doc)(this.categoriesRef, id);
+    await (0, import_firestore40.updateDoc)(docRef, updateData);
     return this.getById(id);
   }
   /**
@@ -11452,8 +12383,8 @@ var CategoryService = class extends BaseService {
    * @returns Kategorija ili null ako ne postoji
    */
   async getById(id) {
-    const docRef = (0, import_firestore38.doc)(this.categoriesRef, id);
-    const docSnap = await (0, import_firestore38.getDoc)(docRef);
+    const docRef = (0, import_firestore40.doc)(this.categoriesRef, id);
+    const docSnap = await (0, import_firestore40.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -11463,7 +12394,7 @@ var CategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/subcategory.service.ts
-var import_firestore39 = require("firebase/firestore");
+var import_firestore41 = require("firebase/firestore");
 
 // src/backoffice/types/subcategory.types.ts
 var SUBCATEGORIES_COLLECTION = "subcategories";
@@ -11475,7 +12406,7 @@ var SubcategoryService = class extends BaseService {
    * @param categoryId - ID roditeljske kategorije
    */
   getSubcategoriesRef(categoryId) {
-    return (0, import_firestore39.collection)(
+    return (0, import_firestore41.collection)(
       this.db,
       CATEGORIES_COLLECTION,
       categoryId,
@@ -11497,7 +12428,7 @@ var SubcategoryService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const docRef = await (0, import_firestore39.addDoc)(
+    const docRef = await (0, import_firestore41.addDoc)(
       this.getSubcategoriesRef(categoryId),
       newSubcategory
     );
@@ -11509,15 +12440,15 @@ var SubcategoryService = class extends BaseService {
    * @returns Lista aktivnih podkategorija
    */
   async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore39.query)(
+    const q = (0, import_firestore41.query)(
       this.getSubcategoriesRef(categoryId),
-      (0, import_firestore39.where)("isActive", "==", true)
+      (0, import_firestore41.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore39.getDocs)(q);
+    const snapshot = await (0, import_firestore41.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11533,8 +12464,8 @@ var SubcategoryService = class extends BaseService {
       ...subcategory,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore39.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await (0, import_firestore39.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore41.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    await (0, import_firestore41.updateDoc)(docRef, updateData);
     return this.getById(categoryId, subcategoryId);
   }
   /**
@@ -11552,8 +12483,8 @@ var SubcategoryService = class extends BaseService {
    * @returns Podkategorija ili null ako ne postoji
    */
   async getById(categoryId, subcategoryId) {
-    const docRef = (0, import_firestore39.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await (0, import_firestore39.getDoc)(docRef);
+    const docRef = (0, import_firestore41.doc)(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await (0, import_firestore41.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -11563,12 +12494,7 @@ var SubcategoryService = class extends BaseService {
 };
 
 // src/backoffice/services/technology.service.ts
-var import_firestore40 = require("firebase/firestore");
-
-// src/backoffice/types/technology.types.ts
-var TECHNOLOGIES_COLLECTION = "technologies";
-
-// src/backoffice/services/technology.service.ts
+var import_firestore42 = require("firebase/firestore");
 var DEFAULT_CERTIFICATION_REQUIREMENT = {
   minimumLevel: "aesthetician" /* AESTHETICIAN */,
   requiredSpecialties: []
@@ -11578,7 +12504,7 @@ var TechnologyService = class extends BaseService {
    * Vraća referencu na Firestore kolekciju tehnologija
    */
   getTechnologiesRef() {
-    return (0, import_firestore40.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    return (0, import_firestore42.collection)(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
    * Kreira novu tehnologiju
@@ -11601,7 +12527,7 @@ var TechnologyService = class extends BaseService {
       benefits: technology.benefits || [],
       certificationRequirement: technology.certificationRequirement || DEFAULT_CERTIFICATION_REQUIREMENT
     };
-    const docRef = await (0, import_firestore40.addDoc)(this.getTechnologiesRef(), newTechnology);
+    const docRef = await (0, import_firestore42.addDoc)(this.getTechnologiesRef(), newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
   /**
@@ -11609,12 +12535,12 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAll() {
-    const q = (0, import_firestore40.query)(this.getTechnologiesRef(), (0, import_firestore40.where)("isActive", "==", true));
-    const snapshot = await (0, import_firestore40.getDocs)(q);
+    const q = (0, import_firestore42.query)(this.getTechnologiesRef(), (0, import_firestore42.where)("isActive", "==", true));
+    const snapshot = await (0, import_firestore42.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11624,16 +12550,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByFamily(family) {
-    const q = (0, import_firestore40.query)(
+    const q = (0, import_firestore42.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore40.where)("isActive", "==", true),
-      (0, import_firestore40.where)("family", "==", family)
+      (0, import_firestore42.where)("isActive", "==", true),
+      (0, import_firestore42.where)("family", "==", family)
     );
-    const snapshot = await (0, import_firestore40.getDocs)(q);
+    const snapshot = await (0, import_firestore42.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11643,16 +12569,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByCategoryId(categoryId) {
-    const q = (0, import_firestore40.query)(
+    const q = (0, import_firestore42.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore40.where)("isActive", "==", true),
-      (0, import_firestore40.where)("categoryId", "==", categoryId)
+      (0, import_firestore42.where)("isActive", "==", true),
+      (0, import_firestore42.where)("categoryId", "==", categoryId)
     );
-    const snapshot = await (0, import_firestore40.getDocs)(q);
+    const snapshot = await (0, import_firestore42.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11662,16 +12588,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllBySubcategoryId(subcategoryId) {
-    const q = (0, import_firestore40.query)(
+    const q = (0, import_firestore42.query)(
       this.getTechnologiesRef(),
-      (0, import_firestore40.where)("isActive", "==", true),
-      (0, import_firestore40.where)("subcategoryId", "==", subcategoryId)
+      (0, import_firestore42.where)("isActive", "==", true),
+      (0, import_firestore42.where)("subcategoryId", "==", subcategoryId)
     );
-    const snapshot = await (0, import_firestore40.getDocs)(q);
+    const snapshot = await (0, import_firestore42.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11686,8 +12612,8 @@ var TechnologyService = class extends BaseService {
       ...technology,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, updateData);
     return this.getById(technologyId);
   }
   /**
@@ -11705,8 +12631,8 @@ var TechnologyService = class extends BaseService {
    * @returns Tehnologija ili null ako ne postoji
    */
   async getById(technologyId) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    const docSnap = await (0, import_firestore40.getDoc)(docRef);
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    const docSnap = await (0, import_firestore42.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -11720,10 +12646,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore40.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore40.arrayUnion)(requirement),
+    await (0, import_firestore42.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore42.arrayUnion)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11735,10 +12661,10 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId, requirement) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await (0, import_firestore40.updateDoc)(docRef, {
-      [requirementType]: (0, import_firestore40.arrayRemove)(requirement),
+    await (0, import_firestore42.updateDoc)(docRef, {
+      [requirementType]: (0, import_firestore42.arrayRemove)(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11775,9 +12701,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore40.arrayUnion)(condition),
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore42.arrayUnion)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11789,9 +12715,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(technologyId, condition) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
-      blockingConditions: (0, import_firestore40.arrayRemove)(condition),
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
+      blockingConditions: (0, import_firestore42.arrayRemove)(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11803,9 +12729,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
-      contraindications: (0, import_firestore40.arrayUnion)(contraindication),
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
+      contraindications: (0, import_firestore42.arrayUnion)(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11817,9 +12743,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(technologyId, contraindication) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
-      contraindications: (0, import_firestore40.arrayRemove)(contraindication),
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
+      contraindications: (0, import_firestore42.arrayRemove)(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11831,9 +12757,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
-      benefits: (0, import_firestore40.arrayUnion)(benefit),
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
+      benefits: (0, import_firestore42.arrayUnion)(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11845,9 +12771,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBenefit(technologyId, benefit) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
-      benefits: (0, import_firestore40.arrayRemove)(benefit),
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
+      benefits: (0, import_firestore42.arrayRemove)(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
     return this.getById(technologyId);
@@ -11886,8 +12812,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = (0, import_firestore40.doc)(this.getTechnologiesRef(), technologyId);
-    await (0, import_firestore40.updateDoc)(docRef, {
+    const docRef = (0, import_firestore42.doc)(this.getTechnologiesRef(), technologyId);
+    await (0, import_firestore42.updateDoc)(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11987,7 +12913,7 @@ var TechnologyService = class extends BaseService {
 };
 
 // src/backoffice/services/product.service.ts
-var import_firestore41 = require("firebase/firestore");
+var import_firestore43 = require("firebase/firestore");
 
 // src/backoffice/types/product.types.ts
 var PRODUCTS_COLLECTION = "products";
@@ -12000,7 +12926,7 @@ var ProductService = class extends BaseService {
    * @returns Firestore collection reference
    */
   getProductsRef(technologyId) {
-    return (0, import_firestore41.collection)(
+    return (0, import_firestore43.collection)(
       this.db,
       TECHNOLOGIES_COLLECTION,
       technologyId,
@@ -12020,7 +12946,7 @@ var ProductService = class extends BaseService {
       updatedAt: now,
       isActive: true
     };
-    const productRef = await (0, import_firestore41.addDoc)(
+    const productRef = await (0, import_firestore43.addDoc)(
       this.getProductsRef(technologyId),
       newProduct
     );
@@ -12030,15 +12956,15 @@ var ProductService = class extends BaseService {
    * Gets all products for a technology
    */
   async getAllByTechnology(technologyId) {
-    const q = (0, import_firestore41.query)(
+    const q = (0, import_firestore43.query)(
       this.getProductsRef(technologyId),
-      (0, import_firestore41.where)("isActive", "==", true)
+      (0, import_firestore43.where)("isActive", "==", true)
     );
-    const snapshot = await (0, import_firestore41.getDocs)(q);
+    const snapshot = await (0, import_firestore43.getDocs)(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -12046,21 +12972,21 @@ var ProductService = class extends BaseService {
    * Gets all products for a brand by filtering through all technologies
    */
   async getAllByBrand(brandId) {
-    const allTechnologiesRef = (0, import_firestore41.collection)(this.db, TECHNOLOGIES_COLLECTION);
-    const technologiesSnapshot = await (0, import_firestore41.getDocs)(allTechnologiesRef);
+    const allTechnologiesRef = (0, import_firestore43.collection)(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await (0, import_firestore43.getDocs)(allTechnologiesRef);
     const products = [];
     for (const techDoc of technologiesSnapshot.docs) {
-      const q = (0, import_firestore41.query)(
+      const q = (0, import_firestore43.query)(
         this.getProductsRef(techDoc.id),
-        (0, import_firestore41.where)("brandId", "==", brandId),
-        (0, import_firestore41.where)("isActive", "==", true)
+        (0, import_firestore43.where)("brandId", "==", brandId),
+        (0, import_firestore43.where)("isActive", "==", true)
       );
-      const snapshot = await (0, import_firestore41.getDocs)(q);
+      const snapshot = await (0, import_firestore43.getDocs)(q);
       products.push(
         ...snapshot.docs.map(
-          (doc29) => ({
-            id: doc29.id,
-            ...doc29.data()
+          (doc30) => ({
+            id: doc30.id,
+            ...doc30.data()
           })
         )
       );
@@ -12075,8 +13001,8 @@ var ProductService = class extends BaseService {
       ...product,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = (0, import_firestore41.doc)(this.getProductsRef(technologyId), productId);
-    await (0, import_firestore41.updateDoc)(docRef, updateData);
+    const docRef = (0, import_firestore43.doc)(this.getProductsRef(technologyId), productId);
+    await (0, import_firestore43.updateDoc)(docRef, updateData);
     return this.getById(technologyId, productId);
   }
   /**
@@ -12091,8 +13017,8 @@ var ProductService = class extends BaseService {
    * Gets a product by ID
    */
   async getById(technologyId, productId) {
-    const docRef = (0, import_firestore41.doc)(this.getProductsRef(technologyId), productId);
-    const docSnap = await (0, import_firestore41.getDoc)(docRef);
+    const docRef = (0, import_firestore43.doc)(this.getProductsRef(technologyId), productId);
+    const docSnap = await (0, import_firestore43.getDoc)(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -12102,54 +13028,54 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-var import_zod22 = require("zod");
-var baseNotificationSchema = import_zod22.z.object({
-  id: import_zod22.z.string().optional(),
-  userId: import_zod22.z.string(),
-  notificationTime: import_zod22.z.any(),
+var import_zod23 = require("zod");
+var baseNotificationSchema = import_zod23.z.object({
+  id: import_zod23.z.string().optional(),
+  userId: import_zod23.z.string(),
+  notificationTime: import_zod23.z.any(),
   // Timestamp
-  notificationType: import_zod22.z.nativeEnum(NotificationType),
-  notificationTokens: import_zod22.z.array(import_zod22.z.string()),
-  status: import_zod22.z.nativeEnum(NotificationStatus),
-  createdAt: import_zod22.z.any().optional(),
+  notificationType: import_zod23.z.nativeEnum(NotificationType),
+  notificationTokens: import_zod23.z.array(import_zod23.z.string()),
+  status: import_zod23.z.nativeEnum(NotificationStatus),
+  createdAt: import_zod23.z.any().optional(),
   // Timestamp
-  updatedAt: import_zod22.z.any().optional(),
+  updatedAt: import_zod23.z.any().optional(),
   // Timestamp
-  title: import_zod22.z.string(),
-  body: import_zod22.z.string(),
-  isRead: import_zod22.z.boolean(),
-  userRole: import_zod22.z.nativeEnum(UserRole)
+  title: import_zod23.z.string(),
+  body: import_zod23.z.string(),
+  isRead: import_zod23.z.boolean(),
+  userRole: import_zod23.z.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod22.z.literal("preRequirement" /* PRE_REQUIREMENT */),
-  treatmentId: import_zod22.z.string(),
-  requirements: import_zod22.z.array(import_zod22.z.string()),
-  deadline: import_zod22.z.any()
+  notificationType: import_zod23.z.literal("preRequirement" /* PRE_REQUIREMENT */),
+  treatmentId: import_zod23.z.string(),
+  requirements: import_zod23.z.array(import_zod23.z.string()),
+  deadline: import_zod23.z.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod22.z.literal("postRequirement" /* POST_REQUIREMENT */),
-  treatmentId: import_zod22.z.string(),
-  requirements: import_zod22.z.array(import_zod22.z.string()),
-  deadline: import_zod22.z.any()
+  notificationType: import_zod23.z.literal("postRequirement" /* POST_REQUIREMENT */),
+  treatmentId: import_zod23.z.string(),
+  requirements: import_zod23.z.array(import_zod23.z.string()),
+  deadline: import_zod23.z.any()
   // Timestamp
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod22.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: import_zod22.z.string(),
-  appointmentTime: import_zod22.z.any(),
+  notificationType: import_zod23.z.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: import_zod23.z.string(),
+  appointmentTime: import_zod23.z.any(),
   // Timestamp
-  treatmentType: import_zod22.z.string(),
-  doctorName: import_zod22.z.string()
+  treatmentType: import_zod23.z.string(),
+  doctorName: import_zod23.z.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: import_zod22.z.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
-  appointmentId: import_zod22.z.string(),
-  appointmentStatus: import_zod22.z.string(),
-  previousStatus: import_zod22.z.string(),
-  reason: import_zod22.z.string().optional()
+  notificationType: import_zod23.z.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  appointmentId: import_zod23.z.string(),
+  appointmentStatus: import_zod23.z.string(),
+  previousStatus: import_zod23.z.string(),
+  reason: import_zod23.z.string().optional()
 });
-var notificationSchema = import_zod22.z.discriminatedUnion("notificationType", [
+var notificationSchema = import_zod23.z.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   appointmentReminderNotificationSchema,
@@ -12189,9 +13115,12 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
 })(RequirementType || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APPOINTMENTS_COLLECTION,
   AUTH_ERRORS,
   AdminTokenStatus,
   AllergyType,
+  AppointmentService,
+  AppointmentStatus,
   AuthService,
   BlockingCondition,
   BrandService,
@@ -12241,6 +13170,7 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   PRACTITIONERS_COLLECTION,
   PROCEDURES_COLLECTION,
   PatientService,
+  PaymentStatus,
   PracticeType,
   PractitionerService,
   PractitionerStatus,
@@ -12355,6 +13285,7 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   procedureSummaryInfoSchema,
   requesterInfoSchema,
   reviewSchema,
+  searchAppointmentsSchema,
   searchPatientsSchema,
   syncedCalendarEventSchema,
   timeSlotSchema,