@blackcode_sa/metaestetics-api 1.5.34 → 1.5.36

package/dist/index.mjs

@@ -1,3 +1,106 @@
+// src/validations/appointment.schema.ts
+import { z } from "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 = z.object({
+  calendarEventId: z.string().min(1, "Calendar event ID is required"),
+  clinicBranchId: z.string().min(1, "Clinic branch ID is required"),
+  practitionerId: z.string().min(1, "Practitioner ID is required"),
+  patientId: z.string().min(1, "Patient ID is required"),
+  procedureId: z.string().min(1, "Procedure ID is required"),
+  appointmentStartTime: z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
+    "Appointment start time must be a valid timestamp"
+  ),
+  appointmentEndTime: z.any().refine(
+    (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0,
+    "Appointment end time must be a valid timestamp"
+  ),
+  cost: z.number().min(0, "Cost must be a non-negative number"),
+  currency: z.string().min(1, "Currency is required"),
+  patientNotes: z.string().nullable().optional(),
+  initialStatus: z.nativeEnum(AppointmentStatus, {
+    errorMap: () => ({ message: "Invalid appointment status" })
+  }),
+  initialPaymentStatus: z.nativeEnum(PaymentStatus, {
+    errorMap: () => ({ message: "Invalid payment status" })
+  }).optional().default("unpaid" /* UNPAID */)
+});
+var updateAppointmentSchema = z.object({
+  status: z.nativeEnum(AppointmentStatus, {
+    errorMap: () => ({ message: "Invalid appointment status" })
+  }).optional(),
+  confirmationTime: 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: z.number().positive("Duration must be positive").optional(),
+  cancellationReason: z.string().nullable().optional(),
+  canceledBy: z.enum(["patient", "clinic", "practitioner", "system"]).optional(),
+  internalNotes: z.string().nullable().optional(),
+  paymentStatus: z.nativeEnum(PaymentStatus, {
+    errorMap: () => ({ message: "Invalid payment status" })
+  }).optional(),
+  paymentTransactionId: z.string().nullable().optional(),
+  completedPreRequirements: z.array(z.string()).optional(),
+  completedPostRequirements: z.array(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 = z.object({
+  patientId: z.string().optional(),
+  practitionerId: z.string().optional(),
+  clinicBranchId: z.string().optional(),
+  startDate: z.date().optional(),
+  endDate: z.date().optional(),
+  status: z.union([
+    z.nativeEnum(AppointmentStatus),
+    z.array(z.nativeEnum(AppointmentStatus))
+  ]).optional(),
+  limit: z.number().positive().optional(),
+  startAfter: 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
 import { initializeApp } from "firebase/app";
 import { getFirestore } from "firebase/firestore";
@@ -152,86 +255,86 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 var USERS_COLLECTION = "users";
 
 // src/services/auth.service.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/validations/schemas.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/validations/documentation-templates/template.schema.ts
-import { z } from "zod";
-var baseElementSchema = z.object({
-  id: z.string().optional(),
+import { z as z2 } from "zod";
+var baseElementSchema = z2.object({
+  id: z2.string().optional(),
   // Make id optional so we can omit it later
-  type: z.nativeEnum(DocumentElementType),
-  required: z.boolean().optional()
+  type: z2.nativeEnum(DocumentElementType),
+  required: z2.boolean().optional()
 });
 var headingElementSchema = baseElementSchema.extend({
-  type: z.literal("heading" /* HEADING */),
-  text: z.string().min(1).max(200),
-  level: z.nativeEnum(HeadingLevel)
+  type: z2.literal("heading" /* HEADING */),
+  text: z2.string().min(1).max(200),
+  level: z2.nativeEnum(HeadingLevel)
 });
 var paragraphElementSchema = baseElementSchema.extend({
-  type: z.literal("paragraph" /* PARAGRAPH */),
-  text: z.string().min(1).max(5e3)
+  type: z2.literal("paragraph" /* PARAGRAPH */),
+  text: z2.string().min(1).max(5e3)
 });
 var listElementSchema = baseElementSchema.extend({
-  type: z.literal("list" /* LIST */),
-  items: z.array(z.string().min(1).max(500)).min(1).max(100),
-  listType: z.nativeEnum(ListType)
+  type: z2.literal("list" /* LIST */),
+  items: z2.array(z2.string().min(1).max(500)).min(1).max(100),
+  listType: z2.nativeEnum(ListType)
 });
 var dynamicTextElementSchema = baseElementSchema.extend({
-  type: z.literal("dynamic_text" /* DYNAMIC_TEXT */),
-  text: z.string().min(1).max(5e3)
+  type: z2.literal("dynamic_text" /* DYNAMIC_TEXT */),
+  text: z2.string().min(1).max(5e3)
 });
 var binaryChoiceElementSchema = baseElementSchema.extend({
-  type: z.literal("binary_choice" /* BINARY_CHOICE */),
-  question: z.string().min(1).max(500),
-  defaultValue: z.boolean().optional()
+  type: z2.literal("binary_choice" /* BINARY_CHOICE */),
+  question: z2.string().min(1).max(500),
+  defaultValue: z2.boolean().optional()
 });
 var multipleChoiceElementSchema = baseElementSchema.extend({
-  type: z.literal("multiple_choice" /* MULTIPLE_CHOICE */),
-  question: z.string().min(1).max(500),
-  options: z.array(z.string().min(1).max(200)).min(2).max(50),
-  defaultValues: z.array(z.string()).optional()
+  type: z2.literal("multiple_choice" /* MULTIPLE_CHOICE */),
+  question: z2.string().min(1).max(500),
+  options: z2.array(z2.string().min(1).max(200)).min(2).max(50),
+  defaultValues: z2.array(z2.string()).optional()
 });
 var singleChoiceElementSchema = baseElementSchema.extend({
-  type: z.literal("single_choice" /* SINGLE_CHOICE */),
-  question: z.string().min(1).max(500),
-  options: z.array(z.string().min(1).max(200)).min(2).max(50),
-  defaultValue: z.string().optional()
+  type: z2.literal("single_choice" /* SINGLE_CHOICE */),
+  question: z2.string().min(1).max(500),
+  options: z2.array(z2.string().min(1).max(200)).min(2).max(50),
+  defaultValue: z2.string().optional()
 });
 var ratingScaleElementSchema = baseElementSchema.extend({
-  type: z.literal("rating_scale" /* RATING_SCALE */),
-  question: z.string().min(1).max(500),
-  min: z.number().int().min(0).max(10),
-  max: z.number().int().min(1).max(10),
-  labels: z.record(z.string()).optional(),
-  defaultValue: z.number().int().optional()
+  type: z2.literal("rating_scale" /* RATING_SCALE */),
+  question: z2.string().min(1).max(500),
+  min: z2.number().int().min(0).max(10),
+  max: z2.number().int().min(1).max(10),
+  labels: z2.record(z2.string()).optional(),
+  defaultValue: z2.number().int().optional()
 });
 var textInputElementSchema = baseElementSchema.extend({
-  type: z.literal("text_input" /* TEXT_INPUT */),
-  label: z.string().min(1).max(200),
-  placeholder: z.string().max(200).optional(),
-  multiline: z.boolean().optional(),
-  defaultValue: z.string().optional()
+  type: z2.literal("text_input" /* TEXT_INPUT */),
+  label: z2.string().min(1).max(200),
+  placeholder: z2.string().max(200).optional(),
+  multiline: z2.boolean().optional(),
+  defaultValue: z2.string().optional()
 });
 var datePickerElementSchema = baseElementSchema.extend({
-  type: z.literal("date_picker" /* DATE_PICKER */),
-  label: z.string().min(1).max(200),
-  defaultValue: z.string().optional()
+  type: z2.literal("date_picker" /* DATE_PICKER */),
+  label: z2.string().min(1).max(200),
+  defaultValue: z2.string().optional()
   // ISO date string
 });
 var signatureElementSchema = baseElementSchema.extend({
-  type: z.literal("signature" /* SIGNATURE */),
-  label: z.string().min(1).max(200)
+  type: z2.literal("signature" /* SIGNATURE */),
+  label: z2.string().min(1).max(200)
 });
 var fileUploadElementSchema = baseElementSchema.extend({
-  type: z.literal("file_upload" /* FILE_UPLOAD */),
-  label: z.string().min(1).max(200),
-  allowedFileTypes: z.array(z.string()).optional(),
-  maxFileSizeMB: z.number().positive().optional()
+  type: z2.literal("file_upload" /* FILE_UPLOAD */),
+  label: z2.string().min(1).max(200),
+  allowedFileTypes: z2.array(z2.string()).optional(),
+  maxFileSizeMB: z2.number().positive().optional()
 });
-var documentElementSchema = z.discriminatedUnion("type", [
+var documentElementSchema = z2.discriminatedUnion("type", [
   headingElementSchema,
   paragraphElementSchema,
   listElementSchema,
@@ -245,7 +348,7 @@ var documentElementSchema = z.discriminatedUnion("type", [
   signatureElementSchema,
   fileUploadElementSchema
 ]);
-var documentElementWithoutIdSchema = z.discriminatedUnion("type", [
+var documentElementWithoutIdSchema = z2.discriminatedUnion("type", [
   headingElementSchema.omit({ id: true }),
   paragraphElementSchema.omit({ id: true }),
   listElementSchema.omit({ id: true }),
@@ -259,50 +362,50 @@ var documentElementWithoutIdSchema = z.discriminatedUnion("type", [
   signatureElementSchema.omit({ id: true }),
   fileUploadElementSchema.omit({ id: true })
 ]);
-var createDocumentTemplateSchema = z.object({
-  title: z.string().min(1).max(200),
-  description: z.string().max(1e3).optional(),
-  elements: z.array(documentElementWithoutIdSchema).min(1).max(100),
-  tags: z.array(z.string().min(1).max(50)).max(20).optional()
+var createDocumentTemplateSchema = z2.object({
+  title: z2.string().min(1).max(200),
+  description: z2.string().max(1e3).optional(),
+  elements: z2.array(documentElementWithoutIdSchema).min(1).max(100),
+  tags: z2.array(z2.string().min(1).max(50)).max(20).optional()
 });
-var updateDocumentTemplateSchema = z.object({
-  title: z.string().min(1).max(200).optional(),
-  description: z.string().max(1e3).optional(),
-  elements: z.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
-  tags: z.array(z.string().min(1).max(50)).max(20).optional(),
-  isActive: z.boolean().optional()
+var updateDocumentTemplateSchema = z2.object({
+  title: z2.string().min(1).max(200).optional(),
+  description: z2.string().max(1e3).optional(),
+  elements: z2.array(documentElementWithoutIdSchema).min(1).max(100).optional(),
+  tags: z2.array(z2.string().min(1).max(50)).max(20).optional(),
+  isActive: z2.boolean().optional()
 });
-var documentTemplateSchema = z.object({
-  id: z.string(),
-  title: z.string().min(1).max(200),
-  description: z.string().max(1e3).optional(),
-  createdAt: z.number(),
-  updatedAt: z.number(),
-  createdBy: z.string(),
-  elements: z.array(documentElementSchema),
-  tags: z.array(z.string().min(1).max(50)).max(20).optional(),
-  version: z.number().int().positive(),
-  isActive: z.boolean()
+var documentTemplateSchema = z2.object({
+  id: z2.string(),
+  title: z2.string().min(1).max(200),
+  description: z2.string().max(1e3).optional(),
+  createdAt: z2.number(),
+  updatedAt: z2.number(),
+  createdBy: z2.string(),
+  elements: z2.array(documentElementSchema),
+  tags: z2.array(z2.string().min(1).max(50)).max(20).optional(),
+  version: z2.number().int().positive(),
+  isActive: z2.boolean()
 });
 
 // src/validations/schemas.ts
-var emailSchema = z2.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 = z2.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
+var emailSchema = z3.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 = z3.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 = z2.nativeEnum(UserRole);
-var userRolesSchema = z2.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = z2.custom((data) => {
+var userRoleSchema = z3.nativeEnum(UserRole);
+var userRolesSchema = z3.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
+var timestampSchema = z3.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 = z2.object({
-  isGroupOwner: z2.boolean(),
-  groupToken: z2.string().optional(),
-  groupId: z2.string().optional()
+var clinicAdminOptionsSchema = z3.object({
+  isGroupOwner: z3.boolean(),
+  groupToken: z3.string().optional(),
+  groupId: z3.string().optional()
 }).refine(
   (data) => {
     if (!data.isGroupOwner && (!data.groupToken || !data.groupId)) {
@@ -317,20 +420,20 @@ var clinicAdminOptionsSchema = z2.object({
     message: "Invalid clinic admin options configuration"
   }
 );
-var createUserOptionsSchema = z2.object({
+var createUserOptionsSchema = z3.object({
   clinicAdminData: clinicAdminOptionsSchema.optional()
 });
-var userSchema = z2.object({
-  uid: z2.string(),
-  email: z2.string().email().nullable(),
-  roles: z2.array(userRoleSchema),
-  isAnonymous: z2.boolean(),
+var userSchema = z3.object({
+  uid: z3.string(),
+  email: z3.string().email().nullable(),
+  roles: z3.array(userRoleSchema),
+  isAnonymous: z3.boolean(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema,
   lastLoginAt: timestampSchema,
-  patientProfile: z2.string().optional(),
-  practitionerProfile: z2.string().optional(),
-  adminProfile: z2.string().optional()
+  patientProfile: z3.string().optional(),
+  practitionerProfile: z3.string().optional(),
+  adminProfile: z3.string().optional()
 });
 
 // src/errors/auth.errors.ts
@@ -689,7 +792,7 @@ var USER_ERRORS = {
 };
 
 // src/services/user.service.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/services/patient/patient.service.ts
 import {
@@ -717,7 +820,7 @@ import {
   doc as doc3
 } from "firebase/firestore";
 import { ref, uploadBytes, getDownloadURL, deleteObject } from "firebase/storage";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/types/patient/medical-info.types.ts
 var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
@@ -746,11 +849,11 @@ var Gender = /* @__PURE__ */ ((Gender2) => {
 })(Gender || {});
 
 // src/validations/patient.schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { Timestamp } from "firebase/firestore";
 
 // src/validations/patient/medical-info.schema.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/types/patient/allergies.ts
 var AllergyType = /* @__PURE__ */ ((AllergyType2) => {
@@ -839,71 +942,71 @@ var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
 })(Contraindication || {});
 
 // src/validations/common.schema.ts
-import { z as z3 } from "zod";
-var timestampSchema2 = z3.object({
-  seconds: z3.number(),
-  nanoseconds: z3.number()
+import { z as z4 } from "zod";
+var timestampSchema2 = z4.object({
+  seconds: z4.number(),
+  nanoseconds: z4.number()
 });
 
 // src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = z4.union([
-  z4.nativeEnum(MedicationAllergySubtype),
-  z4.nativeEnum(FoodAllergySubtype),
-  z4.nativeEnum(EnvironmentalAllergySubtype),
-  z4.nativeEnum(CosmeticAllergySubtype),
-  z4.literal("other")
+var allergySubtypeSchema = z5.union([
+  z5.nativeEnum(MedicationAllergySubtype),
+  z5.nativeEnum(FoodAllergySubtype),
+  z5.nativeEnum(EnvironmentalAllergySubtype),
+  z5.nativeEnum(CosmeticAllergySubtype),
+  z5.literal("other")
 ]);
-var allergySchema = z4.object({
-  type: z4.nativeEnum(AllergyType),
+var allergySchema = z5.object({
+  type: z5.nativeEnum(AllergyType),
   subtype: allergySubtypeSchema,
-  name: z4.string().optional(),
-  severity: z4.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: z4.string().optional(),
+  name: z5.string().optional(),
+  severity: z5.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: z5.string().optional(),
   diagnosed: timestampSchema2.optional(),
-  notes: z4.string().optional()
+  notes: z5.string().optional()
 });
-var vitalStatsSchema = z4.object({
-  height: z4.number().positive().optional(),
-  weight: z4.number().positive().optional(),
-  bloodType: z4.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: z4.object({
-    systolic: z4.number().min(70).max(200),
-    diastolic: z4.number().min(40).max(130),
+var vitalStatsSchema = z5.object({
+  height: z5.number().positive().optional(),
+  weight: z5.number().positive().optional(),
+  bloodType: z5.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: z5.object({
+    systolic: z5.number().min(70).max(200),
+    diastolic: z5.number().min(40).max(130),
     lastMeasured: timestampSchema2
   }).optional()
 });
-var blockingConditionSchema = z4.object({
-  condition: z4.nativeEnum(BlockingCondition),
+var blockingConditionSchema = z5.object({
+  condition: z5.nativeEnum(BlockingCondition),
   diagnosedAt: timestampSchema2,
-  notes: z4.string().optional(),
-  isActive: z4.boolean()
+  notes: z5.string().optional(),
+  isActive: z5.boolean()
 });
-var contraindicationSchema = z4.object({
-  condition: z4.nativeEnum(Contraindication),
+var contraindicationSchema = z5.object({
+  condition: z5.nativeEnum(Contraindication),
   lastOccurrence: timestampSchema2,
-  frequency: z4.enum(["rare", "occasional", "frequent"]),
-  notes: z4.string().optional(),
-  isActive: z4.boolean()
+  frequency: z5.enum(["rare", "occasional", "frequent"]),
+  notes: z5.string().optional(),
+  isActive: z5.boolean()
 });
-var medicationSchema = z4.object({
-  name: z4.string().min(1),
-  dosage: z4.string().min(1),
-  frequency: z4.string().min(1),
+var medicationSchema = z5.object({
+  name: z5.string().min(1),
+  dosage: z5.string().min(1),
+  frequency: z5.string().min(1),
   startDate: timestampSchema2,
   endDate: timestampSchema2.optional(),
-  prescribedBy: z4.string().optional()
+  prescribedBy: z5.string().optional()
 });
-var patientMedicalInfoSchema = z4.object({
-  patientId: z4.string(),
+var patientMedicalInfoSchema = z5.object({
+  patientId: z5.string(),
   vitalStats: vitalStatsSchema,
-  blockingConditions: z4.array(blockingConditionSchema),
-  contraindications: z4.array(contraindicationSchema),
-  allergies: z4.array(allergySchema),
-  currentMedications: z4.array(medicationSchema),
-  emergencyNotes: z4.string().optional(),
+  blockingConditions: z5.array(blockingConditionSchema),
+  contraindications: z5.array(contraindicationSchema),
+  allergies: z5.array(allergySchema),
+  currentMedications: z5.array(medicationSchema),
+  emergencyNotes: z5.string().optional(),
   lastUpdated: timestampSchema2,
-  updatedBy: z4.string(),
-  verifiedBy: z4.string().optional(),
+  updatedBy: z5.string(),
+  verifiedBy: z5.string().optional(),
   verifiedAt: timestampSchema2.optional()
 });
 var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
@@ -917,141 +1020,141 @@ var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
 var updateVitalStatsSchema = vitalStatsSchema;
 var addAllergySchema = allergySchema;
 var updateAllergySchema = allergySchema.partial().extend({
-  allergyIndex: z4.number().min(0)
+  allergyIndex: z5.number().min(0)
 });
 var addBlockingConditionSchema = blockingConditionSchema;
 var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: z4.number().min(0)
+  conditionIndex: z5.number().min(0)
 });
 var addContraindicationSchema = contraindicationSchema;
 var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: z4.number().min(0)
+  contraindicationIndex: z5.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
 var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: z4.number().min(0)
+  medicationIndex: z5.number().min(0)
 });
 
 // src/validations/patient.schema.ts
-var locationDataSchema = z5.object({
-  latitude: z5.number().min(-90).max(90),
-  longitude: z5.number().min(-180).max(180),
-  geohash: z5.string().optional()
+var locationDataSchema = z6.object({
+  latitude: z6.number().min(-90).max(90),
+  longitude: z6.number().min(-180).max(180),
+  geohash: z6.string().optional()
 });
-var addressDataSchema = z5.object({
-  address: z5.string(),
-  city: z5.string(),
-  country: z5.string(),
-  postalCode: z5.string()
+var addressDataSchema = z6.object({
+  address: z6.string(),
+  city: z6.string(),
+  country: z6.string(),
+  postalCode: z6.string()
 });
-var emergencyContactSchema = z5.object({
-  name: z5.string(),
-  relationship: z5.string(),
-  phoneNumber: z5.string(),
-  isNotifiable: z5.boolean()
+var emergencyContactSchema = z6.object({
+  name: z6.string(),
+  relationship: z6.string(),
+  phoneNumber: z6.string(),
+  isNotifiable: z6.boolean()
 });
-var gamificationSchema = z5.object({
-  level: z5.number(),
-  points: z5.number()
+var gamificationSchema = z6.object({
+  level: z6.number(),
+  points: z6.number()
 });
-var patientLocationInfoSchema = z5.object({
-  patientId: z5.string(),
-  userRef: z5.string(),
+var patientLocationInfoSchema = z6.object({
+  patientId: z6.string(),
+  userRef: z6.string(),
   locationData: locationDataSchema,
-  createdAt: z5.instanceof(Timestamp),
-  updatedAt: z5.instanceof(Timestamp)
+  createdAt: z6.instanceof(Timestamp),
+  updatedAt: z6.instanceof(Timestamp)
 });
-var createPatientLocationInfoSchema = z5.object({
-  patientId: z5.string(),
-  userRef: z5.string(),
+var createPatientLocationInfoSchema = z6.object({
+  patientId: z6.string(),
+  userRef: z6.string(),
   locationData: locationDataSchema
 });
-var patientSensitiveInfoSchema = z5.object({
-  patientId: z5.string(),
-  userRef: z5.string(),
-  photoUrl: z5.string().optional(),
-  firstName: z5.string().min(2),
-  lastName: z5.string().min(2),
-  dateOfBirth: z5.instanceof(Timestamp).nullable(),
-  gender: z5.nativeEnum(Gender),
-  email: z5.string().email().optional(),
-  phoneNumber: z5.string().optional(),
-  alternativePhoneNumber: z5.string().optional(),
+var patientSensitiveInfoSchema = z6.object({
+  patientId: z6.string(),
+  userRef: z6.string(),
+  photoUrl: z6.string().optional(),
+  firstName: z6.string().min(2),
+  lastName: z6.string().min(2),
+  dateOfBirth: z6.instanceof(Timestamp).nullable(),
+  gender: z6.nativeEnum(Gender),
+  email: z6.string().email().optional(),
+  phoneNumber: z6.string().optional(),
+  alternativePhoneNumber: z6.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: z5.array(emergencyContactSchema).optional(),
-  createdAt: z5.instanceof(Timestamp),
-  updatedAt: z5.instanceof(Timestamp)
+  emergencyContacts: z6.array(emergencyContactSchema).optional(),
+  createdAt: z6.instanceof(Timestamp),
+  updatedAt: z6.instanceof(Timestamp)
 });
-var patientDoctorSchema = z5.object({
-  userRef: z5.string(),
-  assignedAt: z5.instanceof(Timestamp),
-  assignedBy: z5.string().optional(),
-  isActive: z5.boolean(),
-  notes: z5.string().optional()
+var patientDoctorSchema = z6.object({
+  userRef: z6.string(),
+  assignedAt: z6.instanceof(Timestamp),
+  assignedBy: z6.string().optional(),
+  isActive: z6.boolean(),
+  notes: z6.string().optional()
 });
-var patientClinicSchema = z5.object({
-  clinicId: z5.string(),
-  assignedAt: z5.instanceof(Timestamp),
-  assignedBy: z5.string().optional(),
-  isActive: z5.boolean(),
-  notes: z5.string().optional()
+var patientClinicSchema = z6.object({
+  clinicId: z6.string(),
+  assignedAt: z6.instanceof(Timestamp),
+  assignedBy: z6.string().optional(),
+  isActive: z6.boolean(),
+  notes: z6.string().optional()
 });
-var patientProfileSchema = z5.object({
-  id: z5.string(),
-  userRef: z5.string(),
-  displayName: z5.string(),
-  profilePhoto: z5.string().url().nullable(),
+var patientProfileSchema = z6.object({
+  id: z6.string(),
+  userRef: z6.string(),
+  displayName: z6.string(),
+  profilePhoto: z6.string().url().nullable(),
   gamification: gamificationSchema,
-  expoTokens: z5.array(z5.string()),
-  isActive: z5.boolean(),
-  isVerified: z5.boolean(),
-  doctors: z5.array(patientDoctorSchema),
-  clinics: z5.array(patientClinicSchema),
-  doctorIds: z5.array(z5.string()),
-  clinicIds: z5.array(z5.string()),
-  createdAt: z5.instanceof(Timestamp),
-  updatedAt: z5.instanceof(Timestamp)
+  expoTokens: z6.array(z6.string()),
+  isActive: z6.boolean(),
+  isVerified: z6.boolean(),
+  doctors: z6.array(patientDoctorSchema),
+  clinics: z6.array(patientClinicSchema),
+  doctorIds: z6.array(z6.string()),
+  clinicIds: z6.array(z6.string()),
+  createdAt: z6.instanceof(Timestamp),
+  updatedAt: z6.instanceof(Timestamp)
 });
-var createPatientProfileSchema = z5.object({
-  userRef: z5.string(),
-  displayName: z5.string(),
-  profilePhoto: z5.string().url().nullable().optional(),
-  expoTokens: z5.array(z5.string()),
+var createPatientProfileSchema = z6.object({
+  userRef: z6.string(),
+  displayName: z6.string(),
+  profilePhoto: z6.string().url().nullable().optional(),
+  expoTokens: z6.array(z6.string()),
   gamification: gamificationSchema.optional(),
-  isActive: z5.boolean(),
-  isVerified: z5.boolean(),
-  doctors: z5.array(patientDoctorSchema).optional(),
-  clinics: z5.array(patientClinicSchema).optional(),
-  doctorIds: z5.array(z5.string()).optional(),
-  clinicIds: z5.array(z5.string()).optional()
+  isActive: z6.boolean(),
+  isVerified: z6.boolean(),
+  doctors: z6.array(patientDoctorSchema).optional(),
+  clinics: z6.array(patientClinicSchema).optional(),
+  doctorIds: z6.array(z6.string()).optional(),
+  clinicIds: z6.array(z6.string()).optional()
 });
-var createPatientSensitiveInfoSchema = z5.object({
-  patientId: z5.string(),
-  userRef: z5.string(),
-  photoUrl: z5.string().optional(),
-  firstName: z5.string().min(2),
-  lastName: z5.string().min(2),
-  dateOfBirth: z5.instanceof(Timestamp).nullable(),
-  gender: z5.nativeEnum(Gender),
-  email: z5.string().email().optional(),
-  phoneNumber: z5.string().optional(),
-  alternativePhoneNumber: z5.string().optional(),
+var createPatientSensitiveInfoSchema = z6.object({
+  patientId: z6.string(),
+  userRef: z6.string(),
+  photoUrl: z6.string().optional(),
+  firstName: z6.string().min(2),
+  lastName: z6.string().min(2),
+  dateOfBirth: z6.instanceof(Timestamp).nullable(),
+  gender: z6.nativeEnum(Gender),
+  email: z6.string().email().optional(),
+  phoneNumber: z6.string().optional(),
+  alternativePhoneNumber: z6.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: z5.array(emergencyContactSchema).optional()
+  emergencyContacts: z6.array(emergencyContactSchema).optional()
 });
-var searchPatientsSchema = z5.object({
-  clinicId: z5.string().optional(),
-  practitionerId: z5.string().optional()
+var searchPatientsSchema = z6.object({
+  clinicId: z6.string().optional(),
+  practitionerId: z6.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 = z5.object({
-  id: z5.string(),
-  role: z5.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: z5.string().optional(),
-  associatedPractitionerId: z5.string().optional()
+var requesterInfoSchema = z6.object({
+  id: z6.string(),
+  role: z6.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: z6.string().optional(),
+  associatedPractitionerId: z6.string().optional()
 }).refine(
   (data) => {
     if (data.role === "clinic_admin") {
@@ -1084,7 +1187,7 @@ import {
   setDoc,
   serverTimestamp
 } from "firebase/firestore";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
   try {
     if (data.userRef !== requesterUserId) {
@@ -1109,7 +1212,7 @@ var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
     }
     return createdDoc.data();
   } catch (error) {
-    if (error instanceof z6.ZodError) {
+    if (error instanceof z7.ZodError) {
       throw new Error("Invalid sensitive info data: " + error.message);
     }
     throw error;
@@ -1349,9 +1452,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 getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1367,9 +1470,9 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc29 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1394,9 +1497,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 getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1412,9 +1515,9 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc29 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1439,9 +1542,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 getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1457,9 +1560,9 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc29 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1484,9 +1587,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 getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1502,9 +1605,9 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc29 = await getDoc3(getMedicalInfoDocRef(db, patientId));
-  if (!doc29.exists()) throw new Error("Medical info not found");
-  const medicalInfo = doc29.data();
+  const doc30 = await getDoc3(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");
   }
@@ -1594,7 +1697,7 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
     return patientDoc.data();
   } catch (error) {
     console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
-    if (error instanceof z7.ZodError) {
+    if (error instanceof z8.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
@@ -1782,7 +1885,7 @@ var searchPatientsUtil = async (db, params, requester) => {
   try {
     const finalQuery = query2(patientsCollectionRef, ...constraints);
     const querySnapshot = await getDocs2(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) {
@@ -1806,8 +1909,8 @@ var getAllPatientsUtil = async (db, options) => {
     }
     const patientsSnapshot = await getDocs2(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;
@@ -1826,7 +1929,7 @@ import {
   setDoc as setDoc5,
   serverTimestamp as serverTimestamp5
 } from "firebase/firestore";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import { geohashForLocation } from "geofire-common";
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -1865,7 +1968,7 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof z8.ZodError) {
+    if (error instanceof z9.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -2378,11 +2481,11 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 })(SubscriptionModel || {});
 
 // src/validations/clinic.schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 import { Timestamp as Timestamp6 } from "firebase/firestore";
 
 // src/validations/practitioner.schema.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import { Timestamp as Timestamp5 } from "firebase/firestore";
 
 // src/backoffice/types/static/certification.types.ts
@@ -2426,128 +2529,128 @@ var PractitionerTokenStatus = /* @__PURE__ */ ((PractitionerTokenStatus2) => {
 })(PractitionerTokenStatus || {});
 
 // src/validations/reviews.schema.ts
-import { z as z9 } from "zod";
-var baseReviewSchema = z9.object({
-  id: z9.string().min(1),
-  patientId: z9.string().min(1),
-  fullReviewId: z9.string().min(1),
-  createdAt: z9.date(),
-  updatedAt: z9.date(),
-  comment: z9.string().min(1).max(2e3),
-  isVerified: z9.boolean(),
-  isPublished: z9.boolean()
+import { z as z10 } from "zod";
+var baseReviewSchema = z10.object({
+  id: z10.string().min(1),
+  patientId: z10.string().min(1),
+  fullReviewId: z10.string().min(1),
+  createdAt: z10.date(),
+  updatedAt: z10.date(),
+  comment: z10.string().min(1).max(2e3),
+  isVerified: z10.boolean(),
+  isPublished: z10.boolean()
 });
-var baseReviewCreateSchema = z9.object({
-  patientId: z9.string().min(1),
-  comment: z9.string().min(1).max(2e3),
-  isVerified: z9.boolean().default(false),
-  isPublished: z9.boolean().default(true)
+var baseReviewCreateSchema = z10.object({
+  patientId: z10.string().min(1),
+  comment: z10.string().min(1).max(2e3),
+  isVerified: z10.boolean().default(false),
+  isPublished: z10.boolean().default(true)
 });
 var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: z9.string().min(1),
-  cleanliness: z9.number().min(1).max(5),
-  facilities: z9.number().min(1).max(5),
-  staffFriendliness: z9.number().min(1).max(5),
-  waitingTime: z9.number().min(1).max(5),
-  accessibility: z9.number().min(1).max(5),
-  overallRating: z9.number().min(1).max(5),
-  wouldRecommend: z9.boolean()
+  clinicId: z10.string().min(1),
+  cleanliness: z10.number().min(1).max(5),
+  facilities: z10.number().min(1).max(5),
+  staffFriendliness: z10.number().min(1).max(5),
+  waitingTime: z10.number().min(1).max(5),
+  accessibility: z10.number().min(1).max(5),
+  overallRating: z10.number().min(1).max(5),
+  wouldRecommend: z10.boolean()
 });
 var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: z9.string().min(1),
-  cleanliness: z9.number().min(1).max(5),
-  facilities: z9.number().min(1).max(5),
-  staffFriendliness: z9.number().min(1).max(5),
-  waitingTime: z9.number().min(1).max(5),
-  accessibility: z9.number().min(1).max(5),
-  wouldRecommend: z9.boolean()
+  clinicId: z10.string().min(1),
+  cleanliness: z10.number().min(1).max(5),
+  facilities: z10.number().min(1).max(5),
+  staffFriendliness: z10.number().min(1).max(5),
+  waitingTime: z10.number().min(1).max(5),
+  accessibility: z10.number().min(1).max(5),
+  wouldRecommend: z10.boolean()
 });
 var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: z9.string().min(1),
-  knowledgeAndExpertise: z9.number().min(1).max(5),
-  communicationSkills: z9.number().min(1).max(5),
-  bedSideManner: z9.number().min(1).max(5),
-  thoroughness: z9.number().min(1).max(5),
-  trustworthiness: z9.number().min(1).max(5),
-  overallRating: z9.number().min(1).max(5),
-  wouldRecommend: z9.boolean()
+  practitionerId: z10.string().min(1),
+  knowledgeAndExpertise: z10.number().min(1).max(5),
+  communicationSkills: z10.number().min(1).max(5),
+  bedSideManner: z10.number().min(1).max(5),
+  thoroughness: z10.number().min(1).max(5),
+  trustworthiness: z10.number().min(1).max(5),
+  overallRating: z10.number().min(1).max(5),
+  wouldRecommend: z10.boolean()
 });
 var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: z9.string().min(1),
-  knowledgeAndExpertise: z9.number().min(1).max(5),
-  communicationSkills: z9.number().min(1).max(5),
-  bedSideManner: z9.number().min(1).max(5),
-  thoroughness: z9.number().min(1).max(5),
-  trustworthiness: z9.number().min(1).max(5),
-  wouldRecommend: z9.boolean()
+  practitionerId: z10.string().min(1),
+  knowledgeAndExpertise: z10.number().min(1).max(5),
+  communicationSkills: z10.number().min(1).max(5),
+  bedSideManner: z10.number().min(1).max(5),
+  thoroughness: z10.number().min(1).max(5),
+  trustworthiness: z10.number().min(1).max(5),
+  wouldRecommend: z10.boolean()
 });
 var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: z9.string().min(1),
-  effectivenessOfTreatment: z9.number().min(1).max(5),
-  outcomeExplanation: z9.number().min(1).max(5),
-  painManagement: z9.number().min(1).max(5),
-  followUpCare: z9.number().min(1).max(5),
-  valueForMoney: z9.number().min(1).max(5),
-  overallRating: z9.number().min(1).max(5),
-  wouldRecommend: z9.boolean()
+  procedureId: z10.string().min(1),
+  effectivenessOfTreatment: z10.number().min(1).max(5),
+  outcomeExplanation: z10.number().min(1).max(5),
+  painManagement: z10.number().min(1).max(5),
+  followUpCare: z10.number().min(1).max(5),
+  valueForMoney: z10.number().min(1).max(5),
+  overallRating: z10.number().min(1).max(5),
+  wouldRecommend: z10.boolean()
 });
 var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: z9.string().min(1),
-  effectivenessOfTreatment: z9.number().min(1).max(5),
-  outcomeExplanation: z9.number().min(1).max(5),
-  painManagement: z9.number().min(1).max(5),
-  followUpCare: z9.number().min(1).max(5),
-  valueForMoney: z9.number().min(1).max(5),
-  wouldRecommend: z9.boolean()
+  procedureId: z10.string().min(1),
+  effectivenessOfTreatment: z10.number().min(1).max(5),
+  outcomeExplanation: z10.number().min(1).max(5),
+  painManagement: z10.number().min(1).max(5),
+  followUpCare: z10.number().min(1).max(5),
+  valueForMoney: z10.number().min(1).max(5),
+  wouldRecommend: z10.boolean()
 });
-var clinicReviewInfoSchema = z9.object({
-  totalReviews: z9.number().min(0),
-  averageRating: z9.number().min(0).max(5),
-  cleanliness: z9.number().min(0).max(5),
-  facilities: z9.number().min(0).max(5),
-  staffFriendliness: z9.number().min(0).max(5),
-  waitingTime: z9.number().min(0).max(5),
-  accessibility: z9.number().min(0).max(5),
-  recommendationPercentage: z9.number().min(0).max(100)
+var clinicReviewInfoSchema = z10.object({
+  totalReviews: z10.number().min(0),
+  averageRating: z10.number().min(0).max(5),
+  cleanliness: z10.number().min(0).max(5),
+  facilities: z10.number().min(0).max(5),
+  staffFriendliness: z10.number().min(0).max(5),
+  waitingTime: z10.number().min(0).max(5),
+  accessibility: z10.number().min(0).max(5),
+  recommendationPercentage: z10.number().min(0).max(100)
 });
-var practitionerReviewInfoSchema = z9.object({
-  totalReviews: z9.number().min(0),
-  averageRating: z9.number().min(0).max(5),
-  knowledgeAndExpertise: z9.number().min(0).max(5),
-  communicationSkills: z9.number().min(0).max(5),
-  bedSideManner: z9.number().min(0).max(5),
-  thoroughness: z9.number().min(0).max(5),
-  trustworthiness: z9.number().min(0).max(5),
-  recommendationPercentage: z9.number().min(0).max(100)
+var practitionerReviewInfoSchema = z10.object({
+  totalReviews: z10.number().min(0),
+  averageRating: z10.number().min(0).max(5),
+  knowledgeAndExpertise: z10.number().min(0).max(5),
+  communicationSkills: z10.number().min(0).max(5),
+  bedSideManner: z10.number().min(0).max(5),
+  thoroughness: z10.number().min(0).max(5),
+  trustworthiness: z10.number().min(0).max(5),
+  recommendationPercentage: z10.number().min(0).max(100)
 });
-var procedureReviewInfoSchema = z9.object({
-  totalReviews: z9.number().min(0),
-  averageRating: z9.number().min(0).max(5),
-  effectivenessOfTreatment: z9.number().min(0).max(5),
-  outcomeExplanation: z9.number().min(0).max(5),
-  painManagement: z9.number().min(0).max(5),
-  followUpCare: z9.number().min(0).max(5),
-  valueForMoney: z9.number().min(0).max(5),
-  recommendationPercentage: z9.number().min(0).max(100)
+var procedureReviewInfoSchema = z10.object({
+  totalReviews: z10.number().min(0),
+  averageRating: z10.number().min(0).max(5),
+  effectivenessOfTreatment: z10.number().min(0).max(5),
+  outcomeExplanation: z10.number().min(0).max(5),
+  painManagement: z10.number().min(0).max(5),
+  followUpCare: z10.number().min(0).max(5),
+  valueForMoney: z10.number().min(0).max(5),
+  recommendationPercentage: z10.number().min(0).max(100)
 });
-var reviewSchema = z9.object({
-  id: z9.string().min(1),
-  appointmentId: z9.string().min(1),
-  patientId: z9.string().min(1),
-  createdAt: z9.date(),
-  updatedAt: z9.date(),
+var reviewSchema = z10.object({
+  id: z10.string().min(1),
+  appointmentId: z10.string().min(1),
+  patientId: z10.string().min(1),
+  createdAt: z10.date(),
+  updatedAt: z10.date(),
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
-  overallComment: z9.string().min(1).max(2e3),
-  overallRating: z9.number().min(1).max(5)
+  overallComment: z10.string().min(1).max(2e3),
+  overallRating: z10.number().min(1).max(5)
 });
-var createReviewSchema = z9.object({
-  patientId: z9.string().min(1),
+var createReviewSchema = z10.object({
+  patientId: z10.string().min(1),
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: z9.string().min(1).max(2e3)
+  overallComment: z10.string().min(1).max(2e3)
 }).refine(
   (data) => {
     return data.clinicReview || data.practitionerReview || data.procedureReview;
@@ -2585,34 +2688,34 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
 })(Currency || {});
 
 // src/validations/practitioner.schema.ts
-var practitionerBasicInfoSchema = z10.object({
-  firstName: z10.string().min(2).max(50),
-  lastName: z10.string().min(2).max(50),
-  title: z10.string().min(2).max(100),
-  email: z10.string().email(),
-  phoneNumber: z10.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: z10.instanceof(Timestamp5).or(z10.date()),
-  gender: z10.enum(["male", "female", "other"]),
-  profileImageUrl: z10.string().url().optional(),
-  bio: z10.string().max(1e3).optional(),
-  languages: z10.array(z10.string()).min(1)
+var practitionerBasicInfoSchema = z11.object({
+  firstName: z11.string().min(2).max(50),
+  lastName: z11.string().min(2).max(50),
+  title: z11.string().min(2).max(100),
+  email: z11.string().email(),
+  phoneNumber: z11.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
+  dateOfBirth: z11.instanceof(Timestamp5).or(z11.date()),
+  gender: z11.enum(["male", "female", "other"]),
+  profileImageUrl: z11.string().url().optional(),
+  bio: z11.string().max(1e3).optional(),
+  languages: z11.array(z11.string()).min(1)
 });
-var practitionerCertificationSchema = z10.object({
-  level: z10.nativeEnum(CertificationLevel),
-  specialties: z10.array(z10.nativeEnum(CertificationSpecialty)),
-  licenseNumber: z10.string().min(3).max(50),
-  issuingAuthority: z10.string().min(2).max(100),
-  issueDate: z10.instanceof(Timestamp5).or(z10.date()),
-  expiryDate: z10.instanceof(Timestamp5).or(z10.date()).optional(),
-  verificationStatus: z10.enum(["pending", "verified", "rejected"])
+var practitionerCertificationSchema = z11.object({
+  level: z11.nativeEnum(CertificationLevel),
+  specialties: z11.array(z11.nativeEnum(CertificationSpecialty)),
+  licenseNumber: z11.string().min(3).max(50),
+  issuingAuthority: z11.string().min(2).max(100),
+  issueDate: z11.instanceof(Timestamp5).or(z11.date()),
+  expiryDate: z11.instanceof(Timestamp5).or(z11.date()).optional(),
+  verificationStatus: z11.enum(["pending", "verified", "rejected"])
 });
-var timeSlotSchema = z10.object({
-  start: z10.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
-  end: z10.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
+var timeSlotSchema = z11.object({
+  start: z11.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format"),
+  end: z11.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Invalid time format")
 }).nullable();
-var practitionerWorkingHoursSchema = z10.object({
-  practitionerId: z10.string().min(1),
-  clinicId: z10.string().min(1),
+var practitionerWorkingHoursSchema = z11.object({
+  practitionerId: z11.string().min(1),
+  clinicId: z11.string().min(1),
   monday: timeSlotSchema,
   tuesday: timeSlotSchema,
   wednesday: timeSlotSchema,
@@ -2620,12 +2723,12 @@ var practitionerWorkingHoursSchema = z10.object({
   friday: timeSlotSchema,
   saturday: timeSlotSchema,
   sunday: timeSlotSchema,
-  createdAt: z10.instanceof(Timestamp5).or(z10.date()),
-  updatedAt: z10.instanceof(Timestamp5).or(z10.date())
+  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
+  updatedAt: z11.instanceof(Timestamp5).or(z11.date())
 });
-var practitionerClinicWorkingHoursSchema = z10.object({
-  clinicId: z10.string().min(1),
-  workingHours: z10.object({
+var practitionerClinicWorkingHoursSchema = z11.object({
+  clinicId: z11.string().min(1),
+  workingHours: z11.object({
     monday: timeSlotSchema,
     tuesday: timeSlotSchema,
     wednesday: timeSlotSchema,
@@ -2634,114 +2737,114 @@ var practitionerClinicWorkingHoursSchema = z10.object({
     saturday: timeSlotSchema,
     sunday: timeSlotSchema
   }),
-  isActive: z10.boolean(),
-  createdAt: z10.instanceof(Timestamp5).or(z10.date()),
-  updatedAt: z10.instanceof(Timestamp5).or(z10.date())
+  isActive: z11.boolean(),
+  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
+  updatedAt: z11.instanceof(Timestamp5).or(z11.date())
 });
-var procedureSummaryInfoSchema = z10.object({
-  id: z10.string().min(1),
-  name: z10.string().min(1),
-  description: z10.string().optional(),
-  photo: z10.string().optional(),
-  family: z10.nativeEnum(ProcedureFamily),
-  categoryName: z10.string(),
-  subcategoryName: z10.string(),
-  technologyName: z10.string(),
-  price: z10.number().nonnegative(),
-  pricingMeasure: z10.nativeEnum(PricingMeasure),
-  currency: z10.nativeEnum(Currency),
-  duration: z10.number().int().positive(),
-  clinicId: z10.string().min(1),
-  clinicName: z10.string().min(1),
-  practitionerId: z10.string().min(1),
-  practitionerName: z10.string().min(1)
+var procedureSummaryInfoSchema = z11.object({
+  id: z11.string().min(1),
+  name: z11.string().min(1),
+  description: z11.string().optional(),
+  photo: z11.string().optional(),
+  family: z11.nativeEnum(ProcedureFamily),
+  categoryName: z11.string(),
+  subcategoryName: z11.string(),
+  technologyName: z11.string(),
+  price: z11.number().nonnegative(),
+  pricingMeasure: z11.nativeEnum(PricingMeasure),
+  currency: z11.nativeEnum(Currency),
+  duration: z11.number().int().positive(),
+  clinicId: z11.string().min(1),
+  clinicName: z11.string().min(1),
+  practitionerId: z11.string().min(1),
+  practitionerName: z11.string().min(1)
 });
-var practitionerSchema = z10.object({
-  id: z10.string().min(1),
-  userRef: z10.string().min(1),
+var practitionerSchema = z11.object({
+  id: z11.string().min(1),
+  userRef: z11.string().min(1),
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
-  clinics: z10.array(z10.string()),
-  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema),
-  clinicsInfo: z10.array(clinicInfoSchema),
-  procedures: z10.array(z10.string()),
-  proceduresInfo: z10.array(procedureSummaryInfoSchema),
+  clinics: z11.array(z11.string()),
+  clinicWorkingHours: z11.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: z11.array(clinicInfoSchema),
+  procedures: z11.array(z11.string()),
+  proceduresInfo: z11.array(procedureSummaryInfoSchema),
   reviewInfo: practitionerReviewInfoSchema,
-  isActive: z10.boolean(),
-  isVerified: z10.boolean(),
-  status: z10.nativeEnum(PractitionerStatus),
-  createdAt: z10.instanceof(Timestamp5).or(z10.date()),
-  updatedAt: z10.instanceof(Timestamp5).or(z10.date())
+  isActive: z11.boolean(),
+  isVerified: z11.boolean(),
+  status: z11.nativeEnum(PractitionerStatus),
+  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
+  updatedAt: z11.instanceof(Timestamp5).or(z11.date())
 });
-var createPractitionerSchema = z10.object({
-  userRef: z10.string().min(1),
+var createPractitionerSchema = z11.object({
+  userRef: z11.string().min(1),
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
-  clinics: z10.array(z10.string()).optional(),
-  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: z10.array(clinicInfoSchema).optional(),
-  proceduresInfo: z10.array(procedureSummaryInfoSchema).optional(),
-  isActive: z10.boolean(),
-  isVerified: z10.boolean(),
-  status: z10.nativeEnum(PractitionerStatus).optional()
+  clinics: z11.array(z11.string()).optional(),
+  clinicWorkingHours: z11.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: z11.array(clinicInfoSchema).optional(),
+  proceduresInfo: z11.array(procedureSummaryInfoSchema).optional(),
+  isActive: z11.boolean(),
+  isVerified: z11.boolean(),
+  status: z11.nativeEnum(PractitionerStatus).optional()
 });
-var createDraftPractitionerSchema = z10.object({
+var createDraftPractitionerSchema = z11.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
-  clinics: z10.array(z10.string()).optional(),
-  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema).optional(),
-  clinicsInfo: z10.array(clinicInfoSchema).optional(),
-  proceduresInfo: z10.array(procedureSummaryInfoSchema).optional(),
-  isActive: z10.boolean().optional().default(false),
-  isVerified: z10.boolean().optional().default(false)
+  clinics: z11.array(z11.string()).optional(),
+  clinicWorkingHours: z11.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: z11.array(clinicInfoSchema).optional(),
+  proceduresInfo: z11.array(procedureSummaryInfoSchema).optional(),
+  isActive: z11.boolean().optional().default(false),
+  isVerified: z11.boolean().optional().default(false)
 });
-var practitionerTokenSchema = z10.object({
-  id: z10.string().min(1),
-  token: z10.string().min(6),
-  practitionerId: z10.string().min(1),
-  email: z10.string().email(),
-  clinicId: z10.string().min(1),
-  status: z10.nativeEnum(PractitionerTokenStatus),
-  createdBy: z10.string().min(1),
-  createdAt: z10.instanceof(Timestamp5).or(z10.date()),
-  expiresAt: z10.instanceof(Timestamp5).or(z10.date()),
-  usedBy: z10.string().optional(),
-  usedAt: z10.instanceof(Timestamp5).or(z10.date()).optional()
+var practitionerTokenSchema = z11.object({
+  id: z11.string().min(1),
+  token: z11.string().min(6),
+  practitionerId: z11.string().min(1),
+  email: z11.string().email(),
+  clinicId: z11.string().min(1),
+  status: z11.nativeEnum(PractitionerTokenStatus),
+  createdBy: z11.string().min(1),
+  createdAt: z11.instanceof(Timestamp5).or(z11.date()),
+  expiresAt: z11.instanceof(Timestamp5).or(z11.date()),
+  usedBy: z11.string().optional(),
+  usedAt: z11.instanceof(Timestamp5).or(z11.date()).optional()
 });
-var createPractitionerTokenSchema = z10.object({
-  practitionerId: z10.string().min(1),
-  email: z10.string().email(),
-  clinicId: z10.string().min(1),
-  expiresAt: z10.date().optional()
+var createPractitionerTokenSchema = z11.object({
+  practitionerId: z11.string().min(1),
+  email: z11.string().email(),
+  clinicId: z11.string().min(1),
+  expiresAt: z11.date().optional()
 });
 
 // src/validations/clinic.schema.ts
-var clinicContactInfoSchema = z11.object({
-  email: z11.string().email(),
-  phoneNumber: z11.string(),
-  alternativePhoneNumber: z11.string().nullable().optional(),
-  website: z11.string().nullable().optional()
+var clinicContactInfoSchema = z12.object({
+  email: z12.string().email(),
+  phoneNumber: z12.string(),
+  alternativePhoneNumber: z12.string().nullable().optional(),
+  website: z12.string().nullable().optional()
 });
-var clinicLocationSchema = z11.object({
-  address: z11.string(),
-  city: z11.string(),
-  country: z11.string(),
-  postalCode: z11.string(),
-  latitude: z11.number().min(-90).max(90),
-  longitude: z11.number().min(-180).max(180),
-  geohash: z11.string().nullable().optional()
+var clinicLocationSchema = z12.object({
+  address: z12.string(),
+  city: z12.string(),
+  country: z12.string(),
+  postalCode: z12.string(),
+  latitude: z12.number().min(-90).max(90),
+  longitude: z12.number().min(-180).max(180),
+  geohash: z12.string().nullable().optional()
 });
-var workingHoursTimeSchema = z11.object({
-  open: z11.string(),
-  close: z11.string(),
-  breaks: z11.array(
-    z11.object({
-      start: z11.string(),
-      end: z11.string()
+var workingHoursTimeSchema = z12.object({
+  open: z12.string(),
+  close: z12.string(),
+  breaks: z12.array(
+    z12.object({
+      start: z12.string(),
+      end: z12.string()
     })
   ).optional()
 });
-var workingHoursSchema = z11.object({
+var workingHoursSchema = z12.object({
   monday: workingHoursTimeSchema.nullable(),
   tuesday: workingHoursTimeSchema.nullable(),
   wednesday: workingHoursTimeSchema.nullable(),
@@ -2750,235 +2853,235 @@ var workingHoursSchema = z11.object({
   saturday: workingHoursTimeSchema.nullable(),
   sunday: workingHoursTimeSchema.nullable()
 });
-var clinicTagsSchema = z11.object({
-  tags: z11.array(z11.nativeEnum(ClinicTag))
+var clinicTagsSchema = z12.object({
+  tags: z12.array(z12.nativeEnum(ClinicTag))
 });
-var contactPersonSchema = z11.object({
-  firstName: z11.string(),
-  lastName: z11.string(),
-  title: z11.string().nullable().optional(),
-  email: z11.string().email(),
-  phoneNumber: z11.string().nullable().optional()
+var contactPersonSchema = z12.object({
+  firstName: z12.string(),
+  lastName: z12.string(),
+  title: z12.string().nullable().optional(),
+  email: z12.string().email(),
+  phoneNumber: z12.string().nullable().optional()
 });
-var adminInfoSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  email: z11.string().email()
+var adminInfoSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  email: z12.string().email()
 });
-var clinicInfoSchema = z11.object({
-  id: z11.string(),
-  featuredPhoto: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
+var clinicInfoSchema = z12.object({
+  id: z12.string(),
+  featuredPhoto: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var doctorInfoSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
-  photo: z11.string(),
-  rating: z11.number().min(0).max(5),
-  services: z11.array(z11.string())
+var doctorInfoSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
+  photo: z12.string(),
+  rating: z12.number().min(0).max(5),
+  services: z12.array(z12.string())
   // List of procedure IDs practitioner offers
 });
-var clinicAdminSchema = z11.object({
-  id: z11.string(),
-  userRef: z11.string(),
-  clinicGroupId: z11.string(),
-  isGroupOwner: z11.boolean(),
-  clinicsManaged: z11.array(z11.string()),
-  clinicsManagedInfo: z11.array(clinicInfoSchema),
+var clinicAdminSchema = z12.object({
+  id: z12.string(),
+  userRef: z12.string(),
+  clinicGroupId: z12.string(),
+  isGroupOwner: z12.boolean(),
+  clinicsManaged: z12.array(z12.string()),
+  clinicsManagedInfo: z12.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
-  roleTitle: z11.string(),
-  createdAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
-  updatedAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
-  isActive: z11.boolean()
+  roleTitle: z12.string(),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
+  isActive: z12.boolean()
 });
-var adminTokenSchema = z11.object({
-  id: z11.string(),
-  token: z11.string(),
-  email: z11.string().email().optional().nullable(),
-  status: z11.nativeEnum(AdminTokenStatus),
-  usedByUserRef: z11.string().optional(),
-  createdAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
+var adminTokenSchema = z12.object({
+  id: z12.string(),
+  token: z12.string(),
+  email: z12.string().email().optional().nullable(),
+  status: z12.nativeEnum(AdminTokenStatus),
+  usedByUserRef: z12.string().optional(),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
   // Timestamp
-  expiresAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6))
+  expiresAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6))
   // Timestamp
 });
-var createAdminTokenSchema = z11.object({
-  expiresInDays: z11.number().min(1).max(30).optional(),
-  email: z11.string().email().optional().nullable()
+var createAdminTokenSchema = z12.object({
+  expiresInDays: z12.number().min(1).max(30).optional(),
+  email: z12.string().email().optional().nullable()
 });
-var clinicGroupSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
+var clinicGroupSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  clinics: z11.array(z11.string()),
-  clinicsInfo: z11.array(clinicInfoSchema),
-  admins: z11.array(z11.string()),
-  adminsInfo: z11.array(adminInfoSchema),
-  adminTokens: z11.array(adminTokenSchema),
-  ownerId: z11.string().nullable(),
-  createdAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
+  clinics: z12.array(z12.string()),
+  clinicsInfo: z12.array(clinicInfoSchema),
+  admins: z12.array(z12.string()),
+  adminsInfo: z12.array(adminInfoSchema),
+  adminTokens: z12.array(adminTokenSchema),
+  ownerId: z12.string().nullable(),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
   // Timestamp
-  updatedAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
+  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
   // Timestamp
-  isActive: z11.boolean(),
-  logo: z11.string().optional().nullable(),
-  practiceType: z11.nativeEnum(PracticeType).optional(),
-  languages: z11.array(z11.nativeEnum(Language)).optional(),
-  subscriptionModel: z11.nativeEnum(SubscriptionModel),
-  calendarSyncEnabled: z11.boolean().optional(),
-  autoConfirmAppointments: z11.boolean().optional(),
-  businessIdentificationNumber: z11.string().optional().nullable()
+  isActive: z12.boolean(),
+  logo: z12.string().optional().nullable(),
+  practiceType: z12.nativeEnum(PracticeType).optional(),
+  languages: z12.array(z12.nativeEnum(Language)).optional(),
+  subscriptionModel: z12.nativeEnum(SubscriptionModel),
+  calendarSyncEnabled: z12.boolean().optional(),
+  autoConfirmAppointments: z12.boolean().optional(),
+  businessIdentificationNumber: z12.string().optional().nullable()
 });
-var clinicSchema = z11.object({
-  id: z11.string(),
-  clinicGroupId: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
+var clinicSchema = z12.object({
+  id: z12.string(),
+  clinicGroupId: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: z11.array(z11.nativeEnum(ClinicTag)),
-  featuredPhotos: z11.array(z11.string()),
-  coverPhoto: z11.string().nullable(),
-  photosWithTags: z11.array(
-    z11.object({
-      url: z11.string(),
-      tag: z11.string()
+  tags: z12.array(z12.nativeEnum(ClinicTag)),
+  featuredPhotos: z12.array(z12.string()),
+  coverPhoto: z12.string().nullable(),
+  photosWithTags: z12.array(
+    z12.object({
+      url: z12.string(),
+      tag: z12.string()
     })
   ).optional(),
-  doctors: z11.array(z11.string()),
+  doctors: z12.array(z12.string()),
   // List of practitioner IDs
-  doctorsInfo: z11.array(doctorInfoSchema),
+  doctorsInfo: z12.array(doctorInfoSchema),
   // Aggregated doctor info
-  procedures: z11.array(z11.string()),
+  procedures: z12.array(z12.string()),
   // List of procedure IDs offered by clinic
-  proceduresInfo: z11.array(procedureSummaryInfoSchema),
+  proceduresInfo: z12.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: z11.array(z11.string()),
-  createdAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
+  admins: z12.array(z12.string()),
+  createdAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
   // Timestamp
-  updatedAt: z11.instanceof(Date).or(z11.instanceof(Timestamp6)),
+  updatedAt: z12.instanceof(Date).or(z12.instanceof(Timestamp6)),
   // Timestamp
-  isActive: z11.boolean(),
-  isVerified: z11.boolean(),
-  logo: z11.string().optional()
+  isActive: z12.boolean(),
+  isVerified: z12.boolean(),
+  logo: z12.string().optional()
 });
-var createClinicAdminSchema = z11.object({
-  userRef: z11.string(),
-  clinicGroupId: z11.string().optional(),
-  isGroupOwner: z11.boolean(),
-  clinicsManaged: z11.array(z11.string()),
+var createClinicAdminSchema = z12.object({
+  userRef: z12.string(),
+  clinicGroupId: z12.string().optional(),
+  isGroupOwner: z12.boolean(),
+  clinicsManaged: z12.array(z12.string()),
   contactInfo: contactPersonSchema,
-  roleTitle: z11.string(),
-  isActive: z11.boolean()
+  roleTitle: z12.string(),
+  isActive: z12.boolean()
   // clinicsManagedInfo is aggregated, not provided on creation
 });
-var createClinicGroupSchema = z11.object({
-  name: z11.string(),
-  description: z11.string().optional(),
+var createClinicGroupSchema = z12.object({
+  name: z12.string(),
+  description: z12.string().optional(),
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  ownerId: z11.string().nullable(),
-  isActive: z11.boolean(),
-  logo: z11.string().optional().nullable(),
-  practiceType: z11.nativeEnum(PracticeType).optional(),
-  languages: z11.array(z11.nativeEnum(Language)).optional(),
-  subscriptionModel: z11.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
-  calendarSyncEnabled: z11.boolean().optional(),
-  autoConfirmAppointments: z11.boolean().optional(),
-  businessIdentificationNumber: z11.string().optional().nullable()
+  ownerId: z12.string().nullable(),
+  isActive: z12.boolean(),
+  logo: z12.string().optional().nullable(),
+  practiceType: z12.nativeEnum(PracticeType).optional(),
+  languages: z12.array(z12.nativeEnum(Language)).optional(),
+  subscriptionModel: z12.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */),
+  calendarSyncEnabled: z12.boolean().optional(),
+  autoConfirmAppointments: z12.boolean().optional(),
+  businessIdentificationNumber: z12.string().optional().nullable()
   // clinics, clinicsInfo, admins, adminsInfo, adminTokens are managed internally
 });
-var createClinicSchema = z11.object({
-  clinicGroupId: z11.string(),
-  name: z11.string(),
-  description: z11.string().optional(),
+var createClinicSchema = z12.object({
+  clinicGroupId: z12.string(),
+  name: z12.string(),
+  description: z12.string().optional(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: z11.array(z11.nativeEnum(ClinicTag)),
-  coverPhoto: z11.string().nullable(),
-  photosWithTags: z11.array(
-    z11.object({
-      url: z11.string(),
-      tag: z11.string()
+  tags: z12.array(z12.nativeEnum(ClinicTag)),
+  coverPhoto: z12.string().nullable(),
+  photosWithTags: z12.array(
+    z12.object({
+      url: z12.string(),
+      tag: z12.string()
     })
   ).optional(),
   // doctors, doctorsInfo, procedures, proceduresInfo are managed internally/aggregated
   // doctors: z.array(z.string()),
   // services: z.array(z.string()), // Deprecated
-  admins: z11.array(z11.string()),
+  admins: z12.array(z12.string()),
   // Should likely just be creator ID initially
-  isActive: z11.boolean(),
-  isVerified: z11.boolean(),
-  logo: z11.string().optional(),
-  featuredPhotos: z11.array(z11.string()).optional()
+  isActive: z12.boolean(),
+  isVerified: z12.boolean(),
+  logo: z12.string().optional(),
+  featuredPhotos: z12.array(z12.string()).optional()
 });
-var createDefaultClinicGroupSchema = z11.object({
-  name: z11.string(),
-  ownerId: z11.string().nullable(),
+var createDefaultClinicGroupSchema = z12.object({
+  name: z12.string(),
+  ownerId: z12.string().nullable(),
   contactPerson: contactPersonSchema,
   contactInfo: clinicContactInfoSchema,
   hqLocation: clinicLocationSchema,
-  isActive: z11.boolean(),
-  logo: z11.string().optional().nullable(),
-  practiceType: z11.nativeEnum(PracticeType).optional(),
-  languages: z11.array(z11.nativeEnum(Language)).optional(),
-  subscriptionModel: z11.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+  isActive: z12.boolean(),
+  logo: z12.string().optional().nullable(),
+  practiceType: z12.nativeEnum(PracticeType).optional(),
+  languages: z12.array(z12.nativeEnum(Language)).optional(),
+  subscriptionModel: z12.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
 });
-var clinicAdminSignupSchema = z11.object({
-  email: z11.string().email(),
-  password: z11.string().min(8),
-  firstName: z11.string(),
-  lastName: z11.string(),
-  title: z11.string(),
-  phoneNumber: z11.string(),
-  isCreatingNewGroup: z11.boolean(),
-  inviteToken: z11.string().optional(),
-  clinicGroupData: z11.object({
-    name: z11.string(),
+var clinicAdminSignupSchema = z12.object({
+  email: z12.string().email(),
+  password: z12.string().min(8),
+  firstName: z12.string(),
+  lastName: z12.string(),
+  title: z12.string(),
+  phoneNumber: z12.string(),
+  isCreatingNewGroup: z12.boolean(),
+  inviteToken: z12.string().optional(),
+  clinicGroupData: z12.object({
+    name: z12.string(),
     hqLocation: clinicLocationSchema,
-    logo: z11.string().optional(),
+    logo: z12.string().optional(),
     contactInfo: clinicContactInfoSchema,
-    subscriptionModel: z11.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
+    subscriptionModel: z12.nativeEnum(SubscriptionModel).optional().default("no_subscription" /* NO_SUBSCRIPTION */)
   }).optional()
 });
-var clinicGroupSetupSchema = z11.object({
-  languages: z11.array(z11.nativeEnum(Language)),
-  practiceType: z11.nativeEnum(PracticeType),
-  description: z11.string(),
-  logo: z11.string(),
-  calendarSyncEnabled: z11.boolean(),
-  autoConfirmAppointments: z11.boolean(),
-  businessIdentificationNumber: z11.string().optional().nullable()
+var clinicGroupSetupSchema = z12.object({
+  languages: z12.array(z12.nativeEnum(Language)),
+  practiceType: z12.nativeEnum(PracticeType),
+  description: z12.string(),
+  logo: z12.string(),
+  calendarSyncEnabled: z12.boolean(),
+  autoConfirmAppointments: z12.boolean(),
+  businessIdentificationNumber: z12.string().optional().nullable()
 });
-var clinicBranchSetupSchema = z11.object({
-  name: z11.string(),
+var clinicBranchSetupSchema = z12.object({
+  name: z12.string(),
   location: clinicLocationSchema,
-  description: z11.string().optional(),
+  description: z12.string().optional(),
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
-  tags: z11.array(z11.nativeEnum(ClinicTag)),
-  logo: z11.string().optional(),
-  coverPhoto: z11.string().nullable(),
-  photosWithTags: z11.array(
-    z11.object({
-      url: z11.string(),
-      tag: z11.string()
+  tags: z12.array(z12.nativeEnum(ClinicTag)),
+  logo: z12.string().optional(),
+  coverPhoto: z12.string().nullable(),
+  photosWithTags: z12.array(
+    z12.object({
+      url: z12.string(),
+      tag: z12.string()
     })
   ).optional(),
-  featuredPhotos: z11.array(z11.string()).optional()
+  featuredPhotos: z12.array(z12.string()).optional()
 });
 var updateClinicAdminSchema = createClinicAdminSchema.partial();
 var updateClinicGroupSchema = createClinicGroupSchema.partial();
@@ -3165,7 +3268,7 @@ async function getClinicAdminsByGroup(db, clinicGroupId) {
     where3("clinicGroupId", "==", clinicGroupId)
   );
   const querySnapshot = await getDocs3(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);
@@ -3447,7 +3550,7 @@ import {
   arrayUnion as arrayUnion5,
   arrayRemove as arrayRemove4
 } from "firebase/firestore";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import { distanceBetween } from "geofire-common";
 var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService) {
@@ -3516,7 +3619,7 @@ var PractitionerService = class extends BaseService {
       }
       return createdPractitioner;
     } catch (error) {
-      if (error instanceof z12.ZodError) {
+      if (error instanceof z13.ZodError) {
         throw new Error(`Invalid practitioner data: ${error.message}`);
       }
       console.error("Error creating practitioner:", error);
@@ -3612,7 +3715,7 @@ var PractitionerService = class extends BaseService {
       await setDoc7(doc6(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
-      if (error instanceof z12.ZodError) {
+      if (error instanceof z13.ZodError) {
         throw new Error("Invalid practitioner data: " + error.message);
       }
       throw error;
@@ -3665,7 +3768,7 @@ var PractitionerService = class extends BaseService {
       await setDoc7(doc6(this.db, tokenPath), token);
       return token;
     } catch (error) {
-      if (error instanceof z12.ZodError) {
+      if (error instanceof z13.ZodError) {
         throw new Error("Invalid token data: " + error.message);
       }
       throw error;
@@ -3687,7 +3790,7 @@ var PractitionerService = class extends BaseService {
       where4("expiresAt", ">", Timestamp8.now())
     );
     const querySnapshot = await getDocs4(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
@@ -3770,7 +3873,7 @@ var PractitionerService = class extends BaseService {
       where4("status", "==", "active" /* ACTIVE */)
     );
     const querySnapshot = await getDocs4(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
@@ -3782,7 +3885,7 @@ var PractitionerService = class extends BaseService {
       where4("isActive", "==", true)
     );
     const querySnapshot = await getDocs4(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
@@ -3794,7 +3897,7 @@ var PractitionerService = class extends BaseService {
       where4("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await getDocs4(q);
-    return querySnapshot.docs.map((doc29) => doc29.data());
+    return querySnapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Updates a practitioner
@@ -3825,7 +3928,7 @@ var PractitionerService = class extends BaseService {
       }
       return updatedPractitioner;
     } catch (error) {
-      if (error instanceof z12.ZodError) {
+      if (error instanceof z13.ZodError) {
         throw new Error(`Invalid practitioner update data: ${error.message}`);
       }
       console.error(`Error updating practitioner ${practitionerId}:`, error);
@@ -3976,7 +4079,7 @@ var PractitionerService = class extends BaseService {
       );
       const querySnapshot = await getDocs4(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 {
@@ -4047,8 +4150,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() !== "") {
@@ -4302,7 +4405,7 @@ var UserService = class extends BaseService {
     ];
     const q = query5(collection5(this.db, USERS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs5(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)));
   }
   /**
@@ -4353,7 +4456,7 @@ var UserService = class extends BaseService {
       });
       return this.getUserById(uid);
     } catch (error) {
-      if (error instanceof z13.ZodError) {
+      if (error instanceof z14.ZodError) {
         throw USER_ERRORS.VALIDATION_ERROR;
       }
       throw error;
@@ -4450,7 +4553,7 @@ import {
   Timestamp as Timestamp10
 } from "firebase/firestore";
 import { geohashForLocation as geohashForLocation2 } from "geofire-common";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/services/clinic/utils/photos.utils.ts
 import {
@@ -4654,7 +4757,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
     });
     return groupData;
   } catch (error) {
-    if (error instanceof z14.ZodError) {
+    if (error instanceof z15.ZodError) {
       console.error(
         "[CLINIC_GROUP] Zod validation error:",
         JSON.stringify(error.errors, null, 2)
@@ -4682,7 +4785,7 @@ async function getAllActiveGroups(db) {
     where6("isActive", "==", true)
   );
   const querySnapshot = await getDocs6(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 });
@@ -5069,7 +5172,7 @@ import {
 import {
   geohashForLocation as geohashForLocation4
 } from "geofire-common";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/services/clinic/utils/clinic.utils.ts
 import {
@@ -5090,7 +5193,7 @@ import {
   distanceBetween as distanceBetween2,
   geohashQueryBounds
 } from "geofire-common";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 async function getClinic(db, clinicId) {
   const docRef = doc9(db, CLINICS_COLLECTION, clinicId);
   const docSnap = await getDoc12(docRef);
@@ -5106,7 +5209,7 @@ async function getClinicsByGroup(db, groupId) {
     where7("isActive", "==", true)
   );
   const querySnapshot = await getDocs7(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 });
@@ -5300,7 +5403,7 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   }
   const q = query7(collection7(db, CLINICS_COLLECTION), ...constraints);
   const querySnapshot = await getDocs7(q);
-  return querySnapshot.docs.map((doc29) => doc29.data());
+  return querySnapshot.docs.map((doc30) => doc30.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
   return getClinicsByAdmin(
@@ -5345,11 +5448,11 @@ async function getAllClinics(db, pagination, lastDoc) {
     }
     const clinicsSnapshot = await getDocs7(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 {
@@ -5376,8 +5479,8 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
     ];
     const q = query7(collection7(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs7(q);
-    for (const doc29 of querySnapshot.docs) {
-      const clinic = doc29.data();
+    for (const doc30 of querySnapshot.docs) {
+      const clinic = doc30.data();
       const distance = distanceBetween2(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5499,8 +5602,8 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
     }
     const q = query8(collection8(db, CLINICS_COLLECTION), ...constraints);
     const querySnapshot = await getDocs8(q);
-    for (const doc29 of querySnapshot.docs) {
-      const clinic = doc29.data();
+    for (const doc30 of querySnapshot.docs) {
+      const clinic = doc30.data();
       const distance = distanceBetween3(
         [center.latitude, center.longitude],
         [clinic.location.latitude, clinic.location.longitude]
@@ -5596,8 +5699,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 = distanceBetween4(
           [center.latitude, center.longitude],
           [clinic.location.latitude, clinic.location.longitude]
@@ -5653,8 +5756,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) {
@@ -5775,7 +5878,7 @@ var ClinicService = class extends BaseService {
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
     } catch (error) {
-      if (error instanceof z16.ZodError) {
+      if (error instanceof z17.ZodError) {
         throw new Error("Invalid clinic data: " + error.message);
       }
       console.error("Error creating clinic:", error);
@@ -5823,7 +5926,7 @@ var ClinicService = class extends BaseService {
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
-      if (error instanceof z16.ZodError) {
+      if (error instanceof z17.ZodError) {
         throw new Error(
           "Invalid clinic update data: " + error.errors.map((e) => `${e.path.join(".")} - ${e.message}`).join(", ")
         );
@@ -6282,7 +6385,7 @@ var AuthService = class extends BaseService {
         clinicAdmin: adminProfile
       };
     } catch (error) {
-      if (error instanceof z17.ZodError) {
+      if (error instanceof z18.ZodError) {
         console.error(
           "[AUTH] Zod validation error in signUpClinicAdmin:",
           JSON.stringify(error.errors, null, 2)
@@ -6455,7 +6558,7 @@ var AuthService = class extends BaseService {
         email
       );
     } catch (error) {
-      if (error instanceof z17.ZodError) {
+      if (error instanceof z18.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6578,7 +6681,7 @@ var AuthService = class extends BaseService {
       await emailSchema.parseAsync(email);
       await sendPasswordResetEmail(this.auth, email);
     } catch (error) {
-      if (error instanceof z17.ZodError) {
+      if (error instanceof z18.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6617,7 +6720,7 @@ var AuthService = class extends BaseService {
       await passwordSchema.parseAsync(newPassword);
       await confirmPasswordReset(this.auth, oobCode, newPassword);
     } catch (error) {
-      if (error instanceof z17.ZodError) {
+      if (error instanceof z18.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
       const firebaseError = error;
@@ -6717,9 +6820,9 @@ var NotificationService = class extends BaseService {
       orderBy3("notificationTime", "desc")
     );
     const querySnapshot = await getDocs12(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
   /**
@@ -6733,9 +6836,9 @@ var NotificationService = class extends BaseService {
       orderBy3("notificationTime", "desc")
     );
     const querySnapshot = await getDocs12(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
   /**
@@ -6807,9 +6910,9 @@ var NotificationService = class extends BaseService {
       orderBy3("notificationTime", "desc")
     );
     const querySnapshot = await getDocs12(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
   /**
@@ -6822,9 +6925,9 @@ var NotificationService = class extends BaseService {
       orderBy3("notificationTime", "desc")
     );
     const querySnapshot = await getDocs12(q);
-    return querySnapshot.docs.map((doc29) => ({
-      id: doc29.id,
-      ...doc29.data()
+    return querySnapshot.docs.map((doc30) => ({
+      id: doc30.id,
+      ...doc30.data()
     }));
   }
 };
@@ -6850,59 +6953,59 @@ import {
 var PROCEDURES_COLLECTION = "procedures";
 
 // src/validations/procedure.schema.ts
-import { z as z18 } from "zod";
-var createProcedureSchema = z18.object({
-  name: z18.string().min(1).max(200),
-  description: z18.string().min(1).max(2e3),
-  family: z18.nativeEnum(ProcedureFamily),
-  categoryId: z18.string().min(1),
-  subcategoryId: z18.string().min(1),
-  technologyId: z18.string().min(1),
-  productId: z18.string().min(1),
-  price: z18.number().min(0),
-  currency: z18.nativeEnum(Currency),
-  pricingMeasure: z18.nativeEnum(PricingMeasure),
-  duration: z18.number().min(1).max(480),
+import { z as z19 } from "zod";
+var createProcedureSchema = z19.object({
+  name: z19.string().min(1).max(200),
+  description: z19.string().min(1).max(2e3),
+  family: z19.nativeEnum(ProcedureFamily),
+  categoryId: z19.string().min(1),
+  subcategoryId: z19.string().min(1),
+  technologyId: z19.string().min(1),
+  productId: z19.string().min(1),
+  price: z19.number().min(0),
+  currency: z19.nativeEnum(Currency),
+  pricingMeasure: z19.nativeEnum(PricingMeasure),
+  duration: z19.number().min(1).max(480),
   // Max 8 hours
-  practitionerId: z18.string().min(1),
-  clinicBranchId: z18.string().min(1)
+  practitionerId: z19.string().min(1),
+  clinicBranchId: z19.string().min(1)
 });
-var updateProcedureSchema = z18.object({
-  name: z18.string().min(3).max(100).optional(),
-  description: z18.string().min(3).max(1e3).optional(),
-  price: z18.number().min(0).optional(),
-  currency: z18.nativeEnum(Currency).optional(),
-  pricingMeasure: z18.nativeEnum(PricingMeasure).optional(),
-  duration: z18.number().min(0).optional(),
-  isActive: z18.boolean().optional(),
-  practitionerId: z18.string().optional(),
-  categoryId: z18.string().optional(),
-  subcategoryId: z18.string().optional(),
-  technologyId: z18.string().optional(),
-  productId: z18.string().optional(),
-  clinicBranchId: z18.string().optional()
+var updateProcedureSchema = z19.object({
+  name: z19.string().min(3).max(100).optional(),
+  description: z19.string().min(3).max(1e3).optional(),
+  price: z19.number().min(0).optional(),
+  currency: z19.nativeEnum(Currency).optional(),
+  pricingMeasure: z19.nativeEnum(PricingMeasure).optional(),
+  duration: z19.number().min(0).optional(),
+  isActive: z19.boolean().optional(),
+  practitionerId: z19.string().optional(),
+  categoryId: z19.string().optional(),
+  subcategoryId: z19.string().optional(),
+  technologyId: z19.string().optional(),
+  productId: z19.string().optional(),
+  clinicBranchId: z19.string().optional()
 });
 var procedureSchema = createProcedureSchema.extend({
-  id: z18.string().min(1),
-  category: z18.any(),
+  id: z19.string().min(1),
+  category: z19.any(),
   // We'll validate the full category object separately
-  subcategory: z18.any(),
+  subcategory: z19.any(),
   // We'll validate the full subcategory object separately
-  technology: z18.any(),
+  technology: z19.any(),
   // We'll validate the full technology object separately
-  product: z18.any(),
+  product: z19.any(),
   // We'll validate the full product object separately
-  blockingConditions: z18.array(z18.any()),
+  blockingConditions: z19.array(z19.any()),
   // We'll validate blocking conditions separately
-  treatmentBenefits: z18.array(z18.any()),
+  treatmentBenefits: z19.array(z19.any()),
   // We'll validate treatment benefits separately
-  preRequirements: z18.array(z18.any()),
+  preRequirements: z19.array(z19.any()),
   // We'll validate requirements separately
-  postRequirements: z18.array(z18.any()),
+  postRequirements: z19.array(z19.any()),
   // We'll validate requirements separately
-  certificationRequirement: z18.any(),
+  certificationRequirement: z19.any(),
   // We'll validate certification requirement separately
-  documentationTemplates: z18.array(z18.any()),
+  documentationTemplates: z19.array(z19.any()),
   // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema,
   // Clinic info validation
@@ -6910,9 +7013,9 @@ var procedureSchema = createProcedureSchema.extend({
   // Doctor info validation
   reviewInfo: procedureReviewInfoSchema,
   // Procedure review info validation
-  isActive: z18.boolean(),
-  createdAt: z18.date(),
-  updatedAt: z18.date()
+  isActive: z19.boolean(),
+  createdAt: z19.date(),
+  updatedAt: z19.date()
 });
 
 // src/services/procedure/procedure.service.ts
@@ -7055,7 +7158,7 @@ var ProcedureService = class extends BaseService {
       where13("isActive", "==", true)
     );
     const snapshot = await getDocs13(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all procedures for a practitioner
@@ -7069,7 +7172,7 @@ var ProcedureService = class extends BaseService {
       where13("isActive", "==", true)
     );
     const snapshot = await getDocs13(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Updates a procedure
@@ -7252,20 +7355,20 @@ var ProcedureService = class extends BaseService {
       const proceduresCollection = collection13(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = query13(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 = query13(
             proceduresCollection,
             orderBy4("name"),
             // Use imported orderBy
-            startAfter8(lastDoc),
-            limit8(pagination)
+            startAfter9(lastDoc),
+            limit9(pagination)
           );
         } else {
           proceduresQuery = query13(
             proceduresCollection,
             orderBy4("name"),
-            limit8(pagination)
+            limit9(pagination)
           );
         }
       } else {
@@ -7273,11 +7376,11 @@ var ProcedureService = class extends BaseService {
       }
       const proceduresSnapshot = await getDocs13(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
         };
       });
@@ -7359,8 +7462,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 = distanceBetween6(
               [center.latitude, center.longitude],
               [
@@ -7411,8 +7514,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;
@@ -7643,9 +7746,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await getDocs14(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,
@@ -7673,9 +7776,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await getDocs14(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,
@@ -7702,9 +7805,9 @@ var DocumentationTemplateService = class extends BaseService {
     const querySnapshot = await getDocs14(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,
@@ -7829,9 +7932,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs15(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,
@@ -7858,9 +7961,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs15(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,
@@ -7887,9 +7990,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs15(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,
@@ -7916,9 +8019,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs15(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,
@@ -7945,9 +8048,9 @@ var FilledDocumentService = class extends BaseService {
     const querySnapshot = await getDocs15(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,
@@ -7981,42 +8084,42 @@ import {
 } from "firebase/firestore";
 
 // src/validations/calendar.schema.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 import { Timestamp as Timestamp18 } from "firebase/firestore";
 
 // src/validations/profile-info.schema.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 import { Timestamp as Timestamp17 } from "firebase/firestore";
-var clinicInfoSchema2 = z19.object({
-  id: z19.string(),
-  featuredPhoto: z19.string(),
-  name: z19.string(),
-  description: z19.string(),
+var clinicInfoSchema2 = z20.object({
+  id: z20.string(),
+  featuredPhoto: z20.string(),
+  name: z20.string(),
+  description: z20.string(),
   location: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema
 });
-var practitionerProfileInfoSchema = z19.object({
-  id: z19.string(),
-  practitionerPhoto: z19.string().nullable(),
-  name: z19.string(),
-  email: z19.string().email(),
-  phone: z19.string().nullable(),
+var practitionerProfileInfoSchema = z20.object({
+  id: z20.string(),
+  practitionerPhoto: z20.string().nullable(),
+  name: z20.string(),
+  email: z20.string().email(),
+  phone: z20.string().nullable(),
   certification: practitionerCertificationSchema
 });
-var patientProfileInfoSchema = z19.object({
-  id: z19.string(),
-  fullName: z19.string(),
-  email: z19.string().email(),
-  phone: z19.string().nullable(),
-  dateOfBirth: z19.instanceof(Timestamp17),
-  gender: z19.nativeEnum(Gender)
+var patientProfileInfoSchema = z20.object({
+  id: z20.string(),
+  fullName: z20.string(),
+  email: z20.string().email(),
+  phone: z20.string().nullable(),
+  dateOfBirth: z20.instanceof(Timestamp17),
+  gender: z20.nativeEnum(Gender)
 });
 
 // src/validations/calendar.schema.ts
 var MIN_APPOINTMENT_DURATION = 15;
-var calendarEventTimeSchema = z20.object({
-  start: z20.instanceof(Date).or(z20.instanceof(Timestamp18)),
-  end: z20.instanceof(Date).or(z20.instanceof(Timestamp18))
+var calendarEventTimeSchema = z21.object({
+  start: z21.instanceof(Date).or(z21.instanceof(Timestamp18)),
+  end: z21.instanceof(Date).or(z21.instanceof(Timestamp18))
 }).refine(
   (data) => {
     const startDate = data.start instanceof Timestamp18 ? data.start.toDate() : data.start;
@@ -8037,46 +8140,46 @@ var calendarEventTimeSchema = z20.object({
     path: ["start"]
   }
 );
-var timeSlotSchema2 = z20.object({
-  start: z20.date(),
-  end: z20.date(),
-  isAvailable: z20.boolean()
+var timeSlotSchema2 = z21.object({
+  start: z21.date(),
+  end: z21.date(),
+  isAvailable: z21.boolean()
 }).refine((data) => data.start < data.end, {
   message: "End time must be after start time",
   path: ["end"]
 });
-var syncedCalendarEventSchema = z20.object({
-  eventId: z20.string(),
-  syncedCalendarProvider: z20.nativeEnum(SyncedCalendarProvider),
-  syncedAt: z20.instanceof(Date).or(z20.instanceof(Timestamp18))
+var syncedCalendarEventSchema = z21.object({
+  eventId: z21.string(),
+  syncedCalendarProvider: z21.nativeEnum(SyncedCalendarProvider),
+  syncedAt: z21.instanceof(Date).or(z21.instanceof(Timestamp18))
 });
-var procedureInfoSchema = z20.object({
-  name: z20.string(),
-  description: z20.string(),
-  duration: z20.number().min(MIN_APPOINTMENT_DURATION),
-  price: z20.number().min(0),
-  currency: z20.nativeEnum(Currency)
+var procedureInfoSchema = z21.object({
+  name: z21.string(),
+  description: z21.string(),
+  duration: z21.number().min(MIN_APPOINTMENT_DURATION),
+  price: z21.number().min(0),
+  currency: z21.nativeEnum(Currency)
 });
-var procedureCategorizationSchema = z20.object({
-  procedureFamily: z20.string(),
+var procedureCategorizationSchema = z21.object({
+  procedureFamily: z21.string(),
   // Replace with proper enum when available
-  procedureCategory: z20.string(),
+  procedureCategory: z21.string(),
   // Replace with proper enum when available
-  procedureSubcategory: z20.string(),
+  procedureSubcategory: z21.string(),
   // Replace with proper enum when available
-  procedureTechnology: z20.string(),
+  procedureTechnology: z21.string(),
   // Replace with proper enum when available
-  procedureProduct: z20.string()
+  procedureProduct: z21.string()
   // Replace with proper enum when available
 });
-var createAppointmentSchema = z20.object({
-  clinicId: z20.string().min(1, "Clinic ID is required"),
-  doctorId: z20.string().min(1, "Doctor ID is required"),
-  patientId: z20.string().min(1, "Patient ID is required"),
-  procedureId: z20.string().min(1, "Procedure ID is required"),
+var createAppointmentSchema2 = z21.object({
+  clinicId: z21.string().min(1, "Clinic ID is required"),
+  doctorId: z21.string().min(1, "Doctor ID is required"),
+  patientId: z21.string().min(1, "Patient ID is required"),
+  procedureId: z21.string().min(1, "Procedure ID is required"),
   eventLocation: clinicLocationSchema,
   eventTime: calendarEventTimeSchema,
-  description: z20.string().optional()
+  description: z21.string().optional()
 }).refine(
   (data) => {
     return true;
@@ -8085,73 +8188,73 @@ var createAppointmentSchema = z20.object({
     message: "Invalid appointment parameters"
   }
 );
-var updateAppointmentSchema = z20.object({
-  appointmentId: z20.string().min(1, "Appointment ID is required"),
-  clinicId: z20.string().min(1, "Clinic ID is required"),
-  doctorId: z20.string().min(1, "Doctor ID is required"),
-  patientId: z20.string().min(1, "Patient ID is required"),
+var updateAppointmentSchema2 = z21.object({
+  appointmentId: z21.string().min(1, "Appointment ID is required"),
+  clinicId: z21.string().min(1, "Clinic ID is required"),
+  doctorId: z21.string().min(1, "Doctor ID is required"),
+  patientId: z21.string().min(1, "Patient ID is required"),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z20.string().optional(),
-  status: z20.nativeEnum(CalendarEventStatus).optional()
+  description: z21.string().optional(),
+  status: z21.nativeEnum(CalendarEventStatus).optional()
 });
-var createCalendarEventSchema = z20.object({
-  id: z20.string(),
-  clinicBranchId: z20.string().nullable().optional(),
-  clinicBranchInfo: z20.any().nullable().optional(),
-  practitionerProfileId: z20.string().nullable().optional(),
+var createCalendarEventSchema = z21.object({
+  id: z21.string(),
+  clinicBranchId: z21.string().nullable().optional(),
+  clinicBranchInfo: z21.any().nullable().optional(),
+  practitionerProfileId: z21.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z20.string().nullable().optional(),
+  patientProfileId: z21.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z20.string().nullable().optional(),
-  appointmentId: z20.string().nullable().optional(),
-  syncedCalendarEventId: z20.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: z20.string().min(1, "Event name is required"),
+  procedureId: z21.string().nullable().optional(),
+  appointmentId: z21.string().nullable().optional(),
+  syncedCalendarEventId: z21.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z21.string().min(1, "Event name is required"),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: z20.string().optional(),
-  status: z20.nativeEnum(CalendarEventStatus),
-  syncStatus: z20.nativeEnum(CalendarSyncStatus),
-  eventType: z20.nativeEnum(CalendarEventType),
-  createdAt: z20.any(),
+  description: z21.string().optional(),
+  status: z21.nativeEnum(CalendarEventStatus),
+  syncStatus: z21.nativeEnum(CalendarSyncStatus),
+  eventType: z21.nativeEnum(CalendarEventType),
+  createdAt: z21.any(),
   // FieldValue for server timestamp
-  updatedAt: z20.any()
+  updatedAt: z21.any()
   // FieldValue for server timestamp
 });
-var updateCalendarEventSchema = z20.object({
-  syncedCalendarEventId: z20.array(syncedCalendarEventSchema).nullable().optional(),
-  appointmentId: z20.string().nullable().optional(),
-  eventName: z20.string().optional(),
+var updateCalendarEventSchema = z21.object({
+  syncedCalendarEventId: z21.array(syncedCalendarEventSchema).nullable().optional(),
+  appointmentId: z21.string().nullable().optional(),
+  eventName: z21.string().optional(),
   eventTime: calendarEventTimeSchema.optional(),
-  description: z20.string().optional(),
-  status: z20.nativeEnum(CalendarEventStatus).optional(),
-  syncStatus: z20.nativeEnum(CalendarSyncStatus).optional(),
-  eventType: z20.nativeEnum(CalendarEventType).optional(),
-  updatedAt: z20.any()
+  description: z21.string().optional(),
+  status: z21.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: z21.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: z21.nativeEnum(CalendarEventType).optional(),
+  updatedAt: z21.any()
   // FieldValue for server timestamp
 });
-var calendarEventSchema = z20.object({
-  id: z20.string(),
-  clinicBranchId: z20.string().nullable().optional(),
-  clinicBranchInfo: z20.any().nullable().optional(),
+var calendarEventSchema = z21.object({
+  id: z21.string(),
+  clinicBranchId: z21.string().nullable().optional(),
+  clinicBranchInfo: z21.any().nullable().optional(),
   // Will be replaced with proper clinic info schema
-  practitionerProfileId: z20.string().nullable().optional(),
+  practitionerProfileId: z21.string().nullable().optional(),
   practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
-  patientProfileId: z20.string().nullable().optional(),
+  patientProfileId: z21.string().nullable().optional(),
   patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
-  procedureId: z20.string().nullable().optional(),
+  procedureId: z21.string().nullable().optional(),
   procedureInfo: procedureInfoSchema.nullable().optional(),
   procedureCategorization: procedureCategorizationSchema.nullable().optional(),
-  appointmentId: z20.string().nullable().optional(),
-  syncedCalendarEventId: z20.array(syncedCalendarEventSchema).nullable().optional(),
-  eventName: z20.string(),
+  appointmentId: z21.string().nullable().optional(),
+  syncedCalendarEventId: z21.array(syncedCalendarEventSchema).nullable().optional(),
+  eventName: z21.string(),
   eventLocation: clinicLocationSchema.optional(),
   eventTime: calendarEventTimeSchema,
-  description: z20.string().optional(),
-  status: z20.nativeEnum(CalendarEventStatus),
-  syncStatus: z20.nativeEnum(CalendarSyncStatus),
-  eventType: z20.nativeEnum(CalendarEventType),
-  createdAt: z20.instanceof(Date).or(z20.instanceof(Timestamp18)),
-  updatedAt: z20.instanceof(Date).or(z20.instanceof(Timestamp18))
+  description: z21.string().optional(),
+  status: z21.nativeEnum(CalendarEventStatus),
+  syncStatus: z21.nativeEnum(CalendarSyncStatus),
+  eventType: z21.nativeEnum(CalendarEventType),
+  createdAt: z21.instanceof(Date).or(z21.instanceof(Timestamp18)),
+  updatedAt: z21.instanceof(Date).or(z21.instanceof(Timestamp18))
 });
 
 // src/services/calendar/utils/clinic.utils.ts
@@ -8503,7 +8606,7 @@ async function searchCalendarEventsUtil(db, params) {
     const finalQuery = query19(collectionRef, ...constraints);
     const querySnapshot = await getDocs19(finalQuery);
     const events = querySnapshot.docs.map(
-      (doc29) => ({ id: doc29.id, ...doc29.data() })
+      (doc30) => ({ id: doc30.id, ...doc30.data() })
     );
     return events;
   } catch (error) {
@@ -8596,7 +8699,7 @@ async function getPractitionerSyncedCalendarsUtil(db, practitionerId) {
   );
   const q = query20(calendarsRef, orderBy11("createdAt", "desc"));
   const querySnapshot = await getDocs20(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);
@@ -8613,7 +8716,7 @@ async function getPatientSyncedCalendarsUtil(db, patientId) {
   );
   const q = query20(calendarsRef, orderBy11("createdAt", "desc"));
   const querySnapshot = await getDocs20(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);
@@ -8630,7 +8733,7 @@ async function getClinicSyncedCalendarsUtil(db, clinicId) {
   );
   const q = query20(calendarsRef, orderBy11("createdAt", "desc"));
   const querySnapshot = await getDocs20(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(
@@ -9985,9 +10088,9 @@ var CalendarServiceV2 = class extends BaseService {
         where21("eventTime.start", "<=", Timestamp25.fromDate(endDate))
       );
       const eventsSnapshot = await getDocs21(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
@@ -10254,7 +10357,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
@@ -10536,7 +10639,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
@@ -10619,7 +10722,7 @@ var CalendarServiceV2 = class extends BaseService {
       ])
     );
     const querySnapshot = await getDocs21(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
@@ -10762,7 +10865,7 @@ import {
 var REVIEWS_COLLECTION = "reviews";
 
 // src/services/reviews/reviews.service.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
@@ -10868,7 +10971,7 @@ var ReviewService = class extends BaseService {
       await Promise.all(updatePromises);
       return review;
     } catch (error) {
-      if (error instanceof z21.ZodError) {
+      if (error instanceof z22.ZodError) {
         throw new Error(`Invalid review data: ${error.message}`);
       }
       throw error;
@@ -10898,7 +11001,7 @@ var ReviewService = class extends BaseService {
       where22("patientId", "==", patientId)
     );
     const snapshot = await getDocs22(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific clinic
@@ -10911,7 +11014,7 @@ var ReviewService = class extends BaseService {
       where22("clinicReview.clinicId", "==", clinicId)
     );
     const snapshot = await getDocs22(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific practitioner
@@ -10924,7 +11027,7 @@ var ReviewService = class extends BaseService {
       where22("practitionerReview.practitionerId", "==", practitionerId)
     );
     const snapshot = await getDocs22(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific procedure
@@ -10937,7 +11040,7 @@ var ReviewService = class extends BaseService {
       where22("procedureReview.procedureId", "==", procedureId)
     );
     const snapshot = await getDocs22(q);
-    return snapshot.docs.map((doc29) => doc29.data());
+    return snapshot.docs.map((doc30) => doc30.data());
   }
   /**
    * Gets all reviews for a specific appointment
@@ -11364,95 +11467,850 @@ var ReviewService = class extends BaseService {
   }
 };
 
-// src/backoffice/services/brand.service.ts
+// src/services/appointment/appointment.service.ts
+import {
+  Timestamp as Timestamp28
+} from "firebase/firestore";
+import { getFunctions, httpsCallable } from "firebase/functions";
+
+// src/services/appointment/utils/appointment.utils.ts
 import {
-  addDoc as addDoc3,
   collection as collection23,
   doc as doc24,
   getDoc as getDoc26,
   getDocs as getDocs23,
   query as query23,
+  where as where23,
+  setDoc as setDoc23,
   updateDoc as updateDoc25,
-  where as where23
+  serverTimestamp as serverTimestamp23,
+  Timestamp as Timestamp27,
+  orderBy as orderBy12,
+  limit as limit8,
+  startAfter as startAfter8
 } from "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 collection23(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([
+      getDoc26(doc24(db, CLINICS_COLLECTION, clinicId)),
+      getDoc26(doc24(db, PRACTITIONERS_COLLECTION, practitionerId)),
+      getDoc26(doc24(db, PATIENTS_COLLECTION, patientId)),
+      getDoc26(doc24(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 addDoc3(this.getBrandsRef(), newBrand);
-    return { id: docRef.id, ...newBrand };
-  }
-  /**
-   * Gets all active brands
-   */
-  async getAll() {
-    const q = query23(this.getBrandsRef(), where23("isActive", "==", true));
-    const snapshot = await getDocs23(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 = doc24(this.getBrandsRef(), brandId);
-    await updateDoc25(docRef, updateData);
-    return this.getById(brandId);
+    const patientInfo = {
+      id: patientId,
+      fullName: patientData.displayName || "",
+      email: patientData.email || "",
+      phone: patientData.phoneNumber || null,
+      dateOfBirth: patientData.dateOfBirth || Timestamp27.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 getDoc26(
+        doc24(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: Timestamp27.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: serverTimestamp23(),
+      updatedAt: serverTimestamp23()
+    };
+    if (data.initialStatus === "confirmed" /* CONFIRMED */) {
+      appointment.confirmationTime = Timestamp27.now();
+    }
+    await setDoc23(doc24(db, APPOINTMENTS_COLLECTION, appointmentId), appointment);
+    const calendarEventRef = doc24(db, CALENDAR_COLLECTION, data.calendarEventId);
+    await updateDoc25(calendarEventRef, {
+      appointmentId,
+      updatedAt: serverTimestamp23()
     });
-  }
-  /**
-   * Gets a brand by ID
-   */
-  async getById(brandId) {
-    const docRef = doc24(this.getBrandsRef(), brandId);
-    const docSnap = await getDoc26(docRef);
-    if (!docSnap.exists()) return null;
+    const now = Timestamp27.now();
     return {
-      id: docSnap.id,
-      ...docSnap.data()
+      ...appointment,
+      createdAt: now,
+      updatedAt: now
     };
+  } catch (error) {
+    console.error("Error creating appointment:", error);
+    throw error;
   }
-};
-
-// src/backoffice/services/category.service.ts
-import {
-  addDoc as addDoc4,
-  collection as collection24,
-  doc as doc25,
+}
+async function updateAppointmentUtil2(db, appointmentId, data) {
+  try {
+    const appointmentRef = doc24(db, APPOINTMENTS_COLLECTION, appointmentId);
+    const appointmentDoc = await getDoc26(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: serverTimestamp23()
+    };
+    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 = Timestamp27.now();
+      }
+      if (currentAppointment.calendarEventId) {
+        await updateCalendarEventStatus(
+          db,
+          currentAppointment.calendarEventId,
+          data.status
+        );
+      }
+    }
+    await updateDoc25(appointmentRef, updateData);
+    const updatedAppointmentDoc = await getDoc26(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 = doc24(db, CALENDAR_COLLECTION, calendarEventId);
+    const calendarEventDoc = await getDoc26(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 updateDoc25(calendarEventRef, {
+      status: calendarStatus,
+      updatedAt: serverTimestamp23()
+    });
+  } catch (error) {
+    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+  }
+}
+async function getAppointmentByIdUtil(db, appointmentId) {
+  try {
+    const appointmentDoc = await getDoc26(
+      doc24(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(where23("patientId", "==", params.patientId));
+    }
+    if (params.practitionerId) {
+      constraints.push(where23("practitionerId", "==", params.practitionerId));
+    }
+    if (params.clinicBranchId) {
+      constraints.push(where23("clinicBranchId", "==", params.clinicBranchId));
+    }
+    if (params.startDate) {
+      constraints.push(
+        where23(
+          "appointmentStartTime",
+          ">=",
+          Timestamp27.fromDate(params.startDate)
+        )
+      );
+    }
+    if (params.endDate) {
+      constraints.push(
+        where23("appointmentStartTime", "<=", Timestamp27.fromDate(params.endDate))
+      );
+    }
+    if (params.status) {
+      if (Array.isArray(params.status)) {
+        constraints.push(where23("status", "in", params.status));
+      } else {
+        constraints.push(where23("status", "==", params.status));
+      }
+    }
+    constraints.push(orderBy12("appointmentStartTime", "asc"));
+    if (params.limit) {
+      constraints.push(limit8(params.limit));
+    }
+    if (params.startAfter) {
+      constraints.push(startAfter8(params.startAfter));
+    }
+    const q = query23(collection23(db, APPOINTMENTS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs23(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 = 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 = 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);
+  }
+  /**
+   * 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 = Timestamp28.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
+import {
+  addDoc as addDoc3,
+  collection as collection24,
+  doc as doc25,
   getDoc as getDoc27,
   getDocs as getDocs24,
   query as query24,
@@ -11460,6 +12318,90 @@ import {
   where as where24
 } from "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 collection24(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 addDoc3(this.getBrandsRef(), newBrand);
+    return { id: docRef.id, ...newBrand };
+  }
+  /**
+   * Gets all active brands
+   */
+  async getAll() {
+    const q = query24(this.getBrandsRef(), where24("isActive", "==", true));
+    const snapshot = await getDocs24(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 = doc25(this.getBrandsRef(), brandId);
+    await updateDoc26(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 = doc25(this.getBrandsRef(), brandId);
+    const docSnap = await getDoc27(docRef);
+    if (!docSnap.exists()) return null;
+    return {
+      id: docSnap.id,
+      ...docSnap.data()
+    };
+  }
+};
+
+// src/backoffice/services/category.service.ts
+import {
+  addDoc as addDoc4,
+  collection as collection25,
+  doc as doc26,
+  getDoc as getDoc28,
+  getDocs as getDocs25,
+  query as query25,
+  updateDoc as updateDoc27,
+  where as where25
+} from "firebase/firestore";
+
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
 
@@ -11469,7 +12411,7 @@ var CategoryService = class extends BaseService {
    * Referenca na Firestore kolekciju kategorija
    */
   get categoriesRef() {
-    return collection24(this.db, CATEGORIES_COLLECTION);
+    return collection25(this.db, CATEGORIES_COLLECTION);
   }
   /**
    * Kreira novu kategoriju u sistemu
@@ -11492,12 +12434,12 @@ var CategoryService = class extends BaseService {
    * @returns Lista aktivnih kategorija
    */
   async getAll() {
-    const q = query24(this.categoriesRef, where24("isActive", "==", true));
-    const snapshot = await getDocs24(q);
+    const q = query25(this.categoriesRef, where25("isActive", "==", true));
+    const snapshot = await getDocs25(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11507,16 +12449,16 @@ var CategoryService = class extends BaseService {
    * @returns Lista kategorija koje pripadaju traženoj familiji
    */
   async getAllByFamily(family) {
-    const q = query24(
+    const q = query25(
       this.categoriesRef,
-      where24("family", "==", family),
-      where24("isActive", "==", true)
+      where25("family", "==", family),
+      where25("isActive", "==", true)
     );
-    const snapshot = await getDocs24(q);
+    const snapshot = await getDocs25(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11531,8 +12473,8 @@ var CategoryService = class extends BaseService {
       ...category,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc25(this.categoriesRef, id);
-    await updateDoc26(docRef, updateData);
+    const docRef = doc26(this.categoriesRef, id);
+    await updateDoc27(docRef, updateData);
     return this.getById(id);
   }
   /**
@@ -11548,8 +12490,8 @@ var CategoryService = class extends BaseService {
    * @returns Kategorija ili null ako ne postoji
    */
   async getById(id) {
-    const docRef = doc25(this.categoriesRef, id);
-    const docSnap = await getDoc27(docRef);
+    const docRef = doc26(this.categoriesRef, id);
+    const docSnap = await getDoc28(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -11561,13 +12503,13 @@ var CategoryService = class extends BaseService {
 // src/backoffice/services/subcategory.service.ts
 import {
   addDoc as addDoc5,
-  collection as collection25,
-  doc as doc26,
-  getDoc as getDoc28,
-  getDocs as getDocs25,
-  query as query25,
-  updateDoc as updateDoc27,
-  where as where25
+  collection as collection26,
+  doc as doc27,
+  getDoc as getDoc29,
+  getDocs as getDocs26,
+  query as query26,
+  updateDoc as updateDoc28,
+  where as where26
 } from "firebase/firestore";
 
 // src/backoffice/types/subcategory.types.ts
@@ -11580,7 +12522,7 @@ var SubcategoryService = class extends BaseService {
    * @param categoryId - ID roditeljske kategorije
    */
   getSubcategoriesRef(categoryId) {
-    return collection25(
+    return collection26(
       this.db,
       CATEGORIES_COLLECTION,
       categoryId,
@@ -11614,15 +12556,15 @@ var SubcategoryService = class extends BaseService {
    * @returns Lista aktivnih podkategorija
    */
   async getAllByCategoryId(categoryId) {
-    const q = query25(
+    const q = query26(
       this.getSubcategoriesRef(categoryId),
-      where25("isActive", "==", true)
+      where26("isActive", "==", true)
     );
-    const snapshot = await getDocs25(q);
+    const snapshot = await getDocs26(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11638,8 +12580,8 @@ var SubcategoryService = class extends BaseService {
       ...subcategory,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc26(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await updateDoc27(docRef, updateData);
+    const docRef = doc27(this.getSubcategoriesRef(categoryId), subcategoryId);
+    await updateDoc28(docRef, updateData);
     return this.getById(categoryId, subcategoryId);
   }
   /**
@@ -11657,8 +12599,8 @@ var SubcategoryService = class extends BaseService {
    * @returns Podkategorija ili null ako ne postoji
    */
   async getById(categoryId, subcategoryId) {
-    const docRef = doc26(this.getSubcategoriesRef(categoryId), subcategoryId);
-    const docSnap = await getDoc28(docRef);
+    const docRef = doc27(this.getSubcategoriesRef(categoryId), subcategoryId);
+    const docSnap = await getDoc29(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -11670,21 +12612,16 @@ var SubcategoryService = class extends BaseService {
 // src/backoffice/services/technology.service.ts
 import {
   addDoc as addDoc6,
-  collection as collection26,
-  doc as doc27,
-  getDoc as getDoc29,
-  getDocs as getDocs26,
-  query as query26,
-  updateDoc as updateDoc28,
-  where as where26,
+  collection as collection27,
+  doc as doc28,
+  getDoc as getDoc30,
+  getDocs as getDocs27,
+  query as query27,
+  updateDoc as updateDoc29,
+  where as where27,
   arrayUnion as arrayUnion8,
   arrayRemove as arrayRemove7
 } from "firebase/firestore";
-
-// src/backoffice/types/technology.types.ts
-var TECHNOLOGIES_COLLECTION = "technologies";
-
-// src/backoffice/services/technology.service.ts
 var DEFAULT_CERTIFICATION_REQUIREMENT = {
   minimumLevel: "aesthetician" /* AESTHETICIAN */,
   requiredSpecialties: []
@@ -11694,7 +12631,7 @@ var TechnologyService = class extends BaseService {
    * Vraća referencu na Firestore kolekciju tehnologija
    */
   getTechnologiesRef() {
-    return collection26(this.db, TECHNOLOGIES_COLLECTION);
+    return collection27(this.db, TECHNOLOGIES_COLLECTION);
   }
   /**
    * Kreira novu tehnologiju
@@ -11725,12 +12662,12 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAll() {
-    const q = query26(this.getTechnologiesRef(), where26("isActive", "==", true));
-    const snapshot = await getDocs26(q);
+    const q = query27(this.getTechnologiesRef(), where27("isActive", "==", true));
+    const snapshot = await getDocs27(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11740,16 +12677,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByFamily(family) {
-    const q = query26(
+    const q = query27(
       this.getTechnologiesRef(),
-      where26("isActive", "==", true),
-      where26("family", "==", family)
+      where27("isActive", "==", true),
+      where27("family", "==", family)
     );
-    const snapshot = await getDocs26(q);
+    const snapshot = await getDocs27(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11759,16 +12696,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllByCategoryId(categoryId) {
-    const q = query26(
+    const q = query27(
       this.getTechnologiesRef(),
-      where26("isActive", "==", true),
-      where26("categoryId", "==", categoryId)
+      where27("isActive", "==", true),
+      where27("categoryId", "==", categoryId)
     );
-    const snapshot = await getDocs26(q);
+    const snapshot = await getDocs27(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11778,16 +12715,16 @@ var TechnologyService = class extends BaseService {
    * @returns Lista aktivnih tehnologija
    */
   async getAllBySubcategoryId(subcategoryId) {
-    const q = query26(
+    const q = query27(
       this.getTechnologiesRef(),
-      where26("isActive", "==", true),
-      where26("subcategoryId", "==", subcategoryId)
+      where27("isActive", "==", true),
+      where27("subcategoryId", "==", subcategoryId)
     );
-    const snapshot = await getDocs26(q);
+    const snapshot = await getDocs27(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -11802,8 +12739,8 @@ var TechnologyService = class extends BaseService {
       ...technology,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, updateData);
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, updateData);
     return this.getById(technologyId);
   }
   /**
@@ -11821,8 +12758,8 @@ var TechnologyService = class extends BaseService {
    * @returns Tehnologija ili null ako ne postoji
    */
   async getById(technologyId) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    const docSnap = await getDoc29(docRef);
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    const docSnap = await getDoc30(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -11836,9 +12773,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija sa novim zahtevom
    */
   async addRequirement(technologyId, requirement) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await updateDoc28(docRef, {
+    await updateDoc29(docRef, {
       [requirementType]: arrayUnion8(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11851,9 +12788,9 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija bez uklonjenog zahteva
    */
   async removeRequirement(technologyId, requirement) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
     const requirementType = requirement.type === "pre" ? "requirements.pre" : "requirements.post";
-    await updateDoc28(docRef, {
+    await updateDoc29(docRef, {
       [requirementType]: arrayRemove7(requirement),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11891,8 +12828,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBlockingCondition(technologyId, condition) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       blockingConditions: arrayUnion8(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11905,8 +12842,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBlockingCondition(technologyId, condition) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       blockingConditions: arrayRemove7(condition),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11919,8 +12856,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addContraindication(technologyId, contraindication) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       contraindications: arrayUnion8(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11933,8 +12870,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeContraindication(technologyId, contraindication) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       contraindications: arrayRemove7(contraindication),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11947,8 +12884,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async addBenefit(technologyId, benefit) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       benefits: arrayUnion8(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -11961,8 +12898,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async removeBenefit(technologyId, benefit) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       benefits: arrayRemove7(benefit),
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -12002,8 +12939,8 @@ var TechnologyService = class extends BaseService {
    * @returns Ažurirana tehnologija
    */
   async updateCertificationRequirement(technologyId, certificationRequirement) {
-    const docRef = doc27(this.getTechnologiesRef(), technologyId);
-    await updateDoc28(docRef, {
+    const docRef = doc28(this.getTechnologiesRef(), technologyId);
+    await updateDoc29(docRef, {
       certificationRequirement,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -12105,13 +13042,13 @@ var TechnologyService = class extends BaseService {
 // src/backoffice/services/product.service.ts
 import {
   addDoc as addDoc7,
-  collection as collection27,
-  doc as doc28,
-  getDoc as getDoc30,
-  getDocs as getDocs27,
-  query as query27,
-  updateDoc as updateDoc29,
-  where as where27
+  collection as collection28,
+  doc as doc29,
+  getDoc as getDoc31,
+  getDocs as getDocs28,
+  query as query28,
+  updateDoc as updateDoc30,
+  where as where28
 } from "firebase/firestore";
 
 // src/backoffice/types/product.types.ts
@@ -12125,7 +13062,7 @@ var ProductService = class extends BaseService {
    * @returns Firestore collection reference
    */
   getProductsRef(technologyId) {
-    return collection27(
+    return collection28(
       this.db,
       TECHNOLOGIES_COLLECTION,
       technologyId,
@@ -12155,15 +13092,15 @@ var ProductService = class extends BaseService {
    * Gets all products for a technology
    */
   async getAllByTechnology(technologyId) {
-    const q = query27(
+    const q = query28(
       this.getProductsRef(technologyId),
-      where27("isActive", "==", true)
+      where28("isActive", "==", true)
     );
-    const snapshot = await getDocs27(q);
+    const snapshot = await getDocs28(q);
     return snapshot.docs.map(
-      (doc29) => ({
-        id: doc29.id,
-        ...doc29.data()
+      (doc30) => ({
+        id: doc30.id,
+        ...doc30.data()
       })
     );
   }
@@ -12171,21 +13108,21 @@ var ProductService = class extends BaseService {
    * Gets all products for a brand by filtering through all technologies
    */
   async getAllByBrand(brandId) {
-    const allTechnologiesRef = collection27(this.db, TECHNOLOGIES_COLLECTION);
-    const technologiesSnapshot = await getDocs27(allTechnologiesRef);
+    const allTechnologiesRef = collection28(this.db, TECHNOLOGIES_COLLECTION);
+    const technologiesSnapshot = await getDocs28(allTechnologiesRef);
     const products = [];
     for (const techDoc of technologiesSnapshot.docs) {
-      const q = query27(
+      const q = query28(
         this.getProductsRef(techDoc.id),
-        where27("brandId", "==", brandId),
-        where27("isActive", "==", true)
+        where28("brandId", "==", brandId),
+        where28("isActive", "==", true)
       );
-      const snapshot = await getDocs27(q);
+      const snapshot = await getDocs28(q);
       products.push(
         ...snapshot.docs.map(
-          (doc29) => ({
-            id: doc29.id,
-            ...doc29.data()
+          (doc30) => ({
+            id: doc30.id,
+            ...doc30.data()
           })
         )
       );
@@ -12200,8 +13137,8 @@ var ProductService = class extends BaseService {
       ...product,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const docRef = doc28(this.getProductsRef(technologyId), productId);
-    await updateDoc29(docRef, updateData);
+    const docRef = doc29(this.getProductsRef(technologyId), productId);
+    await updateDoc30(docRef, updateData);
     return this.getById(technologyId, productId);
   }
   /**
@@ -12216,8 +13153,8 @@ var ProductService = class extends BaseService {
    * Gets a product by ID
    */
   async getById(technologyId, productId) {
-    const docRef = doc28(this.getProductsRef(technologyId), productId);
-    const docSnap = await getDoc30(docRef);
+    const docRef = doc29(this.getProductsRef(technologyId), productId);
+    const docSnap = await getDoc31(docRef);
     if (!docSnap.exists()) return null;
     return {
       id: docSnap.id,
@@ -12227,54 +13164,54 @@ var ProductService = class extends BaseService {
 };
 
 // src/validations/notification.schema.ts
-import { z as z22 } from "zod";
-var baseNotificationSchema = z22.object({
-  id: z22.string().optional(),
-  userId: z22.string(),
-  notificationTime: z22.any(),
+import { z as z23 } from "zod";
+var baseNotificationSchema = z23.object({
+  id: z23.string().optional(),
+  userId: z23.string(),
+  notificationTime: z23.any(),
   // Timestamp
-  notificationType: z22.nativeEnum(NotificationType),
-  notificationTokens: z22.array(z22.string()),
-  status: z22.nativeEnum(NotificationStatus),
-  createdAt: z22.any().optional(),
+  notificationType: z23.nativeEnum(NotificationType),
+  notificationTokens: z23.array(z23.string()),
+  status: z23.nativeEnum(NotificationStatus),
+  createdAt: z23.any().optional(),
   // Timestamp
-  updatedAt: z22.any().optional(),
+  updatedAt: z23.any().optional(),
   // Timestamp
-  title: z22.string(),
-  body: z22.string(),
-  isRead: z22.boolean(),
-  userRole: z22.nativeEnum(UserRole)
+  title: z23.string(),
+  body: z23.string(),
+  isRead: z23.boolean(),
+  userRole: z23.nativeEnum(UserRole)
 });
 var preRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z22.literal("preRequirement" /* PRE_REQUIREMENT */),
-  treatmentId: z22.string(),
-  requirements: z22.array(z22.string()),
-  deadline: z22.any()
+  notificationType: z23.literal("preRequirement" /* PRE_REQUIREMENT */),
+  treatmentId: z23.string(),
+  requirements: z23.array(z23.string()),
+  deadline: z23.any()
   // Timestamp
 });
 var postRequirementNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z22.literal("postRequirement" /* POST_REQUIREMENT */),
-  treatmentId: z22.string(),
-  requirements: z22.array(z22.string()),
-  deadline: z22.any()
+  notificationType: z23.literal("postRequirement" /* POST_REQUIREMENT */),
+  treatmentId: z23.string(),
+  requirements: z23.array(z23.string()),
+  deadline: z23.any()
   // Timestamp
 });
 var appointmentReminderNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z22.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
-  appointmentId: z22.string(),
-  appointmentTime: z22.any(),
+  notificationType: z23.literal("appointmentReminder" /* APPOINTMENT_REMINDER */),
+  appointmentId: z23.string(),
+  appointmentTime: z23.any(),
   // Timestamp
-  treatmentType: z22.string(),
-  doctorName: z22.string()
+  treatmentType: z23.string(),
+  doctorName: z23.string()
 });
 var appointmentNotificationSchema = baseNotificationSchema.extend({
-  notificationType: z22.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
-  appointmentId: z22.string(),
-  appointmentStatus: z22.string(),
-  previousStatus: z22.string(),
-  reason: z22.string().optional()
+  notificationType: z23.literal("appointmentNotification" /* APPOINTMENT_NOTIFICATION */),
+  appointmentId: z23.string(),
+  appointmentStatus: z23.string(),
+  previousStatus: z23.string(),
+  reason: z23.string().optional()
 });
-var notificationSchema = z22.discriminatedUnion("notificationType", [
+var notificationSchema = z23.discriminatedUnion("notificationType", [
   preRequirementNotificationSchema,
   postRequirementNotificationSchema,
   appointmentReminderNotificationSchema,
@@ -12313,9 +13250,12 @@ var RequirementType = /* @__PURE__ */ ((RequirementType2) => {
   return RequirementType2;
 })(RequirementType || {});
 export {
+  APPOINTMENTS_COLLECTION,
   AUTH_ERRORS,
   AdminTokenStatus,
   AllergyType,
+  AppointmentService,
+  AppointmentStatus,
   AuthService,
   BlockingCondition,
   BrandService,
@@ -12365,6 +13305,7 @@ export {
   PRACTITIONERS_COLLECTION,
   PROCEDURES_COLLECTION,
   PatientService,
+  PaymentStatus,
   PracticeType,
   PractitionerService,
   PractitionerStatus,
@@ -12479,6 +13420,7 @@ export {
   procedureSummaryInfoSchema,
   requesterInfoSchema,
   reviewSchema,
+  searchAppointmentsSchema,
   searchPatientsSchema,
   syncedCalendarEventSchema,
   timeSlotSchema2 as timeSlotSchema,