@blackcode_sa/metaestetics-api 1.7.19 → 1.7.21

package/dist/index.js

@@ -1096,7 +1096,7 @@ var BaseService = class {
 };
 
 // src/services/user.service.ts
-var import_firestore17 = require("firebase/firestore");
+var import_firestore19 = require("firebase/firestore");
 
 // src/errors/user.errors.ts
 var USER_ERRORS = {
@@ -1194,419 +1194,770 @@ var USER_ERRORS = {
 var import_zod16 = require("zod");
 
 // src/services/patient/patient.service.ts
-var import_firestore12 = require("firebase/firestore");
+var import_firestore14 = require("firebase/firestore");
 
-// src/services/patient/utils/profile.utils.ts
-var import_firestore8 = require("firebase/firestore");
+// src/services/media/media.service.ts
+var import_firestore2 = require("firebase/firestore");
 var import_storage3 = require("firebase/storage");
-var import_zod8 = require("zod");
-
-// src/types/patient/medical-info.types.ts
-var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
-var DEFAULT_MEDICAL_INFO = {
-  vitalStats: {},
-  blockingConditions: [],
-  contraindications: [],
-  allergies: [],
-  currentMedications: []
-};
-
-// src/types/patient/index.ts
-var PATIENTS_COLLECTION = "patients";
-var PATIENT_SENSITIVE_INFO_COLLECTION = "sensitive-info";
-var PATIENT_MEDICAL_HISTORY_COLLECTION = "medical-history";
-var PATIENT_APPOINTMENTS_COLLECTION = "appointments";
-var PATIENT_LOCATION_INFO_COLLECTION = "location-info";
-var Gender = /* @__PURE__ */ ((Gender2) => {
-  Gender2["MALE"] = "male";
-  Gender2["FEMALE"] = "female";
-  Gender2["TRANSGENDER_MALE"] = "transgender_male";
-  Gender2["TRANSGENDER_FEMALE"] = "transgender_female";
-  Gender2["PREFER_NOT_TO_SAY"] = "prefer_not_to_say";
-  Gender2["OTHER"] = "other";
-  return Gender2;
-})(Gender || {});
-
-// src/validations/patient.schema.ts
-var import_zod6 = require("zod");
 var import_firestore3 = require("firebase/firestore");
-
-// src/validations/patient/medical-info.schema.ts
-var import_zod5 = require("zod");
-
-// src/types/patient/allergies.ts
-var AllergyType = /* @__PURE__ */ ((AllergyType2) => {
-  AllergyType2["MEDICATION"] = "medication";
-  AllergyType2["FOOD"] = "food";
-  AllergyType2["ENVIRONMENTAL"] = "environmental";
-  AllergyType2["LATEX"] = "latex";
-  AllergyType2["COSMETIC"] = "cosmetic";
-  AllergyType2["OTHER"] = "other";
-  return AllergyType2;
-})(AllergyType || {});
-var MedicationAllergySubtype = /* @__PURE__ */ ((MedicationAllergySubtype2) => {
-  MedicationAllergySubtype2["ANTIBIOTICS"] = "antibiotics";
-  MedicationAllergySubtype2["NSAIDS"] = "nsaids";
-  MedicationAllergySubtype2["OPIOIDS"] = "opioids";
-  MedicationAllergySubtype2["ANESTHETICS"] = "anesthetics";
-  MedicationAllergySubtype2["VACCINES"] = "vaccines";
-  MedicationAllergySubtype2["OTHER"] = "other";
-  return MedicationAllergySubtype2;
-})(MedicationAllergySubtype || {});
-var FoodAllergySubtype = /* @__PURE__ */ ((FoodAllergySubtype2) => {
-  FoodAllergySubtype2["NUTS"] = "nuts";
-  FoodAllergySubtype2["SHELLFISH"] = "shellfish";
-  FoodAllergySubtype2["DAIRY"] = "dairy";
-  FoodAllergySubtype2["EGGS"] = "eggs";
-  FoodAllergySubtype2["WHEAT"] = "wheat";
-  FoodAllergySubtype2["SOY"] = "soy";
-  FoodAllergySubtype2["FISH"] = "fish";
-  FoodAllergySubtype2["FRUITS"] = "fruits";
-  FoodAllergySubtype2["OTHER"] = "other";
-  return FoodAllergySubtype2;
-})(FoodAllergySubtype || {});
-var EnvironmentalAllergySubtype = /* @__PURE__ */ ((EnvironmentalAllergySubtype2) => {
-  EnvironmentalAllergySubtype2["POLLEN"] = "pollen";
-  EnvironmentalAllergySubtype2["DUST"] = "dust";
-  EnvironmentalAllergySubtype2["MOLD"] = "mold";
-  EnvironmentalAllergySubtype2["PET_DANDER"] = "pet_dander";
-  EnvironmentalAllergySubtype2["INSECTS"] = "insects";
-  EnvironmentalAllergySubtype2["OTHER"] = "other";
-  return EnvironmentalAllergySubtype2;
-})(EnvironmentalAllergySubtype || {});
-var CosmeticAllergySubtype = /* @__PURE__ */ ((CosmeticAllergySubtype2) => {
-  CosmeticAllergySubtype2["FRAGRANCES"] = "fragrances";
-  CosmeticAllergySubtype2["PRESERVATIVES"] = "preservatives";
-  CosmeticAllergySubtype2["DYES"] = "dyes";
-  CosmeticAllergySubtype2["METALS"] = "metals";
-  CosmeticAllergySubtype2["OTHER"] = "other";
-  return CosmeticAllergySubtype2;
-})(CosmeticAllergySubtype || {});
-
-// src/backoffice/types/static/blocking-condition.types.ts
-var BlockingCondition = /* @__PURE__ */ ((BlockingCondition2) => {
-  BlockingCondition2["PREGNANCY"] = "pregnancy";
-  BlockingCondition2["BREASTFEEDING"] = "breastfeeding";
-  BlockingCondition2["ACTIVE_INFECTION"] = "active_infection";
-  BlockingCondition2["SKIN_CONDITION"] = "skin_condition";
-  BlockingCondition2["AUTOIMMUNE_DISEASE"] = "autoimmune_disease";
-  BlockingCondition2["BLOOD_THINNERS"] = "blood_thinners";
-  BlockingCondition2["RECENT_SURGERY"] = "recent_surgery";
-  BlockingCondition2["DIABETES"] = "diabetes";
-  BlockingCondition2["HEART_CONDITION"] = "heart_condition";
-  BlockingCondition2["HIGH_BLOOD_PRESSURE"] = "high_blood_pressure";
-  BlockingCondition2["KELOID_SCARRING"] = "keloid_scarring";
-  BlockingCondition2["METAL_IMPLANTS"] = "metal_implants";
-  BlockingCondition2["PACEMAKER"] = "pacemaker";
-  BlockingCondition2["CANCER"] = "cancer";
-  BlockingCondition2["EPILEPSY"] = "epilepsy";
-  return BlockingCondition2;
-})(BlockingCondition || {});
-
-// src/backoffice/types/static/contraindication.types.ts
-var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
-  Contraindication2["SENSITIVE_SKIN"] = "sensitive_skin";
-  Contraindication2["RECENT_TANNING"] = "recent_tanning";
-  Contraindication2["RECENT_BOTOX"] = "recent_botox";
-  Contraindication2["RECENT_FILLERS"] = "recent_fillers";
-  Contraindication2["SKIN_ALLERGIES"] = "skin_allergies";
-  Contraindication2["MEDICATIONS"] = "medications";
-  Contraindication2["RECENT_CHEMICAL_PEEL"] = "recent_chemical_peel";
-  Contraindication2["RECENT_LASER"] = "recent_laser";
-  Contraindication2["SKIN_INFLAMMATION"] = "skin_inflammation";
-  Contraindication2["OPEN_WOUNDS"] = "open_wounds";
-  Contraindication2["HERPES_SIMPLEX"] = "herpes_simplex";
-  Contraindication2["COLD_SORES"] = "cold_sores";
-  return Contraindication2;
-})(Contraindication || {});
-
-// src/validations/common.schema.ts
-var import_zod4 = require("zod");
-var import_firestore2 = require("firebase/firestore");
-var timestampSchema2 = import_zod4.z.union([
-  import_zod4.z.object({
-    seconds: import_zod4.z.number(),
-    nanoseconds: import_zod4.z.number()
-  }),
-  import_zod4.z.instanceof(import_firestore2.Timestamp)
-]).transform((data) => {
-  if (data instanceof import_firestore2.Timestamp) {
-    return data;
-  }
-  return new import_firestore2.Timestamp(data.seconds, data.nanoseconds);
-});
-
-// src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = import_zod5.z.union([
-  import_zod5.z.nativeEnum(MedicationAllergySubtype),
-  import_zod5.z.nativeEnum(FoodAllergySubtype),
-  import_zod5.z.nativeEnum(EnvironmentalAllergySubtype),
-  import_zod5.z.nativeEnum(CosmeticAllergySubtype),
-  import_zod5.z.literal("other")
-]);
-var allergySchema = import_zod5.z.object({
-  type: import_zod5.z.nativeEnum(AllergyType),
-  subtype: allergySubtypeSchema,
-  name: import_zod5.z.string().optional().nullable(),
-  severity: import_zod5.z.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: import_zod5.z.string().optional().nullable(),
-  diagnosed: timestampSchema2.optional().nullable(),
-  notes: import_zod5.z.string().optional().nullable()
-});
-var vitalStatsSchema = import_zod5.z.object({
-  height: import_zod5.z.number().positive().optional(),
-  weight: import_zod5.z.number().positive().optional(),
-  bloodType: import_zod5.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: import_zod5.z.object({
-    systolic: import_zod5.z.number().min(70).max(200),
-    diastolic: import_zod5.z.number().min(40).max(130),
-    lastMeasured: timestampSchema2
-  }).optional()
-});
-var blockingConditionSchema = import_zod5.z.object({
-  condition: import_zod5.z.nativeEnum(BlockingCondition),
-  diagnosedAt: timestampSchema2,
-  notes: import_zod5.z.string().optional().nullable(),
-  isActive: import_zod5.z.boolean()
-});
-var contraindicationSchema = import_zod5.z.object({
-  condition: import_zod5.z.nativeEnum(Contraindication),
-  lastOccurrence: timestampSchema2,
-  frequency: import_zod5.z.enum(["rare", "occasional", "frequent"]),
-  notes: import_zod5.z.string().optional().nullable(),
-  isActive: import_zod5.z.boolean()
-});
-var medicationSchema = import_zod5.z.object({
-  name: import_zod5.z.string().min(1),
-  dosage: import_zod5.z.string().min(1),
-  frequency: import_zod5.z.string().min(1),
-  startDate: timestampSchema2.optional().nullable(),
-  endDate: timestampSchema2.optional().nullable(),
-  prescribedBy: import_zod5.z.string().optional().nullable()
-});
-var patientMedicalInfoSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string(),
-  vitalStats: vitalStatsSchema,
-  blockingConditions: import_zod5.z.array(blockingConditionSchema),
-  contraindications: import_zod5.z.array(contraindicationSchema),
-  allergies: import_zod5.z.array(allergySchema),
-  currentMedications: import_zod5.z.array(medicationSchema),
-  emergencyNotes: import_zod5.z.string().optional(),
-  lastUpdated: timestampSchema2,
-  updatedBy: import_zod5.z.string(),
-  verifiedBy: import_zod5.z.string().optional(),
-  verifiedAt: timestampSchema2.optional()
-});
-var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
-  patientId: true,
-  lastUpdated: true,
-  updatedBy: true,
-  verifiedBy: true,
-  verifiedAt: true
-});
-var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
-var updateVitalStatsSchema = vitalStatsSchema;
-var addAllergySchema = allergySchema;
-var updateAllergySchema = allergySchema.partial().extend({
-  allergyIndex: import_zod5.z.number().min(0)
-});
-var addBlockingConditionSchema = blockingConditionSchema;
-var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: import_zod5.z.number().min(0)
-});
-var addContraindicationSchema = contraindicationSchema;
-var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: import_zod5.z.number().min(0)
-});
-var addMedicationSchema = medicationSchema;
-var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: import_zod5.z.number().min(0)
-});
-
-// src/validations/patient.schema.ts
-var locationDataSchema = import_zod6.z.object({
-  latitude: import_zod6.z.number().min(-90).max(90),
-  longitude: import_zod6.z.number().min(-180).max(180),
-  geohash: import_zod6.z.string().optional()
-});
-var addressDataSchema = import_zod6.z.object({
-  address: import_zod6.z.string(),
-  city: import_zod6.z.string(),
-  country: import_zod6.z.string(),
-  postalCode: import_zod6.z.string()
-});
-var emergencyContactSchema = import_zod6.z.object({
-  name: import_zod6.z.string(),
-  relationship: import_zod6.z.string(),
-  phoneNumber: import_zod6.z.string(),
-  isNotifiable: import_zod6.z.boolean()
-});
-var gamificationSchema = import_zod6.z.object({
-  level: import_zod6.z.number(),
-  points: import_zod6.z.number()
-});
-var patientLocationInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  locationData: locationDataSchema,
-  createdAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  updatedAt: import_zod6.z.instanceof(import_firestore3.Timestamp)
-});
-var createPatientLocationInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  locationData: locationDataSchema
-});
-var patientSensitiveInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  photoUrl: import_zod6.z.string().optional(),
-  firstName: import_zod6.z.string().min(2),
-  lastName: import_zod6.z.string().min(2),
-  dateOfBirth: import_zod6.z.instanceof(import_firestore3.Timestamp).nullable(),
-  gender: import_zod6.z.nativeEnum(Gender),
-  email: import_zod6.z.string().email().optional(),
-  phoneNumber: import_zod6.z.string().optional(),
-  alternativePhoneNumber: import_zod6.z.string().optional(),
-  addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod6.z.array(emergencyContactSchema).optional(),
-  createdAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  updatedAt: import_zod6.z.instanceof(import_firestore3.Timestamp)
-});
-var patientDoctorSchema = import_zod6.z.object({
-  userRef: import_zod6.z.string(),
-  assignedAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  assignedBy: import_zod6.z.string().optional(),
-  isActive: import_zod6.z.boolean(),
-  notes: import_zod6.z.string().optional()
-});
-var patientClinicSchema = import_zod6.z.object({
-  clinicId: import_zod6.z.string(),
-  assignedAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  assignedBy: import_zod6.z.string().optional(),
-  isActive: import_zod6.z.boolean(),
-  notes: import_zod6.z.string().optional()
-});
-var patientProfileSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  displayName: import_zod6.z.string(),
-  profilePhoto: import_zod6.z.string().url().nullable(),
-  gamification: gamificationSchema,
-  expoTokens: import_zod6.z.array(import_zod6.z.string()),
-  isActive: import_zod6.z.boolean(),
-  isVerified: import_zod6.z.boolean(),
-  doctors: import_zod6.z.array(patientDoctorSchema),
-  clinics: import_zod6.z.array(patientClinicSchema),
-  doctorIds: import_zod6.z.array(import_zod6.z.string()),
-  clinicIds: import_zod6.z.array(import_zod6.z.string()),
-  createdAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  updatedAt: import_zod6.z.instanceof(import_firestore3.Timestamp)
-});
-var createPatientProfileSchema = import_zod6.z.object({
-  userRef: import_zod6.z.string(),
-  displayName: import_zod6.z.string(),
-  profilePhoto: import_zod6.z.string().url().nullable().optional(),
-  expoTokens: import_zod6.z.array(import_zod6.z.string()),
-  gamification: gamificationSchema.optional(),
-  isActive: import_zod6.z.boolean(),
-  isVerified: import_zod6.z.boolean(),
-  doctors: import_zod6.z.array(patientDoctorSchema).optional(),
-  clinics: import_zod6.z.array(patientClinicSchema).optional(),
-  doctorIds: import_zod6.z.array(import_zod6.z.string()).optional(),
-  clinicIds: import_zod6.z.array(import_zod6.z.string()).optional()
-});
-var createPatientSensitiveInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  photoUrl: import_zod6.z.string().optional(),
-  firstName: import_zod6.z.string().min(2),
-  lastName: import_zod6.z.string().min(2),
-  dateOfBirth: import_zod6.z.instanceof(import_firestore3.Timestamp).nullable(),
-  gender: import_zod6.z.nativeEnum(Gender),
-  email: import_zod6.z.string().email().optional(),
-  phoneNumber: import_zod6.z.string().optional(),
-  alternativePhoneNumber: import_zod6.z.string().optional(),
-  addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod6.z.array(emergencyContactSchema).optional()
-});
-var searchPatientsSchema = import_zod6.z.object({
-  clinicId: import_zod6.z.string().optional(),
-  practitionerId: import_zod6.z.string().optional()
-}).refine((data) => data.clinicId || data.practitionerId, {
-  message: "At least one of clinicId or practitionerId must be provided",
-  path: []
-  // Optional: specify a path like ['clinicId'] or ['practitionerId']
-});
-var requesterInfoSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  role: import_zod6.z.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: import_zod6.z.string().optional(),
-  associatedPractitionerId: import_zod6.z.string().optional()
-}).refine(
-  (data) => {
-    if (data.role === "clinic_admin") {
-      return !!data.associatedClinicId;
-    } else if (data.role === "practitioner") {
-      return !!data.associatedPractitionerId;
-    }
-    return false;
-  },
-  {
-    message: "Associated ID (clinic or practitioner) is required based on role",
-    path: ["associatedClinicId", "associatedPractitionerId"]
+var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
+  MediaAccessLevel2["PUBLIC"] = "public";
+  MediaAccessLevel2["PRIVATE"] = "private";
+  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
+  return MediaAccessLevel2;
+})(MediaAccessLevel || {});
+var MEDIA_METADATA_COLLECTION = "media_metadata";
+var MediaService = class extends BaseService {
+  constructor(db, auth, app) {
+    super(db, auth, app);
   }
-);
-
-// src/services/patient/utils/docs.utils.ts
-var import_firestore5 = require("firebase/firestore");
-
-// src/services/patient/utils/sensitive.utils.ts
-var import_firestore4 = require("firebase/firestore");
-var import_zod7 = require("zod");
-var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
-  try {
-    if (data.userRef !== requesterUserId) {
-      throw new Error("Only patient can create their sensitive information");
-    }
-    const validatedData = createPatientSensitiveInfoSchema.parse(data);
-    const sensitiveDoc = await (0, import_firestore4.getDoc)(
-      getSensitiveInfoDocRef(db, data.patientId)
-    );
-    if (sensitiveDoc.exists()) {
-      throw new Error("Sensitive information already exists for this patient");
-    }
-    const sensitiveInfoData = {
-      ...validatedData,
-      createdAt: (0, import_firestore4.serverTimestamp)(),
-      updatedAt: (0, import_firestore4.serverTimestamp)()
-    };
-    await (0, import_firestore4.setDoc)(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
-    const createdDoc = await (0, import_firestore4.getDoc)(getSensitiveInfoDocRef(db, data.patientId));
-    if (!createdDoc.exists()) {
-      throw new Error("Failed to create sensitive information");
-    }
-    return createdDoc.data();
-  } catch (error) {
-    if (error instanceof import_zod7.z.ZodError) {
-      throw new Error("Invalid sensitive info data: " + error.message);
-    }
+  /**
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
+   */
+  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+    const storageRef = (0, import_storage3.ref)(this.storage, filePath);
+    try {
+      const uploadResult = await (0, import_storage3.uploadBytes)(storageRef, file, {
+        contentType: file.type
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await (0, import_storage3.getDownloadURL)(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+      const metadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: import_firestore2.Timestamp.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore3.setDoc)(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+      return metadata;
+    } catch (error) {
+      console.error("[MediaService] Error during media upload:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId) {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await (0, import_firestore3.getDoc)(docRef);
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data();
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url) {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = (0, import_firestore3.query)(
+      (0, import_firestore3.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      (0, import_firestore3.where)("url", "==", url),
+      (0, import_firestore3.limit)(1)
+    );
+    try {
+      const querySnapshot = await (0, import_firestore3.getDocs)(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data();
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
+      }
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
+    } catch (error) {
+      console.error("[MediaService] Error fetching metadata by URL:", error);
+      throw error;
+    }
+  }
+  /**
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
+   */
+  async deleteMedia(mediaId) {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
+      );
+      return;
+    }
+    const storageFileRef = (0, import_storage3.ref)(this.storage, metadata.path);
+    try {
+      await (0, import_storage3.deleteObject)(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore3.deleteDoc)(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+      );
+    } catch (error) {
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Update media access level. This involves moving the file in Firebase Storage
+   * to a new path reflecting the new access level, and updating its metadata.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata, or null if metadata not found.
+   */
+  async updateMediaAccessLevel(mediaId, newAccessLevel) {
+    var _a;
+    console.log(
+      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+    );
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+      );
+      return null;
+    }
+    if (metadata.accessLevel === newAccessLevel) {
+      console.log(
+        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
+      );
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      try {
+        await (0, import_firestore3.updateDoc)(metadataDocRef, { updatedAt: import_firestore2.Timestamp.now() });
+        return { ...metadata, updatedAt: import_firestore2.Timestamp.now() };
+      } catch (error) {
+        console.error(
+          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    const oldStoragePath = metadata.path;
+    const fileNamePart = `${metadata.id}-${metadata.name}`;
+    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+    console.log(
+      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+    );
+    const oldStorageFileRef = (0, import_storage3.ref)(this.storage, oldStoragePath);
+    const newStorageFileRef = (0, import_storage3.ref)(this.storage, newStoragePath);
+    try {
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await (0, import_storage3.getBytes)(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await (0, import_storage3.uploadBytes)(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await (0, import_storage3.getDownloadURL)(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
+      );
+      const updateData = {
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: import_firestore2.Timestamp.now()
+      };
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
+      );
+      await (0, import_firestore3.updateDoc)(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await (0, import_storage3.deleteObject)(oldStorageFileRef);
+        console.log(
+          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
+        );
+      } catch (deleteError) {
+        console.error(
+          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
+          deleteError
+        );
+      }
+      return { ...metadata, ...updateData };
+    } catch (error) {
+      console.error(
+        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
+        error
+      );
+      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
+        console.warn(
+          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
+        );
+        try {
+          await (0, import_storage3.deleteObject)(newStorageFileRef);
+          console.warn(
+            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
+          );
+        } catch (cleanupError) {
+          console.error(
+            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
+            cleanupError
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
+   */
+  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints = [(0, import_firestore3.where)("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push((0, import_firestore3.where)("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push((0, import_firestore3.where)("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push((0, import_firestore3.orderBy)("createdAt", "desc"));
+    if (count) {
+      qConstraints.push((0, import_firestore3.limit)(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = (0, import_firestore3.query)(
+      (0, import_firestore3.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+    try {
+      const querySnapshot = await (0, import_firestore3.getDocs)(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc34) => doc34.data()
+      );
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
+    } catch (error) {
+      console.error("[MediaService] Error listing media:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
+   */
+  async getMediaDownloadUrl(mediaId) {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
+    }
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
+  }
+};
+
+// src/services/patient/utils/profile.utils.ts
+var import_firestore10 = require("firebase/firestore");
+var import_zod9 = require("zod");
+
+// src/types/patient/medical-info.types.ts
+var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
+var DEFAULT_MEDICAL_INFO = {
+  vitalStats: {},
+  blockingConditions: [],
+  contraindications: [],
+  allergies: [],
+  currentMedications: []
+};
+
+// src/types/patient/index.ts
+var PATIENTS_COLLECTION = "patients";
+var PATIENT_SENSITIVE_INFO_COLLECTION = "sensitive-info";
+var PATIENT_MEDICAL_HISTORY_COLLECTION = "medical-history";
+var PATIENT_APPOINTMENTS_COLLECTION = "appointments";
+var PATIENT_LOCATION_INFO_COLLECTION = "location-info";
+var Gender = /* @__PURE__ */ ((Gender2) => {
+  Gender2["MALE"] = "male";
+  Gender2["FEMALE"] = "female";
+  Gender2["TRANSGENDER_MALE"] = "transgender_male";
+  Gender2["TRANSGENDER_FEMALE"] = "transgender_female";
+  Gender2["PREFER_NOT_TO_SAY"] = "prefer_not_to_say";
+  Gender2["OTHER"] = "other";
+  return Gender2;
+})(Gender || {});
+
+// src/validations/patient.schema.ts
+var import_zod7 = require("zod");
+var import_firestore5 = require("firebase/firestore");
+
+// src/validations/media.schema.ts
+var import_zod4 = require("zod");
+var mediaResourceSchema = import_zod4.z.union([
+  import_zod4.z.string().url(),
+  import_zod4.z.instanceof(File),
+  import_zod4.z.instanceof(Blob)
+]);
+
+// src/validations/patient/medical-info.schema.ts
+var import_zod6 = require("zod");
+
+// src/types/patient/allergies.ts
+var AllergyType = /* @__PURE__ */ ((AllergyType2) => {
+  AllergyType2["MEDICATION"] = "medication";
+  AllergyType2["FOOD"] = "food";
+  AllergyType2["ENVIRONMENTAL"] = "environmental";
+  AllergyType2["LATEX"] = "latex";
+  AllergyType2["COSMETIC"] = "cosmetic";
+  AllergyType2["OTHER"] = "other";
+  return AllergyType2;
+})(AllergyType || {});
+var MedicationAllergySubtype = /* @__PURE__ */ ((MedicationAllergySubtype2) => {
+  MedicationAllergySubtype2["ANTIBIOTICS"] = "antibiotics";
+  MedicationAllergySubtype2["NSAIDS"] = "nsaids";
+  MedicationAllergySubtype2["OPIOIDS"] = "opioids";
+  MedicationAllergySubtype2["ANESTHETICS"] = "anesthetics";
+  MedicationAllergySubtype2["VACCINES"] = "vaccines";
+  MedicationAllergySubtype2["OTHER"] = "other";
+  return MedicationAllergySubtype2;
+})(MedicationAllergySubtype || {});
+var FoodAllergySubtype = /* @__PURE__ */ ((FoodAllergySubtype2) => {
+  FoodAllergySubtype2["NUTS"] = "nuts";
+  FoodAllergySubtype2["SHELLFISH"] = "shellfish";
+  FoodAllergySubtype2["DAIRY"] = "dairy";
+  FoodAllergySubtype2["EGGS"] = "eggs";
+  FoodAllergySubtype2["WHEAT"] = "wheat";
+  FoodAllergySubtype2["SOY"] = "soy";
+  FoodAllergySubtype2["FISH"] = "fish";
+  FoodAllergySubtype2["FRUITS"] = "fruits";
+  FoodAllergySubtype2["OTHER"] = "other";
+  return FoodAllergySubtype2;
+})(FoodAllergySubtype || {});
+var EnvironmentalAllergySubtype = /* @__PURE__ */ ((EnvironmentalAllergySubtype2) => {
+  EnvironmentalAllergySubtype2["POLLEN"] = "pollen";
+  EnvironmentalAllergySubtype2["DUST"] = "dust";
+  EnvironmentalAllergySubtype2["MOLD"] = "mold";
+  EnvironmentalAllergySubtype2["PET_DANDER"] = "pet_dander";
+  EnvironmentalAllergySubtype2["INSECTS"] = "insects";
+  EnvironmentalAllergySubtype2["OTHER"] = "other";
+  return EnvironmentalAllergySubtype2;
+})(EnvironmentalAllergySubtype || {});
+var CosmeticAllergySubtype = /* @__PURE__ */ ((CosmeticAllergySubtype2) => {
+  CosmeticAllergySubtype2["FRAGRANCES"] = "fragrances";
+  CosmeticAllergySubtype2["PRESERVATIVES"] = "preservatives";
+  CosmeticAllergySubtype2["DYES"] = "dyes";
+  CosmeticAllergySubtype2["METALS"] = "metals";
+  CosmeticAllergySubtype2["OTHER"] = "other";
+  return CosmeticAllergySubtype2;
+})(CosmeticAllergySubtype || {});
+
+// src/backoffice/types/static/blocking-condition.types.ts
+var BlockingCondition = /* @__PURE__ */ ((BlockingCondition2) => {
+  BlockingCondition2["PREGNANCY"] = "pregnancy";
+  BlockingCondition2["BREASTFEEDING"] = "breastfeeding";
+  BlockingCondition2["ACTIVE_INFECTION"] = "active_infection";
+  BlockingCondition2["SKIN_CONDITION"] = "skin_condition";
+  BlockingCondition2["AUTOIMMUNE_DISEASE"] = "autoimmune_disease";
+  BlockingCondition2["BLOOD_THINNERS"] = "blood_thinners";
+  BlockingCondition2["RECENT_SURGERY"] = "recent_surgery";
+  BlockingCondition2["DIABETES"] = "diabetes";
+  BlockingCondition2["HEART_CONDITION"] = "heart_condition";
+  BlockingCondition2["HIGH_BLOOD_PRESSURE"] = "high_blood_pressure";
+  BlockingCondition2["KELOID_SCARRING"] = "keloid_scarring";
+  BlockingCondition2["METAL_IMPLANTS"] = "metal_implants";
+  BlockingCondition2["PACEMAKER"] = "pacemaker";
+  BlockingCondition2["CANCER"] = "cancer";
+  BlockingCondition2["EPILEPSY"] = "epilepsy";
+  return BlockingCondition2;
+})(BlockingCondition || {});
+
+// src/backoffice/types/static/contraindication.types.ts
+var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
+  Contraindication2["SENSITIVE_SKIN"] = "sensitive_skin";
+  Contraindication2["RECENT_TANNING"] = "recent_tanning";
+  Contraindication2["RECENT_BOTOX"] = "recent_botox";
+  Contraindication2["RECENT_FILLERS"] = "recent_fillers";
+  Contraindication2["SKIN_ALLERGIES"] = "skin_allergies";
+  Contraindication2["MEDICATIONS"] = "medications";
+  Contraindication2["RECENT_CHEMICAL_PEEL"] = "recent_chemical_peel";
+  Contraindication2["RECENT_LASER"] = "recent_laser";
+  Contraindication2["SKIN_INFLAMMATION"] = "skin_inflammation";
+  Contraindication2["OPEN_WOUNDS"] = "open_wounds";
+  Contraindication2["HERPES_SIMPLEX"] = "herpes_simplex";
+  Contraindication2["COLD_SORES"] = "cold_sores";
+  return Contraindication2;
+})(Contraindication || {});
+
+// src/validations/common.schema.ts
+var import_zod5 = require("zod");
+var import_firestore4 = require("firebase/firestore");
+var timestampSchema2 = import_zod5.z.union([
+  import_zod5.z.object({
+    seconds: import_zod5.z.number(),
+    nanoseconds: import_zod5.z.number()
+  }),
+  import_zod5.z.instanceof(import_firestore4.Timestamp)
+]).transform((data) => {
+  if (data instanceof import_firestore4.Timestamp) {
+    return data;
+  }
+  return new import_firestore4.Timestamp(data.seconds, data.nanoseconds);
+});
+
+// src/validations/patient/medical-info.schema.ts
+var allergySubtypeSchema = import_zod6.z.union([
+  import_zod6.z.nativeEnum(MedicationAllergySubtype),
+  import_zod6.z.nativeEnum(FoodAllergySubtype),
+  import_zod6.z.nativeEnum(EnvironmentalAllergySubtype),
+  import_zod6.z.nativeEnum(CosmeticAllergySubtype),
+  import_zod6.z.literal("other")
+]);
+var allergySchema = import_zod6.z.object({
+  type: import_zod6.z.nativeEnum(AllergyType),
+  subtype: allergySubtypeSchema,
+  name: import_zod6.z.string().optional().nullable(),
+  severity: import_zod6.z.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: import_zod6.z.string().optional().nullable(),
+  diagnosed: timestampSchema2.optional().nullable(),
+  notes: import_zod6.z.string().optional().nullable()
+});
+var vitalStatsSchema = import_zod6.z.object({
+  height: import_zod6.z.number().positive().optional(),
+  weight: import_zod6.z.number().positive().optional(),
+  bloodType: import_zod6.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: import_zod6.z.object({
+    systolic: import_zod6.z.number().min(70).max(200),
+    diastolic: import_zod6.z.number().min(40).max(130),
+    lastMeasured: timestampSchema2
+  }).optional()
+});
+var blockingConditionSchema = import_zod6.z.object({
+  condition: import_zod6.z.nativeEnum(BlockingCondition),
+  diagnosedAt: timestampSchema2,
+  notes: import_zod6.z.string().optional().nullable(),
+  isActive: import_zod6.z.boolean()
+});
+var contraindicationSchema = import_zod6.z.object({
+  condition: import_zod6.z.nativeEnum(Contraindication),
+  lastOccurrence: timestampSchema2,
+  frequency: import_zod6.z.enum(["rare", "occasional", "frequent"]),
+  notes: import_zod6.z.string().optional().nullable(),
+  isActive: import_zod6.z.boolean()
+});
+var medicationSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  dosage: import_zod6.z.string().min(1),
+  frequency: import_zod6.z.string().min(1),
+  startDate: timestampSchema2.optional().nullable(),
+  endDate: timestampSchema2.optional().nullable(),
+  prescribedBy: import_zod6.z.string().optional().nullable()
+});
+var patientMedicalInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
+  vitalStats: vitalStatsSchema,
+  blockingConditions: import_zod6.z.array(blockingConditionSchema),
+  contraindications: import_zod6.z.array(contraindicationSchema),
+  allergies: import_zod6.z.array(allergySchema),
+  currentMedications: import_zod6.z.array(medicationSchema),
+  emergencyNotes: import_zod6.z.string().optional(),
+  lastUpdated: timestampSchema2,
+  updatedBy: import_zod6.z.string(),
+  verifiedBy: import_zod6.z.string().optional(),
+  verifiedAt: timestampSchema2.optional()
+});
+var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
+  patientId: true,
+  lastUpdated: true,
+  updatedBy: true,
+  verifiedBy: true,
+  verifiedAt: true
+});
+var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
+var updateVitalStatsSchema = vitalStatsSchema;
+var addAllergySchema = allergySchema;
+var updateAllergySchema = allergySchema.partial().extend({
+  allergyIndex: import_zod6.z.number().min(0)
+});
+var addBlockingConditionSchema = blockingConditionSchema;
+var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
+  conditionIndex: import_zod6.z.number().min(0)
+});
+var addContraindicationSchema = contraindicationSchema;
+var updateContraindicationSchema = contraindicationSchema.partial().extend({
+  contraindicationIndex: import_zod6.z.number().min(0)
+});
+var addMedicationSchema = medicationSchema;
+var updateMedicationSchema = medicationSchema.partial().extend({
+  medicationIndex: import_zod6.z.number().min(0)
+});
+
+// src/validations/patient.schema.ts
+var locationDataSchema = import_zod7.z.object({
+  latitude: import_zod7.z.number().min(-90).max(90),
+  longitude: import_zod7.z.number().min(-180).max(180),
+  geohash: import_zod7.z.string().optional()
+});
+var addressDataSchema = import_zod7.z.object({
+  address: import_zod7.z.string(),
+  city: import_zod7.z.string(),
+  country: import_zod7.z.string(),
+  postalCode: import_zod7.z.string()
+});
+var emergencyContactSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  relationship: import_zod7.z.string(),
+  phoneNumber: import_zod7.z.string(),
+  isNotifiable: import_zod7.z.boolean()
+});
+var gamificationSchema = import_zod7.z.object({
+  level: import_zod7.z.number(),
+  points: import_zod7.z.number()
+});
+var patientLocationInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  locationData: locationDataSchema,
+  createdAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore5.Timestamp)
+});
+var createPatientLocationInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  locationData: locationDataSchema
+});
+var patientSensitiveInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  firstName: import_zod7.z.string().min(2),
+  lastName: import_zod7.z.string().min(2),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore5.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  email: import_zod7.z.string().email().optional(),
+  phoneNumber: import_zod7.z.string().optional(),
+  alternativePhoneNumber: import_zod7.z.string().optional(),
+  addressData: addressDataSchema.optional(),
+  emergencyContacts: import_zod7.z.array(emergencyContactSchema).optional(),
+  createdAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore5.Timestamp)
+});
+var patientDoctorSchema = import_zod7.z.object({
+  userRef: import_zod7.z.string(),
+  assignedAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  assignedBy: import_zod7.z.string().optional(),
+  isActive: import_zod7.z.boolean(),
+  notes: import_zod7.z.string().optional()
+});
+var patientClinicSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string(),
+  assignedAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  assignedBy: import_zod7.z.string().optional(),
+  isActive: import_zod7.z.boolean(),
+  notes: import_zod7.z.string().optional()
+});
+var patientProfileSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  displayName: import_zod7.z.string(),
+  gamification: gamificationSchema,
+  expoTokens: import_zod7.z.array(import_zod7.z.string()),
+  isActive: import_zod7.z.boolean(),
+  isVerified: import_zod7.z.boolean(),
+  phoneNumber: import_zod7.z.string().nullable().optional(),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore5.Timestamp).nullable().optional(),
+  doctors: import_zod7.z.array(patientDoctorSchema),
+  clinics: import_zod7.z.array(patientClinicSchema),
+  doctorIds: import_zod7.z.array(import_zod7.z.string()),
+  clinicIds: import_zod7.z.array(import_zod7.z.string()),
+  createdAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore5.Timestamp)
+});
+var createPatientProfileSchema = import_zod7.z.object({
+  userRef: import_zod7.z.string(),
+  displayName: import_zod7.z.string(),
+  expoTokens: import_zod7.z.array(import_zod7.z.string()),
+  gamification: gamificationSchema.optional(),
+  isActive: import_zod7.z.boolean(),
+  isVerified: import_zod7.z.boolean(),
+  doctors: import_zod7.z.array(patientDoctorSchema).optional(),
+  clinics: import_zod7.z.array(patientClinicSchema).optional(),
+  doctorIds: import_zod7.z.array(import_zod7.z.string()).optional(),
+  clinicIds: import_zod7.z.array(import_zod7.z.string()).optional()
+});
+var createPatientSensitiveInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  photoUrl: mediaResourceSchema.nullable().optional(),
+  firstName: import_zod7.z.string().min(2),
+  lastName: import_zod7.z.string().min(2),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore5.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  email: import_zod7.z.string().email().optional(),
+  phoneNumber: import_zod7.z.string().optional(),
+  alternativePhoneNumber: import_zod7.z.string().optional(),
+  addressData: addressDataSchema.optional(),
+  emergencyContacts: import_zod7.z.array(emergencyContactSchema).optional()
+});
+var searchPatientsSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string().optional(),
+  practitionerId: import_zod7.z.string().optional()
+}).refine((data) => data.clinicId || data.practitionerId, {
+  message: "At least one of clinicId or practitionerId must be provided",
+  path: []
+  // Optional: specify a path like ['clinicId'] or ['practitionerId']
+});
+var requesterInfoSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  role: import_zod7.z.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: import_zod7.z.string().optional(),
+  associatedPractitionerId: import_zod7.z.string().optional()
+}).refine(
+  (data) => {
+    if (data.role === "clinic_admin") {
+      return !!data.associatedClinicId;
+    } else if (data.role === "practitioner") {
+      return !!data.associatedPractitionerId;
+    }
+    return false;
+  },
+  {
+    message: "Associated ID (clinic or practitioner) is required based on role",
+    path: ["associatedClinicId", "associatedPractitionerId"]
+  }
+);
+
+// src/services/patient/utils/docs.utils.ts
+var import_firestore7 = require("firebase/firestore");
+
+// src/services/patient/utils/sensitive.utils.ts
+var import_firestore6 = require("firebase/firestore");
+var import_zod8 = require("zod");
+var handlePhotoUrlUpload = async (photoUrl, patientId, mediaService) => {
+  if (!photoUrl) {
+    return null;
+  }
+  if (typeof photoUrl === "string") {
+    return photoUrl;
+  }
+  if (photoUrl instanceof File || photoUrl instanceof Blob) {
+    const mediaMetadata = await mediaService.uploadMedia(
+      photoUrl,
+      patientId,
+      // Using patientId as ownerId
+      "private" /* PRIVATE */,
+      // Sensitive info should be private
+      "patient_sensitive_photos",
+      photoUrl instanceof File ? photoUrl.name : `sensitive_photo_${patientId}`
+    );
+    return mediaMetadata.url;
+  }
+  return null;
+};
+var createSensitiveInfoUtil = async (db, data, requesterUserId, mediaService) => {
+  try {
+    if (data.userRef !== requesterUserId) {
+      throw new Error("Only patient can create their sensitive information");
+    }
+    const validatedData = createPatientSensitiveInfoSchema.parse(data);
+    const sensitiveDoc = await (0, import_firestore6.getDoc)(
+      getSensitiveInfoDocRef(db, data.patientId)
+    );
+    if (sensitiveDoc.exists()) {
+      throw new Error("Sensitive information already exists for this patient");
+    }
+    let processedPhotoUrl = null;
+    if (validatedData.photoUrl && mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        validatedData.photoUrl,
+        data.patientId,
+        mediaService
+      );
+    } else if (typeof validatedData.photoUrl === "string") {
+      processedPhotoUrl = validatedData.photoUrl;
+    }
+    const sensitiveInfoData = {
+      ...validatedData,
+      photoUrl: processedPhotoUrl,
+      createdAt: (0, import_firestore6.serverTimestamp)(),
+      updatedAt: (0, import_firestore6.serverTimestamp)()
+    };
+    await (0, import_firestore6.setDoc)(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
+    const createdDoc = await (0, import_firestore6.getDoc)(getSensitiveInfoDocRef(db, data.patientId));
+    if (!createdDoc.exists()) {
+      throw new Error("Failed to create sensitive information");
+    }
+    return createdDoc.data();
+  } catch (error) {
+    if (error instanceof import_zod8.z.ZodError) {
+      throw new Error("Invalid sensitive info data: " + error.message);
+    }
     throw error;
   }
 };
 var getSensitiveInfoUtil = async (db, patientId, requesterUserId) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
-  const sensitiveDoc = await (0, import_firestore4.getDoc)(getSensitiveInfoDocRef(db, patientId));
+  const sensitiveDoc = await (0, import_firestore6.getDoc)(getSensitiveInfoDocRef(db, patientId));
   return sensitiveDoc.exists() ? sensitiveDoc.data() : null;
 };
-var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
+var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId, mediaService) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
+  let processedPhotoUrl = void 0;
+  if (data.photoUrl !== void 0) {
+    if (mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        data.photoUrl,
+        patientId,
+        mediaService
+      );
+    } else if (typeof data.photoUrl === "string" || data.photoUrl === null) {
+      processedPhotoUrl = data.photoUrl;
+    } else {
+      throw new Error("MediaService required to process photo upload");
+    }
+  }
   const updateData = {
     ...data,
-    updatedAt: (0, import_firestore4.serverTimestamp)()
+    photoUrl: processedPhotoUrl,
+    updatedAt: (0, import_firestore6.serverTimestamp)()
   };
-  await (0, import_firestore4.updateDoc)(getSensitiveInfoDocRef(db, patientId), updateData);
-  const updatedDoc = await (0, import_firestore4.getDoc)(getSensitiveInfoDocRef(db, patientId));
+  await (0, import_firestore6.updateDoc)(getSensitiveInfoDocRef(db, patientId), updateData);
+  const updatedDoc = await (0, import_firestore6.getDoc)(getSensitiveInfoDocRef(db, patientId));
   if (!updatedDoc.exists()) {
     throw new Error("Failed to retrieve updated sensitive information");
   }
@@ -1615,21 +1966,21 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
 
 // src/services/patient/utils/docs.utils.ts
 var getPatientDocRef = (db, patientId) => {
-  return (0, import_firestore5.doc)(db, PATIENTS_COLLECTION, patientId);
+  return (0, import_firestore7.doc)(db, PATIENTS_COLLECTION, patientId);
 };
 var getPatientDocRefByUserRef = async (db, userRef) => {
-  const patientsRef = (0, import_firestore5.collection)(db, PATIENTS_COLLECTION);
-  const q = (0, import_firestore5.query)(patientsRef, (0, import_firestore5.where)("userRef", "==", userRef));
-  const querySnapshot = await (0, import_firestore5.getDocs)(q);
+  const patientsRef = (0, import_firestore7.collection)(db, PATIENTS_COLLECTION);
+  const q = (0, import_firestore7.query)(patientsRef, (0, import_firestore7.where)("userRef", "==", userRef));
+  const querySnapshot = await (0, import_firestore7.getDocs)(q);
   if (querySnapshot.empty) {
     throw new Error("Patient profile not found");
   }
-  return (0, import_firestore5.doc)(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
+  return (0, import_firestore7.doc)(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
 };
 var getSensitiveInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_SENSITIVE_INFO_COLLECTION}/${patientId}`;
   console.log(`[getSensitiveInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore5.doc)(
+  return (0, import_firestore7.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1640,7 +1991,7 @@ var getSensitiveInfoDocRef = (db, patientId) => {
 var getLocationInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_LOCATION_INFO_COLLECTION}/${patientId}`;
   console.log(`[getLocationInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore5.doc)(
+  return (0, import_firestore7.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1651,7 +2002,7 @@ var getLocationInfoDocRef = (db, patientId) => {
 var getMedicalInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_MEDICAL_INFO_COLLECTION}/${patientId}`;
   console.log(`[getMedicalInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore5.doc)(
+  return (0, import_firestore7.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1668,7 +2019,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
     console.log(
       `[initSensitiveInfoDocIfNotExists] Got document reference: ${sensitiveInfoRef.path}`
     );
-    const sensitiveDoc = await (0, import_firestore5.getDoc)(sensitiveInfoRef);
+    const sensitiveDoc = await (0, import_firestore7.getDoc)(sensitiveInfoRef);
     console.log(
       `[initSensitiveInfoDocIfNotExists] Document exists: ${sensitiveDoc.exists()}`
     );
@@ -1692,7 +2043,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
         )
       );
       await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef);
-      const verifyDoc = await (0, import_firestore5.getDoc)(sensitiveInfoRef);
+      const verifyDoc = await (0, import_firestore7.getDoc)(sensitiveInfoRef);
       console.log(
         `[initSensitiveInfoDocIfNotExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1709,10 +2060,10 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
 };
 
 // src/services/patient/utils/medical.utils.ts
-var import_firestore7 = require("firebase/firestore");
+var import_firestore9 = require("firebase/firestore");
 
 // src/services/patient/utils/practitioner.utils.ts
-var import_firestore6 = require("firebase/firestore");
+var import_firestore8 = require("firebase/firestore");
 
 // src/types/practitioner/index.ts
 var PRACTITIONERS_COLLECTION = "practitioners";
@@ -1737,23 +2088,23 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
       `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore6.collection)(db, PATIENTS_COLLECTION);
+    const patientsCollection = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
     const constraints = [
-      (0, import_firestore6.where)("doctorIds", "array-contains", practitionerId)
+      (0, import_firestore8.where)("doctorIds", "array-contains", practitionerId)
     ];
-    let q = (0, import_firestore6.query)(patientsCollection, ...constraints);
+    let q = (0, import_firestore8.query)(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore6.query)(q, (0, import_firestore6.limit)(options.limit));
+      q = (0, import_firestore8.query)(q, (0, import_firestore8.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore6.getDoc)(
-        (0, import_firestore6.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore8.getDoc)(
+        (0, import_firestore8.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore6.query)(q, (0, import_firestore6.startAfter)(startAfterDoc));
+        q = (0, import_firestore8.query)(q, (0, import_firestore8.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore6.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore8.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -1786,7 +2137,7 @@ var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, option
     const patientProfilesWithDetails = await Promise.all(
       patientProfiles.map(async (profile) => {
         try {
-          const sensitiveInfoDoc = await (0, import_firestore6.getDoc)(
+          const sensitiveInfoDoc = await (0, import_firestore8.getDoc)(
             getSensitiveInfoDocRef(db, profile.id)
           );
           const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
@@ -1822,13 +2173,13 @@ var getPractitionerProfileByUserRef = async (db, userRef) => {
     console.log(
       `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
     );
-    const practitionersCollection = (0, import_firestore6.collection)(db, PRACTITIONERS_COLLECTION);
-    const q = (0, import_firestore6.query)(
+    const practitionersCollection = (0, import_firestore8.collection)(db, PRACTITIONERS_COLLECTION);
+    const q = (0, import_firestore8.query)(
       practitionersCollection,
-      (0, import_firestore6.where)("userRef", "==", userRef),
-      (0, import_firestore6.limit)(1)
+      (0, import_firestore8.where)("userRef", "==", userRef),
+      (0, import_firestore8.limit)(1)
     );
-    const querySnapshot = await (0, import_firestore6.getDocs)(q);
+    const querySnapshot = await (0, import_firestore8.getDocs)(q);
     if (querySnapshot.empty) {
       console.log(
         `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
@@ -1862,7 +2213,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
     console.log(
       `[ensureMedicalInfoExists] Got document reference: ${medicalInfoRef.path}`
     );
-    const medicalInfoDoc = await (0, import_firestore7.getDoc)(medicalInfoRef);
+    const medicalInfoDoc = await (0, import_firestore9.getDoc)(medicalInfoRef);
     console.log(
       `[ensureMedicalInfoExists] Document exists: ${medicalInfoDoc.exists()}`
     );
@@ -1870,7 +2221,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
       const defaultData = {
         ...DEFAULT_MEDICAL_INFO,
         patientId,
-        lastUpdated: (0, import_firestore7.serverTimestamp)(),
+        lastUpdated: (0, import_firestore9.serverTimestamp)(),
         updatedBy: userRef
       };
       console.log(
@@ -1880,9 +2231,9 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
           (key, value) => value && typeof value === "object" && value.constructor && value.constructor.name === "Object" ? "[serverTimestamp]" : value
         )
       );
-      await (0, import_firestore7.setDoc)(medicalInfoRef, defaultData);
+      await (0, import_firestore9.setDoc)(medicalInfoRef, defaultData);
       console.log(`[ensureMedicalInfoExists] Document created successfully`);
-      const verifyDoc = await (0, import_firestore7.getDoc)(medicalInfoRef);
+      const verifyDoc = await (0, import_firestore9.getDoc)(medicalInfoRef);
       console.log(
         `[ensureMedicalInfoExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1898,7 +2249,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
 };
 var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
   var _a;
-  const patientDoc = await (0, import_firestore7.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore9.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) {
     throw new Error("Patient profile not found");
   }
@@ -1931,17 +2282,17 @@ var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
 var createMedicalInfoUtil = async (db, patientId, data, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const validatedData = createPatientMedicalInfoSchema.parse(data);
-  await (0, import_firestore7.setDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.setDoc)(getMedicalInfoDocRef(db, patientId), {
     ...validatedData,
     patientId,
-    lastUpdated: import_firestore7.Timestamp.now(),
+    lastUpdated: import_firestore9.Timestamp.now(),
     updatedBy: userRef
   });
 };
 var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const docRef = getMedicalInfoDocRef(db, patientId);
-  const snapshot = await (0, import_firestore7.getDoc)(docRef);
+  const snapshot = await (0, import_firestore9.getDoc)(docRef);
   if (!snapshot.exists()) {
     throw new Error("Medicinske informacije nisu prona\u0111ene");
   }
@@ -1950,25 +2301,25 @@ var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
 var updateVitalStatsUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = updateVitalStatsSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     vitalStats: validatedData,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addAllergyUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addAllergySchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    allergies: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    allergies: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const docSnapshot = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const docSnapshot = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!docSnapshot.exists()) throw new Error("Medical info not found");
   const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1979,14 +2330,14 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
     ...updatedAllergies[allergyIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1995,25 +2346,25 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
   const updatedAllergies = medicalInfo.allergies.filter(
     (_, index) => index !== allergyIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addBlockingConditionSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    blockingConditions: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    blockingConditions: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -2024,14 +2375,14 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
     ...updatedConditions[conditionIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -2040,25 +2391,25 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef)
   const updatedConditions = medicalInfo.blockingConditions.filter(
     (_, index) => index !== conditionIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addContraindicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addContraindicationSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    contraindications: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    contraindications: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -2069,14 +2420,14 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
     ...updatedContraindications[contraindicationIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -2085,25 +2436,25 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, us
   const updatedContraindications = medicalInfo.contraindications.filter(
     (_, index) => index !== contraindicationIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addMedicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addMedicationSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    currentMedications: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    currentMedications: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -2114,14 +2465,14 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
     ...updatedMedications[medicationIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -2130,9 +2481,9 @@ var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
   const updatedMedications = medicalInfo.currentMedications.filter(
     (_, index) => index !== medicationIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
@@ -2149,7 +2500,6 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       id: patientId,
       userRef: validatedData.userRef,
       displayName: validatedData.displayName,
-      profilePhoto: validatedData.profilePhoto || null,
       expoTokens: validatedData.expoTokens,
       gamification: validatedData.gamification || {
         level: 1,
@@ -2161,15 +2511,15 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       clinics: validatedData.clinics || [],
       doctorIds: ((_a = validatedData.doctors) == null ? void 0 : _a.map((d) => d.userRef)) || [],
       clinicIds: ((_b = validatedData.clinics) == null ? void 0 : _b.map((c) => c.clinicId)) || [],
-      createdAt: (0, import_firestore8.serverTimestamp)(),
-      updatedAt: (0, import_firestore8.serverTimestamp)()
+      createdAt: (0, import_firestore10.serverTimestamp)(),
+      updatedAt: (0, import_firestore10.serverTimestamp)()
     };
     patientProfileSchema.parse({
       ...patientData,
-      createdAt: import_firestore8.Timestamp.now(),
-      updatedAt: import_firestore8.Timestamp.now()
+      createdAt: import_firestore10.Timestamp.now(),
+      updatedAt: import_firestore10.Timestamp.now()
     });
-    await (0, import_firestore8.setDoc)(getPatientDocRef(db, patientId), patientData);
+    await (0, import_firestore10.setDoc)(getPatientDocRef(db, patientId), patientData);
     console.log(`[createPatientProfileUtil] Creating sensitive info document`);
     let sensitiveInfoSuccess = false;
     try {
@@ -2183,81 +2533,103 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       );
       sensitiveInfoSuccess = true;
     } catch (sensitiveError) {
-      console.error(`[createPatientProfileUtil] Error creating sensitive info:`, sensitiveError);
+      console.error(
+        `[createPatientProfileUtil] Error creating sensitive info:`,
+        sensitiveError
+      );
     }
     console.log(`[createPatientProfileUtil] Creating medical info document`);
     let medicalInfoSuccess = false;
     try {
       await ensureMedicalInfoExists(db, patientId, validatedData.userRef);
-      console.log(`[createPatientProfileUtil] Medical info document created successfully`);
+      console.log(
+        `[createPatientProfileUtil] Medical info document created successfully`
+      );
       medicalInfoSuccess = true;
     } catch (medicalError) {
-      console.error(`[createPatientProfileUtil] Error creating medical info:`, medicalError);
+      console.error(
+        `[createPatientProfileUtil] Error creating medical info:`,
+        medicalError
+      );
     }
     if (!sensitiveInfoSuccess || !medicalInfoSuccess) {
-      console.log(`[createPatientProfileUtil] Using fallback method to create documents`);
+      console.log(
+        `[createPatientProfileUtil] Using fallback method to create documents`
+      );
       try {
         await testCreateSubDocuments(db, patientId, validatedData.userRef);
-        console.log(`[createPatientProfileUtil] Fallback method completed successfully`);
+        console.log(
+          `[createPatientProfileUtil] Fallback method completed successfully`
+        );
       } catch (fallbackError) {
-        console.error(`[createPatientProfileUtil] Fallback method failed:`, fallbackError);
+        console.error(
+          `[createPatientProfileUtil] Fallback method failed:`,
+          fallbackError
+        );
       }
     }
     console.log(`[createPatientProfileUtil] Verifying patient document exists`);
-    const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
+    const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
     if (!patientDoc.exists()) {
-      console.error(`[createPatientProfileUtil] Patient document not found after creation`);
+      console.error(
+        `[createPatientProfileUtil] Patient document not found after creation`
+      );
       throw new Error("Failed to create patient profile");
     }
-    console.log(`[createPatientProfileUtil] Patient profile creation completed successfully`);
+    console.log(
+      `[createPatientProfileUtil] Patient profile creation completed successfully`
+    );
     return patientDoc.data();
   } catch (error) {
-    console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
-    if (error instanceof import_zod8.z.ZodError) {
+    console.error(
+      `[createPatientProfileUtil] Error in patient profile creation:`,
+      error
+    );
+    if (error instanceof import_zod9.z.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
   }
 };
 var getPatientProfileUtil = async (db, patientId) => {
-  const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? patientDoc.data() : null;
 };
 var getPatientProfileByUserRefUtil = async (db, userRef) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await (0, import_firestore8.getDoc)(docRef);
+    const patientDoc = await (0, import_firestore10.getDoc)(docRef);
     return patientDoc.exists() ? patientDoc.data() : null;
   } catch (error) {
     return null;
   }
 };
 var addExpoTokenUtil = async (db, patientId, token) => {
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    expoTokens: (0, import_firestore8.arrayUnion)(token),
-    updatedAt: (0, import_firestore8.serverTimestamp)()
+  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), {
+    expoTokens: (0, import_firestore10.arrayUnion)(token),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   });
 };
 var removeExpoTokenUtil = async (db, patientId, token) => {
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    expoTokens: (0, import_firestore8.arrayRemove)(token),
-    updatedAt: (0, import_firestore8.serverTimestamp)()
+  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), {
+    expoTokens: (0, import_firestore10.arrayRemove)(token),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   });
 };
 var addPointsUtil = async (db, patientId, points) => {
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    "gamification.points": (0, import_firestore8.increment)(points),
-    updatedAt: (0, import_firestore8.serverTimestamp)()
+  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), {
+    "gamification.points": (0, import_firestore10.increment)(points),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   });
 };
 var updatePatientProfileUtil = async (db, patientId, data) => {
   try {
     const updateData = {
       ...data,
-      updatedAt: (0, import_firestore8.serverTimestamp)()
+      updatedAt: (0, import_firestore10.serverTimestamp)()
     };
-    await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), updateData);
-    const updatedDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
+    await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), updateData);
+    const updatedDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
       throw new Error("Patient profile not found after update");
     }
@@ -2270,7 +2642,7 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
 var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await (0, import_firestore8.getDoc)(docRef);
+    const patientDoc = await (0, import_firestore10.getDoc)(docRef);
     if (!patientDoc.exists()) {
       throw new Error("Patient profile not found");
     }
@@ -2278,49 +2650,10 @@ var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
     return updatePatientProfileUtil(db, patientData.id, data);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to update patient profile by user ref: ${errorMessage}`);
-  }
-};
-var uploadProfilePhotoUtil = async (storage, patientId, file) => {
-  const photoRef = (0, import_storage3.ref)(storage, `patient-photos/${patientId}/profile-photo`);
-  await (0, import_storage3.uploadBytes)(photoRef, file);
-  return (0, import_storage3.getDownloadURL)(photoRef);
-};
-var updateProfilePhotoUtil = async (storage, db, patientId, file) => {
-  const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const oldPhotoRef = (0, import_storage3.ref)(storage, patientData.profilePhoto);
-      await (0, import_storage3.deleteObject)(oldPhotoRef);
-    } catch (error) {
-      console.warn("Failed to delete old profile photo:", error);
-    }
-  }
-  const newPhotoUrl = await uploadProfilePhotoUtil(storage, patientId, file);
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    profilePhoto: newPhotoUrl,
-    updatedAt: (0, import_firestore8.serverTimestamp)()
-  });
-  return newPhotoUrl;
-};
-var deleteProfilePhotoUtil = async (storage, db, patientId) => {
-  const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const photoRef = (0, import_storage3.ref)(storage, patientData.profilePhoto);
-      await (0, import_storage3.deleteObject)(photoRef);
-    } catch (error) {
-      console.warn("Failed to delete profile photo:", error);
-    }
+    throw new Error(
+      `Failed to update patient profile by user ref: ${errorMessage}`
+    );
   }
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    profilePhoto: null,
-    updatedAt: (0, import_firestore8.serverTimestamp)()
-  });
 };
 var testCreateSubDocuments = async (db, patientId, userRef) => {
   console.log(
@@ -2329,33 +2662,41 @@ var testCreateSubDocuments = async (db, patientId, userRef) => {
   try {
     console.log(`[testCreateSubDocuments] Testing sensitive info creation`);
     const sensitiveInfoRef = getSensitiveInfoDocRef(db, patientId);
-    console.log(`[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`);
+    console.log(
+      `[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`
+    );
     const defaultSensitiveInfo = {
       patientId,
       userRef,
       photoUrl: "",
       firstName: "Name",
       lastName: "Surname",
-      dateOfBirth: import_firestore8.Timestamp.now(),
+      dateOfBirth: import_firestore10.Timestamp.now(),
       gender: "prefer_not_to_say" /* PREFER_NOT_TO_SAY */,
       email: "test@example.com",
       phoneNumber: "",
-      createdAt: import_firestore8.Timestamp.now(),
-      updatedAt: import_firestore8.Timestamp.now()
+      createdAt: import_firestore10.Timestamp.now(),
+      updatedAt: import_firestore10.Timestamp.now()
     };
-    await (0, import_firestore8.setDoc)(sensitiveInfoRef, defaultSensitiveInfo);
-    console.log(`[testCreateSubDocuments] Sensitive info document created directly`);
+    await (0, import_firestore10.setDoc)(sensitiveInfoRef, defaultSensitiveInfo);
+    console.log(
+      `[testCreateSubDocuments] Sensitive info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Testing medical info creation`);
     const medicalInfoRef = getMedicalInfoDocRef(db, patientId);
-    console.log(`[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`);
+    console.log(
+      `[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`
+    );
     const defaultMedicalInfo = {
       ...DEFAULT_MEDICAL_INFO,
       patientId,
-      lastUpdated: import_firestore8.Timestamp.now(),
+      lastUpdated: import_firestore10.Timestamp.now(),
       updatedBy: userRef
     };
-    await (0, import_firestore8.setDoc)(medicalInfoRef, defaultMedicalInfo);
-    console.log(`[testCreateSubDocuments] Medical info document created directly`);
+    await (0, import_firestore10.setDoc)(medicalInfoRef, defaultMedicalInfo);
+    console.log(
+      `[testCreateSubDocuments] Medical info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Test completed successfully`);
   } catch (error) {
     console.error(`[testCreateSubDocuments] Error:`, error);
@@ -2366,10 +2707,12 @@ var searchPatientsUtil = async (db, params, requester) => {
   searchPatientsSchema.parse(params);
   requesterInfoSchema.parse(requester);
   const constraints = [];
-  const patientsCollectionRef = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
+  const patientsCollectionRef = (0, import_firestore10.collection)(db, PATIENTS_COLLECTION);
   if (requester.role === "clinic_admin") {
     if (!requester.associatedClinicId) {
-      throw new Error("Associated clinic ID is required for clinic admin search.");
+      throw new Error(
+        "Associated clinic ID is required for clinic admin search."
+      );
     }
     if (params.clinicId && params.clinicId !== requester.associatedClinicId) {
       console.warn(
@@ -2377,13 +2720,19 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push((0, import_firestore8.where)("clinicIds", "array-contains", requester.associatedClinicId));
+    constraints.push(
+      (0, import_firestore10.where)("clinicIds", "array-contains", requester.associatedClinicId)
+    );
     if (params.practitionerId) {
-      constraints.push((0, import_firestore8.where)("doctorIds", "array-contains", params.practitionerId));
+      constraints.push(
+        (0, import_firestore10.where)("doctorIds", "array-contains", params.practitionerId)
+      );
     }
   } else if (requester.role === "practitioner") {
     if (!requester.associatedPractitionerId) {
-      throw new Error("Associated practitioner ID is required for practitioner search.");
+      throw new Error(
+        "Associated practitioner ID is required for practitioner search."
+      );
     }
     if (params.practitionerId && params.practitionerId !== requester.associatedPractitionerId) {
       console.warn(
@@ -2391,18 +2740,24 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push((0, import_firestore8.where)("doctorIds", "array-contains", requester.associatedPractitionerId));
+    constraints.push(
+      (0, import_firestore10.where)("doctorIds", "array-contains", requester.associatedPractitionerId)
+    );
     if (params.clinicId) {
-      constraints.push((0, import_firestore8.where)("clinicIds", "array-contains", params.clinicId));
+      constraints.push((0, import_firestore10.where)("clinicIds", "array-contains", params.clinicId));
     }
   } else {
     throw new Error("Invalid requester role.");
   }
   try {
-    const finalQuery = (0, import_firestore8.query)(patientsCollectionRef, ...constraints);
-    const querySnapshot = await (0, import_firestore8.getDocs)(finalQuery);
-    const patients = querySnapshot.docs.map((doc34) => doc34.data());
-    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
+    const finalQuery = (0, import_firestore10.query)(patientsCollectionRef, ...constraints);
+    const querySnapshot = await (0, import_firestore10.getDocs)(finalQuery);
+    const patients = querySnapshot.docs.map(
+      (doc34) => doc34.data()
+    );
+    console.log(
+      `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
+    );
     return patients;
   } catch (error) {
     console.error("[searchPatientsUtil] Error searching patients:", error);
@@ -2411,19 +2766,24 @@ var searchPatientsUtil = async (db, params, requester) => {
 };
 var getAllPatientsUtil = async (db, options) => {
   try {
-    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
-    const patientsCollection = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
-    let q = (0, import_firestore8.query)(patientsCollection);
+    console.log(
+      `[getAllPatientsUtil] Fetching patients with options:`,
+      options
+    );
+    const patientsCollection = (0, import_firestore10.collection)(db, PATIENTS_COLLECTION);
+    let q = (0, import_firestore10.query)(patientsCollection);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore8.query)(q, (0, import_firestore8.limit)(options.limit));
+      q = (0, import_firestore10.query)(q, (0, import_firestore10.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore8.getDoc)((0, import_firestore8.doc)(db, PATIENTS_COLLECTION, options.startAfter));
+      const startAfterDoc = await (0, import_firestore10.getDoc)(
+        (0, import_firestore10.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore8.query)(q, (0, import_firestore8.startAfter)(startAfterDoc));
+        q = (0, import_firestore10.query)(q, (0, import_firestore10.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore8.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore10.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2439,8 +2799,8 @@ var getAllPatientsUtil = async (db, options) => {
 };
 
 // src/services/patient/utils/location.utils.ts
-var import_firestore9 = require("firebase/firestore");
-var import_zod9 = require("zod");
+var import_firestore11 = require("firebase/firestore");
+var import_zod10 = require("zod");
 var import_geofire_common = require("geofire-common");
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -2450,9 +2810,9 @@ var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   };
   const updateData = {
     locationData,
-    updatedAt: (0, import_firestore9.serverTimestamp)()
+    updatedAt: (0, import_firestore11.serverTimestamp)()
   };
-  await (0, import_firestore9.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
+  await (0, import_firestore11.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
 };
 var createLocationInfoUtil = async (db, data, requesterId) => {
   try {
@@ -2469,17 +2829,17 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
           validatedData.locationData.longitude
         ])
       },
-      createdAt: (0, import_firestore9.serverTimestamp)(),
-      updatedAt: (0, import_firestore9.serverTimestamp)()
+      createdAt: (0, import_firestore11.serverTimestamp)(),
+      updatedAt: (0, import_firestore11.serverTimestamp)()
     };
-    await (0, import_firestore9.setDoc)(getLocationInfoDocRef(db, data.patientId), locationData);
-    const locationDoc = await (0, import_firestore9.getDoc)(getLocationInfoDocRef(db, data.patientId));
+    await (0, import_firestore11.setDoc)(getLocationInfoDocRef(db, data.patientId), locationData);
+    const locationDoc = await (0, import_firestore11.getDoc)(getLocationInfoDocRef(db, data.patientId));
     if (!locationDoc.exists()) {
       throw new Error("Failed to create location information");
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof import_zod9.z.ZodError) {
+    if (error instanceof import_zod10.z.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -2489,7 +2849,7 @@ var getLocationInfoUtil = async (db, patientId, requesterId) => {
   if (patientId !== requesterId) {
     throw new Error("Unauthorized access to location information");
   }
-  const locationDoc = await (0, import_firestore9.getDoc)(getLocationInfoDocRef(db, patientId));
+  const locationDoc = await (0, import_firestore11.getDoc)(getLocationInfoDocRef(db, patientId));
   return locationDoc.exists() ? locationDoc.data() : null;
 };
 var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
@@ -2506,8 +2866,8 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
       ])
     };
   }
-  updateData.updatedAt = (0, import_firestore9.serverTimestamp)();
-  await (0, import_firestore9.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
+  updateData.updatedAt = (0, import_firestore11.serverTimestamp)();
+  await (0, import_firestore11.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
   const updatedInfo = await getLocationInfoUtil(db, patientId, requesterId);
   if (!updatedInfo) {
     throw new Error("Failed to retrieve updated location information");
@@ -2516,127 +2876,127 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
 };
 
 // src/services/patient/utils/medical-stuff.utils.ts
-var import_firestore10 = require("firebase/firestore");
+var import_firestore12 = require("firebase/firestore");
 var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
   var _a;
   const newDoctor = {
     userRef: doctorRef,
-    assignedAt: import_firestore10.Timestamp.now(),
+    assignedAt: import_firestore12.Timestamp.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore12.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingDoctorIndex = (_a = patientData.doctors) == null ? void 0 : _a.findIndex(
     (d) => d.userRef === doctorRef
   );
   const updates = {
-    updatedAt: (0, import_firestore10.serverTimestamp)(),
-    doctorIds: (0, import_firestore10.arrayUnion)(doctorRef)
+    updatedAt: (0, import_firestore12.serverTimestamp)(),
+    doctorIds: (0, import_firestore12.arrayUnion)(doctorRef)
   };
   if (existingDoctorIndex !== void 0 && existingDoctorIndex > -1) {
     const updatedDoctors = [...patientData.doctors];
     updatedDoctors[existingDoctorIndex] = {
       ...updatedDoctors[existingDoctorIndex],
       isActive: true,
-      assignedAt: import_firestore10.Timestamp.now(),
+      assignedAt: import_firestore12.Timestamp.now(),
       assignedBy
     };
     updates.doctors = updatedDoctors;
   } else {
-    updates.doctors = (0, import_firestore10.arrayUnion)(newDoctor);
+    updates.doctors = (0, import_firestore12.arrayUnion)(newDoctor);
   }
-  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), updates);
+  await (0, import_firestore12.updateDoc)(getPatientDocRef(db, patientId), updates);
 };
 var removeDoctorUtil = async (db, patientId, doctorRef) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await (0, import_firestore10.getDoc)(patientDocRef);
+  const patientDoc = await (0, import_firestore12.getDoc)(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedDoctors = ((_a = patientData.doctors) == null ? void 0 : _a.filter((doctor) => doctor.userRef !== doctorRef)) || [];
-  await (0, import_firestore10.updateDoc)(patientDocRef, {
+  await (0, import_firestore12.updateDoc)(patientDocRef, {
     doctors: updatedDoctors,
     // Set the filtered array
-    doctorIds: (0, import_firestore10.arrayRemove)(doctorRef),
+    doctorIds: (0, import_firestore12.arrayRemove)(doctorRef),
     // Remove ID from the denormalized list
-    updatedAt: (0, import_firestore10.serverTimestamp)()
+    updatedAt: (0, import_firestore12.serverTimestamp)()
   });
 };
 var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
   var _a;
   const newClinic = {
     clinicId,
-    assignedAt: import_firestore10.Timestamp.now(),
+    assignedAt: import_firestore12.Timestamp.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore12.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingClinicIndex = (_a = patientData.clinics) == null ? void 0 : _a.findIndex(
     (c) => c.clinicId === clinicId
   );
   const updates = {
-    updatedAt: (0, import_firestore10.serverTimestamp)(),
-    clinicIds: (0, import_firestore10.arrayUnion)(clinicId)
+    updatedAt: (0, import_firestore12.serverTimestamp)(),
+    clinicIds: (0, import_firestore12.arrayUnion)(clinicId)
   };
   if (existingClinicIndex !== void 0 && existingClinicIndex > -1) {
     const updatedClinics = [...patientData.clinics];
     updatedClinics[existingClinicIndex] = {
       ...updatedClinics[existingClinicIndex],
       isActive: true,
-      assignedAt: import_firestore10.Timestamp.now(),
+      assignedAt: import_firestore12.Timestamp.now(),
       assignedBy
     };
     updates.clinics = updatedClinics;
   } else {
-    updates.clinics = (0, import_firestore10.arrayUnion)(newClinic);
+    updates.clinics = (0, import_firestore12.arrayUnion)(newClinic);
   }
-  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), updates);
+  await (0, import_firestore12.updateDoc)(getPatientDocRef(db, patientId), updates);
 };
 var removeClinicUtil = async (db, patientId, clinicId) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await (0, import_firestore10.getDoc)(patientDocRef);
+  const patientDoc = await (0, import_firestore12.getDoc)(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedClinics = ((_a = patientData.clinics) == null ? void 0 : _a.filter((clinic) => clinic.clinicId !== clinicId)) || [];
-  await (0, import_firestore10.updateDoc)(patientDocRef, {
+  await (0, import_firestore12.updateDoc)(patientDocRef, {
     clinics: updatedClinics,
     // Set the filtered array
-    clinicIds: (0, import_firestore10.arrayRemove)(clinicId),
+    clinicIds: (0, import_firestore12.arrayRemove)(clinicId),
     // Remove ID from the denormalized list
-    updatedAt: (0, import_firestore10.serverTimestamp)()
+    updatedAt: (0, import_firestore12.serverTimestamp)()
   });
 };
 
 // src/services/patient/utils/clinic.utils.ts
-var import_firestore11 = require("firebase/firestore");
+var import_firestore13 = require("firebase/firestore");
 var getPatientsByClinicUtil = async (db, clinicId, options) => {
   try {
     console.log(
       `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore11.collection)(db, PATIENTS_COLLECTION);
+    const patientsCollection = (0, import_firestore13.collection)(db, PATIENTS_COLLECTION);
     const constraints = [
-      (0, import_firestore11.where)("clinicIds", "array-contains", clinicId)
+      (0, import_firestore13.where)("clinicIds", "array-contains", clinicId)
     ];
-    let q = (0, import_firestore11.query)(patientsCollection, ...constraints);
+    let q = (0, import_firestore13.query)(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore11.query)(q, (0, import_firestore11.limit)(options.limit));
+      q = (0, import_firestore13.query)(q, (0, import_firestore13.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore11.getDoc)(
-        (0, import_firestore11.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore13.getDoc)(
+        (0, import_firestore13.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore11.query)(q, (0, import_firestore11.startAfter)(startAfterDoc));
+        q = (0, import_firestore13.query)(q, (0, import_firestore13.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore11.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore13.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2660,6 +3020,7 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
 var PatientService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
+    this.mediaService = new MediaService(db, auth, app);
   }
   // Metode za rad sa profilom pacijenta
   async createPatientProfile(data) {
@@ -2696,7 +3057,12 @@ var PatientService = class extends BaseService {
   }
   // Metode za rad sa osetljivim informacijama
   async createSensitiveInfo(data, requesterUserId) {
-    return createSensitiveInfoUtil(this.db, data, requesterUserId);
+    return createSensitiveInfoUtil(
+      this.db,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
   async getSensitiveInfo(patientId, requesterUserId) {
     return getSensitiveInfoUtil(this.db, patientId, requesterUserId);
@@ -2707,7 +3073,13 @@ var PatientService = class extends BaseService {
     return this.getSensitiveInfo(profile.id, requesterUserId);
   }
   async updateSensitiveInfo(patientId, data, requesterUserId) {
-    return updateSensitiveInfoUtil(this.db, patientId, data, requesterUserId);
+    return updateSensitiveInfoUtil(
+      this.db,
+      patientId,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
   // Metode za rad sa medicinskim informacijama
   async createMedicalInfo(patientId, data) {
@@ -2840,8 +3212,8 @@ var PatientService = class extends BaseService {
     if (!this.auth.currentUser) {
       throw new Error("No authenticated user");
     }
-    const userDoc = await (0, import_firestore12.getDoc)(
-      (0, import_firestore12.doc)(this.db, "users", this.auth.currentUser.uid)
+    const userDoc = await (0, import_firestore14.getDoc)(
+      (0, import_firestore14.doc)(this.db, "users", this.auth.currentUser.uid)
     );
     if (!userDoc.exists()) {
       throw new Error("User not found");
@@ -2852,7 +3224,7 @@ var PatientService = class extends BaseService {
    * Briše profil pacijenta i sve povezane subkolekcije
    */
   async deletePatientProfile(patientId) {
-    const batch = (0, import_firestore12.writeBatch)(this.db);
+    const batch = (0, import_firestore14.writeBatch)(this.db);
     batch.delete(getSensitiveInfoDocRef(this.db, patientId));
     batch.delete(getLocationInfoDocRef(this.db, patientId));
     batch.delete(getMedicalInfoDocRef(this.db, patientId));
@@ -2876,14 +3248,113 @@ var PatientService = class extends BaseService {
     await removeClinicUtil(this.db, patientId, clinicId);
   }
   // Metode za rad sa profilnom slikom
+  /**
+   * Uploads a profile photo for a patient
+   * @param patientId - ID of the patient
+   * @param file - File or Blob to upload
+   * @returns URL of the uploaded photo
+   */
   async uploadProfilePhoto(patientId, file) {
-    return uploadProfilePhotoUtil(this.storage, patientId, file);
+    console.log(
+      `[PatientService] Uploading profile photo for patient ${patientId}`
+    );
+    const mediaMetadata = await this.mediaService.uploadMedia(
+      file,
+      patientId,
+      // Using patientId as ownerId
+      "private" /* PRIVATE */,
+      // Profile photos should be private
+      "patient_profile_photos",
+      file instanceof File ? file.name : `profile_photo_${patientId}`
+    );
+    await (0, import_firestore14.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
+      photoUrl: mediaMetadata.url,
+      updatedAt: (0, import_firestore14.serverTimestamp)()
+    });
+    return mediaMetadata.url;
   }
+  /**
+   * Updates a patient's profile photo (replaces existing one)
+   * @param patientId - ID of the patient
+   * @param file - New file or Blob to upload
+   * @returns URL of the new uploaded photo
+   */
   async updateProfilePhoto(patientId, file) {
-    return updateProfilePhotoUtil(this.storage, this.db, patientId, file);
+    console.log(
+      `[PatientService] Updating profile photo for patient ${patientId}`
+    );
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+    if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+    }
+    return this.uploadProfilePhoto(patientId, file);
   }
+  /**
+   * Deletes a patient's profile photo
+   * @param patientId - ID of the patient
+   */
   async deleteProfilePhoto(patientId) {
-    await deleteProfilePhotoUtil(this.storage, this.db, patientId);
+    console.log(
+      `[PatientService] Deleting profile photo for patient ${patientId}`
+    );
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+    if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+      await (0, import_firestore14.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
+        photoUrl: null,
+        updatedAt: (0, import_firestore14.serverTimestamp)()
+      });
+    }
+  }
+  /**
+   * Handles profile photo upload for patients (supports MediaResource)
+   * @param photoUrl - MediaResource (File, Blob, or URL string) from CreatePatientSensitiveInfoData
+   * @param patientId - ID of the patient
+   * @returns URL string of the uploaded or existing photo
+   */
+  async handleProfilePhotoUpload(photoUrl, patientId) {
+    if (!photoUrl) {
+      return void 0;
+    }
+    if (typeof photoUrl === "string") {
+      return photoUrl;
+    }
+    if (photoUrl instanceof File || photoUrl instanceof Blob) {
+      return this.uploadProfilePhoto(patientId, photoUrl);
+    }
+    return void 0;
   }
   // Metode za ažuriranje profila
   async updatePatientProfile(patientId, data) {
@@ -2976,7 +3447,7 @@ var PatientService = class extends BaseService {
 };
 
 // src/services/clinic/utils/admin.utils.ts
-var import_firestore14 = require("firebase/firestore");
+var import_firestore16 = require("firebase/firestore");
 
 // src/types/clinic/preferences.types.ts
 var PracticeType = /* @__PURE__ */ ((PracticeType2) => {
@@ -3103,131 +3574,131 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 
 // src/validations/clinic.schema.ts
 var import_zod13 = require("zod");
-var import_firestore13 = require("firebase/firestore");
+var import_firestore15 = require("firebase/firestore");
 
 // src/validations/reviews.schema.ts
-var import_zod10 = require("zod");
-var baseReviewSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  patientId: import_zod10.z.string().min(1),
-  fullReviewId: import_zod10.z.string().min(1),
-  createdAt: import_zod10.z.date(),
-  updatedAt: import_zod10.z.date(),
-  comment: import_zod10.z.string().min(1).max(2e3),
-  isVerified: import_zod10.z.boolean(),
-  isPublished: import_zod10.z.boolean()
+var import_zod11 = require("zod");
+var baseReviewSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  patientId: import_zod11.z.string().min(1),
+  fullReviewId: import_zod11.z.string().min(1),
+  createdAt: import_zod11.z.date(),
+  updatedAt: import_zod11.z.date(),
+  comment: import_zod11.z.string().min(1).max(2e3),
+  isVerified: import_zod11.z.boolean(),
+  isPublished: import_zod11.z.boolean()
 });
-var baseReviewCreateSchema = import_zod10.z.object({
-  patientId: import_zod10.z.string().min(1),
-  comment: import_zod10.z.string().min(1).max(2e3),
-  isVerified: import_zod10.z.boolean().default(false),
-  isPublished: import_zod10.z.boolean().default(true)
+var baseReviewCreateSchema = import_zod11.z.object({
+  patientId: import_zod11.z.string().min(1),
+  comment: import_zod11.z.string().min(1).max(2e3),
+  isVerified: import_zod11.z.boolean().default(false),
+  isPublished: import_zod11.z.boolean().default(true)
 });
 var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: import_zod10.z.string().min(1),
-  cleanliness: import_zod10.z.number().min(1).max(5),
-  facilities: import_zod10.z.number().min(1).max(5),
-  staffFriendliness: import_zod10.z.number().min(1).max(5),
-  waitingTime: import_zod10.z.number().min(1).max(5),
-  accessibility: import_zod10.z.number().min(1).max(5),
-  overallRating: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  clinicId: import_zod11.z.string().min(1),
+  cleanliness: import_zod11.z.number().min(1).max(5),
+  facilities: import_zod11.z.number().min(1).max(5),
+  staffFriendliness: import_zod11.z.number().min(1).max(5),
+  waitingTime: import_zod11.z.number().min(1).max(5),
+  accessibility: import_zod11.z.number().min(1).max(5),
+  overallRating: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: import_zod10.z.string().min(1),
-  cleanliness: import_zod10.z.number().min(1).max(5),
-  facilities: import_zod10.z.number().min(1).max(5),
-  staffFriendliness: import_zod10.z.number().min(1).max(5),
-  waitingTime: import_zod10.z.number().min(1).max(5),
-  accessibility: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  clinicId: import_zod11.z.string().min(1),
+  cleanliness: import_zod11.z.number().min(1).max(5),
+  facilities: import_zod11.z.number().min(1).max(5),
+  staffFriendliness: import_zod11.z.number().min(1).max(5),
+  waitingTime: import_zod11.z.number().min(1).max(5),
+  accessibility: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: import_zod10.z.string().min(1),
-  knowledgeAndExpertise: import_zod10.z.number().min(1).max(5),
-  communicationSkills: import_zod10.z.number().min(1).max(5),
-  bedSideManner: import_zod10.z.number().min(1).max(5),
-  thoroughness: import_zod10.z.number().min(1).max(5),
-  trustworthiness: import_zod10.z.number().min(1).max(5),
-  overallRating: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  practitionerId: import_zod11.z.string().min(1),
+  knowledgeAndExpertise: import_zod11.z.number().min(1).max(5),
+  communicationSkills: import_zod11.z.number().min(1).max(5),
+  bedSideManner: import_zod11.z.number().min(1).max(5),
+  thoroughness: import_zod11.z.number().min(1).max(5),
+  trustworthiness: import_zod11.z.number().min(1).max(5),
+  overallRating: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: import_zod10.z.string().min(1),
-  knowledgeAndExpertise: import_zod10.z.number().min(1).max(5),
-  communicationSkills: import_zod10.z.number().min(1).max(5),
-  bedSideManner: import_zod10.z.number().min(1).max(5),
-  thoroughness: import_zod10.z.number().min(1).max(5),
-  trustworthiness: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  practitionerId: import_zod11.z.string().min(1),
+  knowledgeAndExpertise: import_zod11.z.number().min(1).max(5),
+  communicationSkills: import_zod11.z.number().min(1).max(5),
+  bedSideManner: import_zod11.z.number().min(1).max(5),
+  thoroughness: import_zod11.z.number().min(1).max(5),
+  trustworthiness: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: import_zod10.z.string().min(1),
-  effectivenessOfTreatment: import_zod10.z.number().min(1).max(5),
-  outcomeExplanation: import_zod10.z.number().min(1).max(5),
-  painManagement: import_zod10.z.number().min(1).max(5),
-  followUpCare: import_zod10.z.number().min(1).max(5),
-  valueForMoney: import_zod10.z.number().min(1).max(5),
-  overallRating: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  procedureId: import_zod11.z.string().min(1),
+  effectivenessOfTreatment: import_zod11.z.number().min(1).max(5),
+  outcomeExplanation: import_zod11.z.number().min(1).max(5),
+  painManagement: import_zod11.z.number().min(1).max(5),
+  followUpCare: import_zod11.z.number().min(1).max(5),
+  valueForMoney: import_zod11.z.number().min(1).max(5),
+  overallRating: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: import_zod10.z.string().min(1),
-  effectivenessOfTreatment: import_zod10.z.number().min(1).max(5),
-  outcomeExplanation: import_zod10.z.number().min(1).max(5),
-  painManagement: import_zod10.z.number().min(1).max(5),
-  followUpCare: import_zod10.z.number().min(1).max(5),
-  valueForMoney: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  procedureId: import_zod11.z.string().min(1),
+  effectivenessOfTreatment: import_zod11.z.number().min(1).max(5),
+  outcomeExplanation: import_zod11.z.number().min(1).max(5),
+  painManagement: import_zod11.z.number().min(1).max(5),
+  followUpCare: import_zod11.z.number().min(1).max(5),
+  valueForMoney: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
-var clinicReviewInfoSchema = import_zod10.z.object({
-  totalReviews: import_zod10.z.number().min(0),
-  averageRating: import_zod10.z.number().min(0).max(5),
-  cleanliness: import_zod10.z.number().min(0).max(5),
-  facilities: import_zod10.z.number().min(0).max(5),
-  staffFriendliness: import_zod10.z.number().min(0).max(5),
-  waitingTime: import_zod10.z.number().min(0).max(5),
-  accessibility: import_zod10.z.number().min(0).max(5),
-  recommendationPercentage: import_zod10.z.number().min(0).max(100)
+var clinicReviewInfoSchema = import_zod11.z.object({
+  totalReviews: import_zod11.z.number().min(0),
+  averageRating: import_zod11.z.number().min(0).max(5),
+  cleanliness: import_zod11.z.number().min(0).max(5),
+  facilities: import_zod11.z.number().min(0).max(5),
+  staffFriendliness: import_zod11.z.number().min(0).max(5),
+  waitingTime: import_zod11.z.number().min(0).max(5),
+  accessibility: import_zod11.z.number().min(0).max(5),
+  recommendationPercentage: import_zod11.z.number().min(0).max(100)
 });
-var practitionerReviewInfoSchema = import_zod10.z.object({
-  totalReviews: import_zod10.z.number().min(0),
-  averageRating: import_zod10.z.number().min(0).max(5),
-  knowledgeAndExpertise: import_zod10.z.number().min(0).max(5),
-  communicationSkills: import_zod10.z.number().min(0).max(5),
-  bedSideManner: import_zod10.z.number().min(0).max(5),
-  thoroughness: import_zod10.z.number().min(0).max(5),
-  trustworthiness: import_zod10.z.number().min(0).max(5),
-  recommendationPercentage: import_zod10.z.number().min(0).max(100)
+var practitionerReviewInfoSchema = import_zod11.z.object({
+  totalReviews: import_zod11.z.number().min(0),
+  averageRating: import_zod11.z.number().min(0).max(5),
+  knowledgeAndExpertise: import_zod11.z.number().min(0).max(5),
+  communicationSkills: import_zod11.z.number().min(0).max(5),
+  bedSideManner: import_zod11.z.number().min(0).max(5),
+  thoroughness: import_zod11.z.number().min(0).max(5),
+  trustworthiness: import_zod11.z.number().min(0).max(5),
+  recommendationPercentage: import_zod11.z.number().min(0).max(100)
 });
-var procedureReviewInfoSchema = import_zod10.z.object({
-  totalReviews: import_zod10.z.number().min(0),
-  averageRating: import_zod10.z.number().min(0).max(5),
-  effectivenessOfTreatment: import_zod10.z.number().min(0).max(5),
-  outcomeExplanation: import_zod10.z.number().min(0).max(5),
-  painManagement: import_zod10.z.number().min(0).max(5),
-  followUpCare: import_zod10.z.number().min(0).max(5),
-  valueForMoney: import_zod10.z.number().min(0).max(5),
-  recommendationPercentage: import_zod10.z.number().min(0).max(100)
+var procedureReviewInfoSchema = import_zod11.z.object({
+  totalReviews: import_zod11.z.number().min(0),
+  averageRating: import_zod11.z.number().min(0).max(5),
+  effectivenessOfTreatment: import_zod11.z.number().min(0).max(5),
+  outcomeExplanation: import_zod11.z.number().min(0).max(5),
+  painManagement: import_zod11.z.number().min(0).max(5),
+  followUpCare: import_zod11.z.number().min(0).max(5),
+  valueForMoney: import_zod11.z.number().min(0).max(5),
+  recommendationPercentage: import_zod11.z.number().min(0).max(100)
 });
-var reviewSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  appointmentId: import_zod10.z.string().min(1),
-  patientId: import_zod10.z.string().min(1),
-  createdAt: import_zod10.z.date(),
-  updatedAt: import_zod10.z.date(),
+var reviewSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  appointmentId: import_zod11.z.string().min(1),
+  patientId: import_zod11.z.string().min(1),
+  createdAt: import_zod11.z.date(),
+  updatedAt: import_zod11.z.date(),
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
-  overallComment: import_zod10.z.string().min(1).max(2e3),
-  overallRating: import_zod10.z.number().min(1).max(5)
+  overallComment: import_zod11.z.string().min(1).max(2e3),
+  overallRating: import_zod11.z.number().min(1).max(5)
 });
-var createReviewSchema = import_zod10.z.object({
-  patientId: import_zod10.z.string().min(1),
+var createReviewSchema = import_zod11.z.object({
+  patientId: import_zod11.z.string().min(1),
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: import_zod10.z.string().min(1).max(2e3)
+  overallComment: import_zod11.z.string().min(1).max(2e3)
 }).refine(
   (data) => {
     return data.clinicReview || data.practitionerReview || data.procedureReview;
@@ -3239,7 +3710,7 @@ var createReviewSchema = import_zod10.z.object({
 );
 
 // src/validations/shared.schema.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/backoffice/types/static/procedure-family.types.ts
 var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
@@ -3268,65 +3739,57 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
 })(Currency || {});
 
 // src/validations/shared.schema.ts
-var sharedClinicContactInfoSchema = import_zod11.z.object({
-  email: import_zod11.z.string().email(),
-  phoneNumber: import_zod11.z.string(),
-  alternativePhoneNumber: import_zod11.z.string().nullable().optional(),
-  website: import_zod11.z.string().nullable().optional()
+var sharedClinicContactInfoSchema = import_zod12.z.object({
+  email: import_zod12.z.string().email(),
+  phoneNumber: import_zod12.z.string(),
+  alternativePhoneNumber: import_zod12.z.string().nullable().optional(),
+  website: import_zod12.z.string().nullable().optional()
 });
-var sharedClinicLocationSchema = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  city: import_zod11.z.string(),
-  country: import_zod11.z.string(),
-  postalCode: import_zod11.z.string(),
-  latitude: import_zod11.z.number().min(-90).max(90),
-  longitude: import_zod11.z.number().min(-180).max(180),
-  geohash: import_zod11.z.string().nullable().optional()
+var sharedClinicLocationSchema = import_zod12.z.object({
+  address: import_zod12.z.string(),
+  city: import_zod12.z.string(),
+  country: import_zod12.z.string(),
+  postalCode: import_zod12.z.string(),
+  latitude: import_zod12.z.number().min(-90).max(90),
+  longitude: import_zod12.z.number().min(-180).max(180),
+  geohash: import_zod12.z.string().nullable().optional()
 });
-var procedureSummaryInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string().min(1),
-  name: import_zod11.z.string().min(1),
-  description: import_zod11.z.string().optional(),
-  photo: import_zod11.z.string().optional(),
-  family: import_zod11.z.nativeEnum(ProcedureFamily),
-  categoryName: import_zod11.z.string(),
-  subcategoryName: import_zod11.z.string(),
-  technologyName: import_zod11.z.string(),
-  price: import_zod11.z.number().nonnegative(),
-  pricingMeasure: import_zod11.z.nativeEnum(PricingMeasure),
-  currency: import_zod11.z.nativeEnum(Currency),
-  duration: import_zod11.z.number().int().positive(),
-  clinicId: import_zod11.z.string().min(1),
-  clinicName: import_zod11.z.string().min(1),
-  practitionerId: import_zod11.z.string().min(1),
-  practitionerName: import_zod11.z.string().min(1)
+var procedureSummaryInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string().min(1),
+  name: import_zod12.z.string().min(1),
+  description: import_zod12.z.string().optional(),
+  photo: import_zod12.z.string().optional(),
+  family: import_zod12.z.nativeEnum(ProcedureFamily),
+  categoryName: import_zod12.z.string(),
+  subcategoryName: import_zod12.z.string(),
+  technologyName: import_zod12.z.string(),
+  price: import_zod12.z.number().nonnegative(),
+  pricingMeasure: import_zod12.z.nativeEnum(PricingMeasure),
+  currency: import_zod12.z.nativeEnum(Currency),
+  duration: import_zod12.z.number().int().positive(),
+  clinicId: import_zod12.z.string().min(1),
+  clinicName: import_zod12.z.string().min(1),
+  practitionerId: import_zod12.z.string().min(1),
+  practitionerName: import_zod12.z.string().min(1)
 });
-var clinicInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  featuredPhoto: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
+var clinicInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  featuredPhoto: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
   location: sharedClinicLocationSchema,
   contactInfo: sharedClinicContactInfoSchema
 });
-var doctorInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
-  photo: import_zod11.z.string(),
-  rating: import_zod11.z.number().min(0).max(5),
-  services: import_zod11.z.array(import_zod11.z.string())
+var doctorInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
+  photo: import_zod12.z.string(),
+  rating: import_zod12.z.number().min(0).max(5),
+  services: import_zod12.z.array(import_zod12.z.string())
   // List of procedure IDs practitioner offers
 });
 
-// src/validations/media.schema.ts
-var import_zod12 = require("zod");
-var mediaResourceSchema = import_zod12.z.union([
-  import_zod12.z.string(),
-  import_zod12.z.instanceof(File),
-  import_zod12.z.instanceof(Blob)
-]);
-
 // src/validations/clinic.schema.ts
 var clinicContactInfoSchema = import_zod13.z.object({
   email: import_zod13.z.string().email(),
@@ -3386,8 +3849,8 @@ var clinicAdminSchema = import_zod13.z.object({
   clinicsManagedInfo: import_zod13.z.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
   roleTitle: import_zod13.z.string(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   isActive: import_zod13.z.boolean()
 });
 var adminTokenSchema = import_zod13.z.object({
@@ -3396,9 +3859,9 @@ var adminTokenSchema = import_zod13.z.object({
   email: import_zod13.z.string().email().optional().nullable(),
   status: import_zod13.z.nativeEnum(AdminTokenStatus),
   usedByUserRef: import_zod13.z.string().optional(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
-  expiresAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp))
+  expiresAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp))
   // Timestamp
 });
 var createAdminTokenSchema = import_zod13.z.object({
@@ -3418,9 +3881,9 @@ var clinicGroupSchema = import_zod13.z.object({
   adminsInfo: import_zod13.z.array(adminInfoSchema),
   adminTokens: import_zod13.z.array(adminTokenSchema),
   ownerId: import_zod13.z.string().nullable(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
   isActive: import_zod13.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
@@ -3462,9 +3925,9 @@ var clinicSchema = import_zod13.z.object({
   // Use the correct schema for aggregated procedure info
   reviewInfo: clinicReviewInfoSchema,
   admins: import_zod13.z.array(import_zod13.z.string()),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
   isActive: import_zod13.z.boolean(),
   isVerified: import_zod13.z.boolean(),
@@ -3686,7 +4149,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
   const adminData = {
-    id: (0, import_firestore14.doc)((0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
+    id: (0, import_firestore16.doc)((0, import_firestore16.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
     // Generate a new ID for the admin document
     userRef: validatedData.userRef,
     clinicGroupId: clinicGroupId || "",
@@ -3699,15 +4162,15 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     contactInfo: validatedData.contactInfo,
     roleTitle: validatedData.roleTitle,
     isActive: validatedData.isActive,
-    createdAt: (0, import_firestore14.serverTimestamp)(),
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    createdAt: (0, import_firestore16.serverTimestamp)(),
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   };
   console.log("[CLINIC_ADMIN] Validating complete admin object");
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: import_firestore14.Timestamp.now(),
-      updatedAt: import_firestore14.Timestamp.now()
+      createdAt: import_firestore16.Timestamp.now(),
+      updatedAt: import_firestore16.Timestamp.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -3721,7 +4184,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     adminId: adminData.id
   });
   try {
-    await (0, import_firestore14.setDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
     console.log("[CLINIC_ADMIN] Admin saved successfully");
   } catch (firestoreError) {
     console.error(
@@ -3770,30 +4233,30 @@ async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   return !!group;
 }
 async function getClinicAdmin(db, adminId) {
-  const docRef = (0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await (0, import_firestore14.getDoc)(docRef);
+  const docRef = (0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await (0, import_firestore16.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicAdminByUserRef(db, userRef) {
-  const q = (0, import_firestore14.query)(
-    (0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore14.where)("userRef", "==", userRef)
+  const q = (0, import_firestore16.query)(
+    (0, import_firestore16.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore16.where)("userRef", "==", userRef)
   );
-  const querySnapshot = await (0, import_firestore14.getDocs)(q);
+  const querySnapshot = await (0, import_firestore16.getDocs)(q);
   if (querySnapshot.empty) {
     return null;
   }
   return querySnapshot.docs[0].data();
 }
 async function getClinicAdminsByGroup(db, clinicGroupId) {
-  const q = (0, import_firestore14.query)(
-    (0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore14.where)("clinicGroupId", "==", clinicGroupId)
+  const q = (0, import_firestore16.query)(
+    (0, import_firestore16.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore16.where)("clinicGroupId", "==", clinicGroupId)
   );
-  const querySnapshot = await (0, import_firestore14.getDocs)(q);
+  const querySnapshot = await (0, import_firestore16.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
@@ -3803,9 +4266,9 @@ async function updateClinicAdmin(db, adminId, data) {
   }
   const updatedData = {
     ...data,
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   };
-  await (0, import_firestore14.updateDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+  await (0, import_firestore16.updateDoc)((0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
   const updatedAdmin = await getClinicAdmin(db, adminId);
   if (!updatedAdmin) {
     throw new Error("Failed to retrieve updated admin");
@@ -3817,7 +4280,7 @@ async function deleteClinicAdmin(db, adminId) {
   if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  await (0, import_firestore14.deleteDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
+  await (0, import_firestore16.deleteDoc)((0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
   const admin = await getClinicAdmin(db, adminId);
@@ -4060,11 +4523,11 @@ var ClinicAdminService = class extends BaseService {
 };
 
 // src/services/practitioner/practitioner.service.ts
-var import_firestore16 = require("firebase/firestore");
+var import_firestore18 = require("firebase/firestore");
 
 // src/validations/practitioner.schema.ts
 var import_zod14 = require("zod");
-var import_firestore15 = require("firebase/firestore");
+var import_firestore17 = require("firebase/firestore");
 
 // src/backoffice/types/static/certification.types.ts
 var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
@@ -4097,9 +4560,9 @@ var practitionerBasicInfoSchema = import_zod14.z.object({
   title: import_zod14.z.string().min(2).max(100),
   email: import_zod14.z.string().email(),
   phoneNumber: import_zod14.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  dateOfBirth: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
   gender: import_zod14.z.enum(["male", "female", "other"]),
-  profileImageUrl: import_zod14.z.string().url().optional(),
+  profileImageUrl: mediaResourceSchema.optional(),
   bio: import_zod14.z.string().max(1e3).optional(),
   languages: import_zod14.z.array(import_zod14.z.string()).min(1)
 });
@@ -4108,8 +4571,8 @@ var practitionerCertificationSchema = import_zod14.z.object({
   specialties: import_zod14.z.array(import_zod14.z.nativeEnum(CertificationSpecialty)),
   licenseNumber: import_zod14.z.string().min(3).max(50),
   issuingAuthority: import_zod14.z.string().min(2).max(100),
-  issueDate: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  expiryDate: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()).optional(),
+  issueDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  expiryDate: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).optional(),
   verificationStatus: import_zod14.z.enum(["pending", "verified", "rejected"])
 });
 var timeSlotSchema = import_zod14.z.object({
@@ -4126,8 +4589,8 @@ var practitionerWorkingHoursSchema = import_zod14.z.object({
   friday: timeSlotSchema,
   saturday: timeSlotSchema,
   sunday: timeSlotSchema,
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date())
 });
 var practitionerClinicWorkingHoursSchema = import_zod14.z.object({
   clinicId: import_zod14.z.string().min(1),
@@ -4141,8 +4604,8 @@ var practitionerClinicWorkingHoursSchema = import_zod14.z.object({
     sunday: timeSlotSchema
   }),
   isActive: import_zod14.z.boolean(),
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date())
 });
 var practitionerSchema = import_zod14.z.object({
   id: import_zod14.z.string().min(1),
@@ -4158,8 +4621,8 @@ var practitionerSchema = import_zod14.z.object({
   isActive: import_zod14.z.boolean(),
   isVerified: import_zod14.z.boolean(),
   status: import_zod14.z.nativeEnum(PractitionerStatus),
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  updatedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date())
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  updatedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date())
 });
 var createPractitionerSchema = import_zod14.z.object({
   userRef: import_zod14.z.string().min(1),
@@ -4191,10 +4654,10 @@ var practitionerTokenSchema = import_zod14.z.object({
   clinicId: import_zod14.z.string().min(1),
   status: import_zod14.z.nativeEnum(PractitionerTokenStatus),
   createdBy: import_zod14.z.string().min(1),
-  createdAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
-  expiresAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()),
+  createdAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
+  expiresAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()),
   usedBy: import_zod14.z.string().optional(),
-  usedAt: import_zod14.z.instanceof(import_firestore15.Timestamp).or(import_zod14.z.date()).optional()
+  usedAt: import_zod14.z.instanceof(import_firestore17.Timestamp).or(import_zod14.z.date()).optional()
 });
 var createPractitionerTokenSchema = import_zod14.z.object({
   practitionerId: import_zod14.z.string().min(1),
@@ -4211,7 +4674,7 @@ var practitionerSignupSchema = import_zod14.z.object({
   profileData: import_zod14.z.object({
     basicInfo: import_zod14.z.object({
       phoneNumber: import_zod14.z.string().optional(),
-      profileImageUrl: import_zod14.z.string().optional(),
+      profileImageUrl: mediaResourceSchema.optional(),
       gender: import_zod14.z.enum(["male", "female", "other"]).optional(),
       bio: import_zod14.z.string().optional()
     }).optional(),
@@ -4226,6 +4689,7 @@ var PractitionerService = class extends BaseService {
   constructor(db, auth, app, clinicService) {
     super(db, auth, app);
     this.clinicService = clinicService;
+    this.mediaService = new MediaService(db, auth, app);
   }
   getClinicService() {
     if (!this.clinicService) {
@@ -4236,6 +4700,53 @@ var PractitionerService = class extends BaseService {
   setClinicService(clinicService) {
     this.clinicService = clinicService;
   }
+  /**
+   * Handles profile photo upload for practitioners
+   * @param profilePhoto - MediaResource (File, Blob, or URL string)
+   * @param practitionerId - ID of the practitioner
+   * @returns URL string of the uploaded or existing photo
+   */
+  async handleProfilePhotoUpload(profilePhoto, practitionerId) {
+    if (!profilePhoto) {
+      return void 0;
+    }
+    if (typeof profilePhoto === "string") {
+      return profilePhoto;
+    }
+    if (profilePhoto instanceof File || profilePhoto instanceof Blob) {
+      console.log(
+        `[PractitionerService] Uploading profile photo for practitioner ${practitionerId}`
+      );
+      const mediaMetadata = await this.mediaService.uploadMedia(
+        profilePhoto,
+        practitionerId,
+        // Using practitionerId as ownerId
+        "public" /* PUBLIC */,
+        // Profile photos should be public
+        "practitioner_profile_photos",
+        profilePhoto instanceof File ? profilePhoto.name : `profile_photo_${practitionerId}`
+      );
+      return mediaMetadata.url;
+    }
+    return void 0;
+  }
+  /**
+   * Processes BasicPractitionerInfo to handle profile photo uploads
+   * @param basicInfo - The basic info containing potential MediaResource profile photo
+   * @param practitionerId - ID of the practitioner
+   * @returns Processed basic info with URL string for profileImageUrl
+   */
+  async processBasicInfo(basicInfo, practitionerId) {
+    const processedBasicInfo = { ...basicInfo };
+    if (basicInfo.profileImageUrl) {
+      const uploadedUrl = await this.handleProfilePhotoUpload(
+        basicInfo.profileImageUrl,
+        practitionerId
+      );
+      processedBasicInfo.profileImageUrl = uploadedUrl;
+    }
+    return processedBasicInfo;
+  }
   /**
    * Creates a new practitioner
    */
@@ -4256,7 +4767,10 @@ var PractitionerService = class extends BaseService {
       const practitioner = {
         id: practitionerId,
         userRef: validData.userRef,
-        basicInfo: validData.basicInfo,
+        basicInfo: await this.processBasicInfo(
+          validData.basicInfo,
+          practitionerId
+        ),
         certification: validData.certification,
         clinics: validData.clinics || [],
         clinicWorkingHours: validData.clinicWorkingHours || [],
@@ -4267,20 +4781,20 @@ var PractitionerService = class extends BaseService {
         isActive: validData.isActive !== void 0 ? validData.isActive : true,
         isVerified: validData.isVerified !== void 0 ? validData.isVerified : false,
         status: validData.status || "active" /* ACTIVE */,
-        createdAt: (0, import_firestore16.serverTimestamp)(),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
+        createdAt: (0, import_firestore18.serverTimestamp)(),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
       };
       practitionerSchema.parse({
         ...practitioner,
-        createdAt: import_firestore16.Timestamp.now(),
-        updatedAt: import_firestore16.Timestamp.now()
+        createdAt: import_firestore18.Timestamp.now(),
+        updatedAt: import_firestore18.Timestamp.now()
       });
-      const practitionerRef = (0, import_firestore16.doc)(
+      const practitionerRef = (0, import_firestore18.doc)(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      await (0, import_firestore16.setDoc)(practitionerRef, practitioner);
+      await (0, import_firestore18.setDoc)(practitionerRef, practitioner);
       const createdPractitioner = await this.getPractitioner(practitionerId);
       if (!createdPractitioner) {
         throw new Error(
@@ -4356,7 +4870,10 @@ var PractitionerService = class extends BaseService {
         id: practitionerId,
         userRef: "",
         // Prazno - biće popunjeno kada korisnik kreira nalog
-        basicInfo: validatedData.basicInfo,
+        basicInfo: await this.processBasicInfo(
+          validatedData.basicInfo,
+          practitionerId
+        ),
         certification: validatedData.certification,
         clinics,
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
@@ -4367,17 +4884,17 @@ var PractitionerService = class extends BaseService {
         isActive: validatedData.isActive !== void 0 ? validatedData.isActive : false,
         isVerified: validatedData.isVerified !== void 0 ? validatedData.isVerified : false,
         status: "draft" /* DRAFT */,
-        createdAt: (0, import_firestore16.serverTimestamp)(),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
+        createdAt: (0, import_firestore18.serverTimestamp)(),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
       };
       practitionerSchema.parse({
         ...practitionerData,
         userRef: "temp-for-validation",
-        createdAt: import_firestore16.Timestamp.now(),
-        updatedAt: import_firestore16.Timestamp.now()
+        createdAt: import_firestore18.Timestamp.now(),
+        updatedAt: import_firestore18.Timestamp.now()
       });
-      await (0, import_firestore16.setDoc)(
-        (0, import_firestore16.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
+      await (0, import_firestore18.setDoc)(
+        (0, import_firestore18.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
         practitionerData
       );
       const savedPractitioner = await this.getPractitioner(practitionerData.id);
@@ -4394,12 +4911,12 @@ var PractitionerService = class extends BaseService {
         clinicId,
         status: "active" /* ACTIVE */,
         createdBy,
-        createdAt: import_firestore16.Timestamp.now(),
-        expiresAt: import_firestore16.Timestamp.fromDate(expiration)
+        createdAt: import_firestore18.Timestamp.now(),
+        expiresAt: import_firestore18.Timestamp.fromDate(expiration)
       };
       practitionerTokenSchema.parse(token);
       const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
-      await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(this.db, tokenPath), token);
+      await (0, import_firestore18.setDoc)((0, import_firestore18.doc)(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
       if (error instanceof import_zod15.z.ZodError) {
@@ -4447,12 +4964,12 @@ var PractitionerService = class extends BaseService {
         clinicId: validatedData.clinicId,
         status: "active" /* ACTIVE */,
         createdBy,
-        createdAt: import_firestore16.Timestamp.now(),
-        expiresAt: import_firestore16.Timestamp.fromDate(expiration)
+        createdAt: import_firestore18.Timestamp.now(),
+        expiresAt: import_firestore18.Timestamp.fromDate(expiration)
       };
       practitionerTokenSchema.parse(token);
       const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
-      await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(this.db, tokenPath), token);
+      await (0, import_firestore18.setDoc)((0, import_firestore18.doc)(this.db, tokenPath), token);
       return token;
     } catch (error) {
       if (error instanceof import_zod15.z.ZodError) {
@@ -4467,16 +4984,16 @@ var PractitionerService = class extends BaseService {
    * @returns Array of active tokens
    */
   async getPractitionerActiveTokens(practitionerId) {
-    const tokensRef = (0, import_firestore16.collection)(
+    const tokensRef = (0, import_firestore18.collection)(
       this.db,
       `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
     );
-    const q = (0, import_firestore16.query)(
+    const q = (0, import_firestore18.query)(
       tokensRef,
-      (0, import_firestore16.where)("status", "==", "active" /* ACTIVE */),
-      (0, import_firestore16.where)("expiresAt", ">", import_firestore16.Timestamp.now())
+      (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
+      (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
     );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
@@ -4485,11 +5002,11 @@ var PractitionerService = class extends BaseService {
    * @returns The token if found and valid, null otherwise
    */
   async validateToken(tokenString) {
-    const practitionersRef = (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION);
-    const practitionersSnapshot = await (0, import_firestore16.getDocs)(practitionersRef);
+    const practitionersRef = (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await (0, import_firestore18.getDocs)(practitionersRef);
     for (const practitionerDoc of practitionersSnapshot.docs) {
       const practitionerId = practitionerDoc.id;
-      const tokensRef = (0, import_firestore16.collection)(
+      const tokensRef = (0, import_firestore18.collection)(
         this.db,
         `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
       );
@@ -4497,17 +5014,17 @@ var PractitionerService = class extends BaseService {
         `[PRACTITIONER] Validating token for practitioner ${practitionerId}`,
         {
           tokenString,
-          timestamp: import_firestore16.Timestamp.now().toDate()
+          timestamp: import_firestore18.Timestamp.now().toDate()
         }
       );
-      const q = (0, import_firestore16.query)(
+      const q = (0, import_firestore18.query)(
         tokensRef,
-        (0, import_firestore16.where)("token", "==", tokenString),
-        (0, import_firestore16.where)("status", "==", "active" /* ACTIVE */),
-        (0, import_firestore16.where)("expiresAt", ">", import_firestore16.Timestamp.now())
+        (0, import_firestore18.where)("token", "==", tokenString),
+        (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */),
+        (0, import_firestore18.where)("expiresAt", ">", import_firestore18.Timestamp.now())
       );
       try {
-        const tokenSnapshot = await (0, import_firestore16.getDocs)(q);
+        const tokenSnapshot = await (0, import_firestore18.getDocs)(q);
         console.log(
           `[PRACTITIONER] Token query results for practitioner ${practitionerId}`,
           {
@@ -4540,22 +5057,22 @@ var PractitionerService = class extends BaseService {
    * @param userId ID of the user using the token
    */
   async markTokenAsUsed(tokenId, practitionerId, userId) {
-    const tokenRef = (0, import_firestore16.doc)(
+    const tokenRef = (0, import_firestore18.doc)(
       this.db,
       `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
     );
-    await (0, import_firestore16.updateDoc)(tokenRef, {
+    await (0, import_firestore18.updateDoc)(tokenRef, {
       status: "used" /* USED */,
       usedBy: userId,
-      usedAt: import_firestore16.Timestamp.now()
+      usedAt: import_firestore18.Timestamp.now()
     });
   }
   /**
    * Dohvata zdravstvenog radnika po ID-u
    */
   async getPractitioner(practitionerId) {
-    const practitionerDoc = await (0, import_firestore16.getDoc)(
-      (0, import_firestore16.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId)
+    const practitionerDoc = await (0, import_firestore18.getDoc)(
+      (0, import_firestore18.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId)
     );
     if (!practitionerDoc.exists()) {
       return null;
@@ -4566,11 +5083,11 @@ var PractitionerService = class extends BaseService {
    * Dohvata zdravstvenog radnika po User ID-u
    */
   async getPractitionerByUserRef(userRef) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("userRef", "==", userRef)
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("userRef", "==", userRef)
     );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
     if (querySnapshot.empty) {
       return null;
     }
@@ -4580,37 +5097,37 @@ var PractitionerService = class extends BaseService {
    * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */
   async getPractitionersByClinic(clinicId) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore16.where)("isActive", "==", true),
-      (0, import_firestore16.where)("status", "==", "active" /* ACTIVE */)
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore18.where)("isActive", "==", true),
+      (0, import_firestore18.where)("status", "==", "active" /* ACTIVE */)
     );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
    */
   async getAllPractitionersByClinic(clinicId) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore16.where)("isActive", "==", true)
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore18.where)("isActive", "==", true)
     );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
    * Dohvata sve draft zdravstvene radnike za određenu kliniku sa statusom DRAFT
    */
   async getDraftPractitionersByClinic(clinicId) {
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
-      (0, import_firestore16.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore16.where)("status", "==", "draft" /* DRAFT */)
+    const q = (0, import_firestore18.query)(
+      (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore18.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore18.where)("status", "==", "draft" /* DRAFT */)
     );
-    const querySnapshot = await (0, import_firestore16.getDocs)(q);
+    const querySnapshot = await (0, import_firestore18.getDocs)(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
@@ -4619,21 +5136,28 @@ var PractitionerService = class extends BaseService {
   async updatePractitioner(practitionerId, data) {
     try {
       const validData = data;
-      const practitionerRef = (0, import_firestore16.doc)(
+      const practitionerRef = (0, import_firestore18.doc)(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      const practitionerDoc = await (0, import_firestore16.getDoc)(practitionerRef);
+      const practitionerDoc = await (0, import_firestore18.getDoc)(practitionerRef);
       if (!practitionerDoc.exists()) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
       const currentPractitioner = practitionerDoc.data();
+      let processedData = { ...validData };
+      if (validData.basicInfo) {
+        processedData.basicInfo = await this.processBasicInfo(
+          validData.basicInfo,
+          practitionerId
+        );
+      }
       const updateData = {
-        ...validData,
-        updatedAt: (0, import_firestore16.serverTimestamp)()
+        ...processedData,
+        updatedAt: (0, import_firestore18.serverTimestamp)()
       };
-      await (0, import_firestore16.updateDoc)(practitionerRef, updateData);
+      await (0, import_firestore18.updateDoc)(practitionerRef, updateData);
       const updatedPractitioner = await this.getPractitioner(practitionerId);
       if (!updatedPractitioner) {
         throw new Error(
@@ -4655,12 +5179,12 @@ var PractitionerService = class extends BaseService {
   async addClinic(practitionerId, clinicId) {
     var _a;
     try {
-      const practitionerRef = (0, import_firestore16.doc)(
+      const practitionerRef = (0, import_firestore18.doc)(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      const practitionerDoc = await (0, import_firestore16.getDoc)(practitionerRef);
+      const practitionerDoc = await (0, import_firestore18.getDoc)(practitionerRef);
       if (!practitionerDoc.exists()) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
@@ -4671,9 +5195,9 @@ var PractitionerService = class extends BaseService {
         );
         return;
       }
-      await (0, import_firestore16.updateDoc)(practitionerRef, {
-        clinics: (0, import_firestore16.arrayUnion)(clinicId),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
+      await (0, import_firestore18.updateDoc)(practitionerRef, {
+        clinics: (0, import_firestore18.arrayUnion)(clinicId),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
       });
     } catch (error) {
       console.error(
@@ -4688,18 +5212,18 @@ var PractitionerService = class extends BaseService {
    */
   async removeClinic(practitionerId, clinicId) {
     try {
-      const practitionerRef = (0, import_firestore16.doc)(
+      const practitionerRef = (0, import_firestore18.doc)(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      const practitionerDoc = await (0, import_firestore16.getDoc)(practitionerRef);
+      const practitionerDoc = await (0, import_firestore18.getDoc)(practitionerRef);
       if (!practitionerDoc.exists()) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
-      await (0, import_firestore16.updateDoc)(practitionerRef, {
-        clinics: (0, import_firestore16.arrayRemove)(clinicId),
-        updatedAt: (0, import_firestore16.serverTimestamp)()
+      await (0, import_firestore18.updateDoc)(practitionerRef, {
+        clinics: (0, import_firestore18.arrayRemove)(clinicId),
+        updatedAt: (0, import_firestore18.serverTimestamp)()
       });
     } catch (error) {
       console.error(
@@ -4733,7 +5257,7 @@ var PractitionerService = class extends BaseService {
     if (!practitioner) {
       throw new Error("Practitioner not found");
     }
-    await (0, import_firestore16.deleteDoc)((0, import_firestore16.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId));
+    await (0, import_firestore18.deleteDoc)((0, import_firestore18.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId));
   }
   /**
    * Validates a registration token and claims the associated draft practitioner profile
@@ -4802,21 +5326,21 @@ var PractitionerService = class extends BaseService {
     try {
       const constraints = [];
       if (!(options == null ? void 0 : options.includeDraftPractitioners)) {
-        constraints.push((0, import_firestore16.where)("status", "==", "active" /* ACTIVE */));
+        constraints.push((0, import_firestore18.where)("status", "==", "active" /* ACTIVE */));
       }
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.lastName", "asc"));
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.firstName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.lastName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.firstName", "asc"));
       if ((options == null ? void 0 : options.pagination) && options.pagination > 0) {
         if (options.lastDoc) {
-          constraints.push((0, import_firestore16.startAfter)(options.lastDoc));
+          constraints.push((0, import_firestore18.startAfter)(options.lastDoc));
         }
-        constraints.push((0, import_firestore16.limit)(options.pagination));
+        constraints.push((0, import_firestore18.limit)(options.pagination));
       }
-      const q = (0, import_firestore16.query)(
-        (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
+      const q = (0, import_firestore18.query)(
+        (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore16.getDocs)(q);
+      const querySnapshot = await (0, import_firestore18.getDocs)(q);
       const practitioners = querySnapshot.docs.map(
         (doc34) => doc34.data()
       );
@@ -4861,31 +5385,31 @@ var PractitionerService = class extends BaseService {
       );
       const constraints = [];
       if (!filters.includeDraftPractitioners) {
-        constraints.push((0, import_firestore16.where)("status", "==", "active" /* ACTIVE */));
+        constraints.push((0, import_firestore18.where)("status", "==", "active" /* ACTIVE */));
       }
-      constraints.push((0, import_firestore16.where)("isActive", "==", true));
+      constraints.push((0, import_firestore18.where)("isActive", "==", true));
       if (filters.certifications && filters.certifications.length > 0) {
         constraints.push(
-          (0, import_firestore16.where)(
+          (0, import_firestore18.where)(
             "certification.certifications",
             "array-contains-any",
             filters.certifications
           )
         );
       }
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.lastName", "asc"));
-      constraints.push((0, import_firestore16.orderBy)("basicInfo.firstName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.lastName", "asc"));
+      constraints.push((0, import_firestore18.orderBy)("basicInfo.firstName", "asc"));
       if (filters.pagination && filters.pagination > 0) {
         if (filters.lastDoc) {
-          constraints.push((0, import_firestore16.startAfter)(filters.lastDoc));
+          constraints.push((0, import_firestore18.startAfter)(filters.lastDoc));
         }
-        constraints.push((0, import_firestore16.limit)(filters.pagination));
+        constraints.push((0, import_firestore18.limit)(filters.pagination));
       }
-      const q = (0, import_firestore16.query)(
-        (0, import_firestore16.collection)(this.db, PRACTITIONERS_COLLECTION),
+      const q = (0, import_firestore18.query)(
+        (0, import_firestore18.collection)(this.db, PRACTITIONERS_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await (0, import_firestore16.getDocs)(q);
+      const querySnapshot = await (0, import_firestore18.getDocs)(q);
       console.log(
         `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
       );
@@ -5007,11 +5531,11 @@ var UserService = class extends BaseService {
       email: firebaseUser.email,
       roles: roles.length > 0 ? roles : ["patient" /* PATIENT */],
       isAnonymous: firebaseUser.isAnonymous,
-      createdAt: (0, import_firestore17.serverTimestamp)(),
-      updatedAt: (0, import_firestore17.serverTimestamp)(),
-      lastLoginAt: (0, import_firestore17.serverTimestamp)()
+      createdAt: (0, import_firestore19.serverTimestamp)(),
+      updatedAt: (0, import_firestore19.serverTimestamp)(),
+      lastLoginAt: (0, import_firestore19.serverTimestamp)()
     };
-    await (0, import_firestore17.setDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, userData.uid), userData);
+    await (0, import_firestore19.setDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, userData.uid), userData);
     if (options == null ? void 0 : options.skipProfileCreation) {
       return this.getUserById(userData.uid);
     }
@@ -5020,7 +5544,7 @@ var UserService = class extends BaseService {
       roles,
       options
     );
-    await (0, import_firestore17.updateDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, userData.uid), profiles);
+    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, userData.uid), profiles);
     return this.getUserById(userData.uid);
   }
   /**
@@ -5098,7 +5622,7 @@ var UserService = class extends BaseService {
               email: "",
               phoneNumber: "",
               title: "",
-              dateOfBirth: import_firestore17.Timestamp.now(),
+              dateOfBirth: import_firestore19.Timestamp.now(),
               gender: "other",
               languages: ["Serbian"]
             },
@@ -5107,7 +5631,7 @@ var UserService = class extends BaseService {
               specialties: [],
               licenseNumber: "",
               issuingAuthority: "",
-              issueDate: import_firestore17.Timestamp.now(),
+              issueDate: import_firestore19.Timestamp.now(),
               verificationStatus: "pending"
             },
             isActive: true,
@@ -5123,7 +5647,7 @@ var UserService = class extends BaseService {
    * Dohvata korisnika po ID-u
    */
   async getUserById(uid) {
-    const userDoc = await (0, import_firestore17.getDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid));
+    const userDoc = await (0, import_firestore19.getDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid));
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5134,19 +5658,19 @@ var UserService = class extends BaseService {
    * Dohvata korisnika po email-u
    */
   async getUserByEmail(email) {
-    const usersRef = (0, import_firestore17.collection)(this.db, USERS_COLLECTION);
-    const q = (0, import_firestore17.query)(usersRef, (0, import_firestore17.where)("email", "==", email));
-    const querySnapshot = await (0, import_firestore17.getDocs)(q);
+    const usersRef = (0, import_firestore19.collection)(this.db, USERS_COLLECTION);
+    const q = (0, import_firestore19.query)(usersRef, (0, import_firestore19.where)("email", "==", email));
+    const querySnapshot = await (0, import_firestore19.getDocs)(q);
     if (querySnapshot.empty) return null;
     const userData = querySnapshot.docs[0].data();
     return userSchema.parse(userData);
   }
   async getUsersByRole(role) {
     const constraints = [
-      (0, import_firestore17.where)("roles", "array-contains", role)
+      (0, import_firestore19.where)("roles", "array-contains", role)
     ];
-    const q = (0, import_firestore17.query)((0, import_firestore17.collection)(this.db, USERS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore17.getDocs)(q);
+    const q = (0, import_firestore19.query)((0, import_firestore19.collection)(this.db, USERS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore19.getDocs)(q);
     const users = querySnapshot.docs.map((doc34) => doc34.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
@@ -5154,33 +5678,33 @@ var UserService = class extends BaseService {
    * Ažurira timestamp poslednjeg logovanja
    */
   async updateUserLoginTimestamp(uid) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw AUTH_ERRORS.USER_NOT_FOUND;
     }
-    await (0, import_firestore17.updateDoc)(userRef, {
-      lastLoginAt: (0, import_firestore17.serverTimestamp)(),
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+    await (0, import_firestore19.updateDoc)(userRef, {
+      lastLoginAt: (0, import_firestore19.serverTimestamp)(),
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
     return this.getUserById(uid);
   }
   async upgradeAnonymousUser(uid, email) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
-    await (0, import_firestore17.updateDoc)(userRef, {
+    await (0, import_firestore19.updateDoc)(userRef, {
       email,
       isAnonymous: false,
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
     return this.getUserById(uid);
   }
   async updateUser(uid, updates) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5189,12 +5713,12 @@ var UserService = class extends BaseService {
       const updatedUser = {
         ...currentUser,
         ...updates,
-        updatedAt: (0, import_firestore17.serverTimestamp)()
+        updatedAt: (0, import_firestore19.serverTimestamp)()
       };
       userSchema.parse(updatedUser);
-      await (0, import_firestore17.updateDoc)(userRef, {
+      await (0, import_firestore19.updateDoc)(userRef, {
         ...updates,
-        updatedAt: (0, import_firestore17.serverTimestamp)()
+        updatedAt: (0, import_firestore19.serverTimestamp)()
       });
       return this.getUserById(uid);
     } catch (error) {
@@ -5211,10 +5735,10 @@ var UserService = class extends BaseService {
     const user = await this.getUserById(uid);
     if (user.roles.includes(role)) return;
     const profiles = await this.createProfilesForRoles(uid, [role], options);
-    await (0, import_firestore17.updateDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid), {
+    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid), {
       roles: [...user.roles, role],
       ...profiles,
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
   }
   /**
@@ -5246,15 +5770,15 @@ var UserService = class extends BaseService {
         }
         break;
     }
-    await (0, import_firestore17.updateDoc)((0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid), {
+    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid), {
       roles: user.roles.filter((r) => r !== role),
-      updatedAt: (0, import_firestore17.serverTimestamp)()
+      updatedAt: (0, import_firestore19.serverTimestamp)()
     });
   }
   // Delete operations
   async deleteUser(uid) {
-    const userRef = (0, import_firestore17.doc)(this.db, USERS_COLLECTION, uid);
-    const userDoc = await (0, import_firestore17.getDoc)(userRef);
+    const userRef = (0, import_firestore19.doc)(this.db, USERS_COLLECTION, uid);
+    const userDoc = await (0, import_firestore19.getDoc)(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5275,7 +5799,7 @@ var UserService = class extends BaseService {
           userData.adminProfile
         );
       }
-      await (0, import_firestore17.deleteDoc)(userRef);
+      await (0, import_firestore19.deleteDoc)(userRef);
     } catch (error) {
       throw error;
     }
@@ -5283,7 +5807,7 @@ var UserService = class extends BaseService {
 };
 
 // src/services/clinic/utils/clinic-group.utils.ts
-var import_firestore18 = require("firebase/firestore");
+var import_firestore20 = require("firebase/firestore");
 var import_geofire_common3 = require("geofire-common");
 var import_zod17 = require("zod");
 
@@ -5400,9 +5924,9 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
       throw geohashError;
     }
   }
-  const now = import_firestore18.Timestamp.now();
+  const now = import_firestore20.Timestamp.now();
   console.log("[CLINIC_GROUP] Preparing clinic group data object");
-  const groupId = (0, import_firestore18.doc)((0, import_firestore18.collection)(db, CLINIC_GROUPS_COLLECTION)).id;
+  const groupId = (0, import_firestore20.doc)((0, import_firestore20.collection)(db, CLINIC_GROUPS_COLLECTION)).id;
   console.log("[CLINIC_GROUP] Logo value:", {
     logoValue: validatedData.logo,
     logoType: validatedData.logo === null ? "null" : typeof validatedData.logo
@@ -5452,7 +5976,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
       groupId: groupData.id
     });
     try {
-      await (0, import_firestore18.setDoc)((0, import_firestore18.doc)(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
+      await (0, import_firestore20.setDoc)((0, import_firestore20.doc)(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
       console.log("[CLINIC_GROUP] Clinic group saved successfully");
     } catch (firestoreError) {
       console.error(
@@ -5498,19 +6022,19 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
   }
 }
 async function getClinicGroup(db, groupId) {
-  const docRef = (0, import_firestore18.doc)(db, CLINIC_GROUPS_COLLECTION, groupId);
-  const docSnap = await (0, import_firestore18.getDoc)(docRef);
+  const docRef = (0, import_firestore20.doc)(db, CLINIC_GROUPS_COLLECTION, groupId);
+  const docSnap = await (0, import_firestore20.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getAllActiveGroups(db) {
-  const q = (0, import_firestore18.query)(
-    (0, import_firestore18.collection)(db, CLINIC_GROUPS_COLLECTION),
-    (0, import_firestore18.where)("isActive", "==", true)
+  const q = (0, import_firestore20.query)(
+    (0, import_firestore20.collection)(db, CLINIC_GROUPS_COLLECTION),
+    (0, import_firestore20.where)("isActive", "==", true)
   );
-  const querySnapshot = await (0, import_firestore18.getDocs)(q);
+  const querySnapshot = await (0, import_firestore20.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
@@ -5539,10 +6063,10 @@ async function updateClinicGroup(db, groupId, data, app) {
   }
   updatedData = {
     ...updatedData,
-    updatedAt: import_firestore18.Timestamp.now()
+    updatedAt: import_firestore20.Timestamp.now()
   };
   console.log("[CLINIC_GROUP] Updating clinic group in Firestore");
-  await (0, import_firestore18.updateDoc)((0, import_firestore18.doc)(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
+  await (0, import_firestore20.updateDoc)((0, import_firestore20.doc)(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
   console.log("[CLINIC_GROUP] Clinic group updated successfully");
   const updatedGroup = await getClinicGroup(db, groupId);
   if (!updatedGroup) {
@@ -5623,10 +6147,10 @@ async function createAdminToken(db, groupId, creatorAdminId, app, data) {
   if (!group.admins.includes(creatorAdminId)) {
     throw new Error("Admin does not belong to this clinic group");
   }
-  const now = import_firestore18.Timestamp.now();
+  const now = import_firestore20.Timestamp.now();
   const expiresInDays = (data == null ? void 0 : data.expiresInDays) || 7;
   const email = (data == null ? void 0 : data.email) || null;
-  const expiresAt = new import_firestore18.Timestamp(
+  const expiresAt = new import_firestore20.Timestamp(
     now.seconds + expiresInDays * 24 * 60 * 60,
     now.nanoseconds
   );
@@ -5660,7 +6184,7 @@ async function verifyAndUseAdminToken(db, groupId, token, userRef, app) {
   if (adminToken.status !== "active" /* ACTIVE */) {
     throw new Error("Admin token is not active");
   }
-  const now = import_firestore18.Timestamp.now();
+  const now = import_firestore20.Timestamp.now();
   if (adminToken.expiresAt.seconds < now.seconds) {
     const updatedTokens2 = group.adminTokens.map(
       (t) => t.id === adminToken.id ? { ...t, status: "expired" /* EXPIRED */ } : t
@@ -5933,24 +6457,24 @@ var import_geofire_common7 = require("geofire-common");
 var import_zod19 = require("zod");
 
 // src/services/clinic/utils/clinic.utils.ts
-var import_firestore19 = require("firebase/firestore");
+var import_firestore21 = require("firebase/firestore");
 var import_geofire_common4 = require("geofire-common");
 var import_zod18 = require("zod");
 async function getClinic(db, clinicId) {
-  const docRef = (0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId);
-  const docSnap = await (0, import_firestore19.getDoc)(docRef);
+  const docRef = (0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId);
+  const docSnap = await (0, import_firestore21.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicsByGroup(db, groupId) {
-  const q = (0, import_firestore19.query)(
-    (0, import_firestore19.collection)(db, CLINICS_COLLECTION),
-    (0, import_firestore19.where)("clinicGroupId", "==", groupId),
-    (0, import_firestore19.where)("isActive", "==", true)
+  const q = (0, import_firestore21.query)(
+    (0, import_firestore21.collection)(db, CLINICS_COLLECTION),
+    (0, import_firestore21.where)("clinicGroupId", "==", groupId),
+    (0, import_firestore21.where)("isActive", "==", true)
   );
-  const querySnapshot = await (0, import_firestore19.getDocs)(q);
+  const querySnapshot = await (0, import_firestore21.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
@@ -6106,11 +6630,11 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
   }
   updatedData = {
     ...updatedData,
-    updatedAt: import_firestore19.Timestamp.now()
+    updatedAt: import_firestore21.Timestamp.now()
   };
   console.log("[CLINIC] Updating clinic in Firestore");
   try {
-    await (0, import_firestore19.updateDoc)((0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId), updatedData);
+    await (0, import_firestore21.updateDoc)((0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId), updatedData);
     console.log("[CLINIC] Clinic updated successfully");
   } catch (updateError) {
     console.error("[CLINIC] Error updating clinic in Firestore:", updateError);
@@ -6139,12 +6663,12 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   if (clinicIds.length === 0) {
     return [];
   }
-  const constraints = [(0, import_firestore19.where)("id", "in", clinicIds)];
+  const constraints = [(0, import_firestore21.where)("id", "in", clinicIds)];
   if (options.isActive !== void 0) {
-    constraints.push((0, import_firestore19.where)("isActive", "==", options.isActive));
+    constraints.push((0, import_firestore21.where)("isActive", "==", options.isActive));
   }
-  const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
-  const querySnapshot = await (0, import_firestore19.getDocs)(q);
+  const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...constraints);
+  const querySnapshot = await (0, import_firestore21.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
@@ -6158,8 +6682,8 @@ async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGr
 }
 async function getClinicById(db, clinicId) {
   try {
-    const clinicRef = (0, import_firestore19.doc)(db, CLINICS_COLLECTION, clinicId);
-    const clinicSnapshot = await (0, import_firestore19.getDoc)(clinicRef);
+    const clinicRef = (0, import_firestore21.doc)(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await (0, import_firestore21.getDoc)(clinicRef);
     if (!clinicSnapshot.exists()) {
       return null;
     }
@@ -6175,20 +6699,20 @@ async function getClinicById(db, clinicId) {
 }
 async function getAllClinics(db, pagination, lastDoc) {
   try {
-    const clinicsCollection = (0, import_firestore19.collection)(db, CLINICS_COLLECTION);
-    let clinicsQuery = (0, import_firestore19.query)(clinicsCollection);
+    const clinicsCollection = (0, import_firestore21.collection)(db, CLINICS_COLLECTION);
+    let clinicsQuery = (0, import_firestore21.query)(clinicsCollection);
     if (pagination && pagination > 0) {
       if (lastDoc) {
-        clinicsQuery = (0, import_firestore19.query)(
+        clinicsQuery = (0, import_firestore21.query)(
           clinicsCollection,
-          (0, import_firestore19.startAfter)(lastDoc),
-          (0, import_firestore19.limit)(pagination)
+          (0, import_firestore21.startAfter)(lastDoc),
+          (0, import_firestore21.limit)(pagination)
         );
       } else {
-        clinicsQuery = (0, import_firestore19.query)(clinicsCollection, (0, import_firestore19.limit)(pagination));
+        clinicsQuery = (0, import_firestore21.query)(clinicsCollection, (0, import_firestore21.limit)(pagination));
       }
     }
-    const clinicsSnapshot = await (0, import_firestore19.getDocs)(clinicsQuery);
+    const clinicsSnapshot = await (0, import_firestore21.getDocs)(clinicsQuery);
     const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
     const clinics = clinicsSnapshot.docs.map((doc34) => {
       const data = doc34.data();
@@ -6215,12 +6739,12 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
   let lastDocSnapshot = null;
   for (const b of bounds) {
     const constraints = [
-      (0, import_firestore19.where)("location.geohash", ">=", b[0]),
-      (0, import_firestore19.where)("location.geohash", "<=", b[1]),
-      (0, import_firestore19.where)("isActive", "==", true)
+      (0, import_firestore21.where)("location.geohash", ">=", b[0]),
+      (0, import_firestore21.where)("location.geohash", "<=", b[1]),
+      (0, import_firestore21.where)("isActive", "==", true)
     ];
-    const q = (0, import_firestore19.query)((0, import_firestore19.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore19.getDocs)(q);
+    const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore21.getDocs)(q);
     for (const doc34 of querySnapshot.docs) {
       const clinic = doc34.data();
       const distance = (0, import_geofire_common4.distanceBetween)(
@@ -6315,7 +6839,7 @@ async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminServic
 }
 
 // src/services/clinic/utils/search.utils.ts
-var import_firestore20 = require("firebase/firestore");
+var import_firestore22 = require("firebase/firestore");
 var import_geofire_common5 = require("geofire-common");
 async function findClinicsInRadius(db, center, radiusInKm, filters) {
   const bounds = (0, import_geofire_common5.geohashQueryBounds)(
@@ -6325,20 +6849,20 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
   const matchingDocs = [];
   for (const b of bounds) {
     const constraints = [
-      (0, import_firestore20.where)("location.geohash", ">=", b[0]),
-      (0, import_firestore20.where)("location.geohash", "<=", b[1]),
-      (0, import_firestore20.where)("isActive", "==", true)
+      (0, import_firestore22.where)("location.geohash", ">=", b[0]),
+      (0, import_firestore22.where)("location.geohash", "<=", b[1]),
+      (0, import_firestore22.where)("isActive", "==", true)
     ];
     if (filters == null ? void 0 : filters.services) {
       constraints.push(
-        (0, import_firestore20.where)("services", "array-contains-any", filters.services)
+        (0, import_firestore22.where)("services", "array-contains-any", filters.services)
       );
     }
     if ((filters == null ? void 0 : filters.tags) && filters.tags.length > 0) {
-      constraints.push((0, import_firestore20.where)("tags", "array-contains-any", filters.tags));
+      constraints.push((0, import_firestore22.where)("tags", "array-contains-any", filters.tags));
     }
-    const q = (0, import_firestore20.query)((0, import_firestore20.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore20.getDocs)(q);
+    const q = (0, import_firestore22.query)((0, import_firestore22.collection)(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore22.getDocs)(q);
     for (const doc34 of querySnapshot.docs) {
       const clinic = doc34.data();
       const distance = (0, import_geofire_common5.distanceBetween)(
@@ -6365,7 +6889,7 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
 }
 
 // src/services/clinic/utils/filter.utils.ts
-var import_firestore21 = require("firebase/firestore");
+var import_firestore23 = require("firebase/firestore");
 var import_geofire_common6 = require("geofire-common");
 async function getClinicsByFilters(db, filters) {
   console.log(
@@ -6375,460 +6899,162 @@ async function getClinicsByFilters(db, filters) {
   const isGeoQuery = filters.center && filters.radiusInKm && filters.radiusInKm > 0;
   const constraints = [];
   if (filters.isActive !== void 0) {
-    constraints.push((0, import_firestore21.where)("isActive", "==", filters.isActive));
+    constraints.push((0, import_firestore23.where)("isActive", "==", filters.isActive));
   } else {
-    constraints.push((0, import_firestore21.where)("isActive", "==", true));
+    constraints.push((0, import_firestore23.where)("isActive", "==", true));
   }
   if (filters.tags && filters.tags.length > 0) {
-    constraints.push((0, import_firestore21.where)("tags", "array-contains", filters.tags[0]));
+    constraints.push((0, import_firestore23.where)("tags", "array-contains", filters.tags[0]));
   }
   if (filters.procedureTechnology) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.technology", "==", filters.procedureTechnology)
+      (0, import_firestore23.where)("servicesInfo.technology", "==", filters.procedureTechnology)
     );
   } else if (filters.procedureSubcategory) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.subCategory", "==", filters.procedureSubcategory)
+      (0, import_firestore23.where)("servicesInfo.subCategory", "==", filters.procedureSubcategory)
     );
   } else if (filters.procedureCategory) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.category", "==", filters.procedureCategory)
+      (0, import_firestore23.where)("servicesInfo.category", "==", filters.procedureCategory)
     );
   } else if (filters.procedureFamily) {
     constraints.push(
-      (0, import_firestore21.where)("servicesInfo.procedureFamily", "==", filters.procedureFamily)
+      (0, import_firestore23.where)("servicesInfo.procedureFamily", "==", filters.procedureFamily)
     );
   }
   if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
-    constraints.push((0, import_firestore21.startAfter)(filters.lastDoc));
-    constraints.push((0, import_firestore21.limit)(filters.pagination));
+    constraints.push((0, import_firestore23.startAfter)(filters.lastDoc));
+    constraints.push((0, import_firestore23.limit)(filters.pagination));
   } else if (filters.pagination && filters.pagination > 0) {
-    constraints.push((0, import_firestore21.limit)(filters.pagination));
+    constraints.push((0, import_firestore23.limit)(filters.pagination));
   }
-  constraints.push((0, import_firestore21.orderBy)("location.geohash"));
+  constraints.push((0, import_firestore23.orderBy)("location.geohash"));
   let clinicsResult = [];
   let lastVisibleDoc = null;
   if (isGeoQuery) {
     const center = filters.center;
     const radiusInKm = filters.radiusInKm;
     const bounds = (0, import_geofire_common6.geohashQueryBounds)(
-      [center.latitude, center.longitude],
-      radiusInKm * 1e3
-      // Convert to meters
-    );
-    const matchingClinics = [];
-    for (const bound of bounds) {
-      const geoConstraints = [
-        ...constraints,
-        (0, import_firestore21.where)("location.geohash", ">=", bound[0]),
-        (0, import_firestore21.where)("location.geohash", "<=", bound[1])
-      ];
-      const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...geoConstraints);
-      const querySnapshot = await (0, import_firestore21.getDocs)(q);
-      console.log(
-        `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
-      );
-      for (const doc34 of querySnapshot.docs) {
-        const clinic = { ...doc34.data(), id: doc34.id };
-        const distance = (0, import_geofire_common6.distanceBetween)(
-          [center.latitude, center.longitude],
-          [clinic.location.latitude, clinic.location.longitude]
-        );
-        const distanceInKm = distance / 1e3;
-        if (distanceInKm <= radiusInKm) {
-          matchingClinics.push({
-            ...clinic,
-            distance: distanceInKm
-          });
-        }
-      }
-    }
-    let filteredClinics = matchingClinics;
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        return filters.tags.every((tag) => clinic.tags.includes(tag));
-      });
-    }
-    if (filters.minRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
-      );
-    }
-    if (filters.maxRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
-      );
-    }
-    filteredClinics.sort((a, b) => a.distance - b.distance);
-    if (filters.pagination && filters.pagination > 0) {
-      let startIndex = 0;
-      if (filters.lastDoc) {
-        const lastDocIndex = filteredClinics.findIndex(
-          (clinic) => clinic.id === filters.lastDoc.id
-        );
-        if (lastDocIndex !== -1) {
-          startIndex = lastDocIndex + 1;
-        }
-      }
-      const paginatedClinics = filteredClinics.slice(
-        startIndex,
-        startIndex + filters.pagination
-      );
-      lastVisibleDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
-      clinicsResult = paginatedClinics;
-    } else {
-      clinicsResult = filteredClinics;
-    }
-  } else {
-    const q = (0, import_firestore21.query)((0, import_firestore21.collection)(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await (0, import_firestore21.getDocs)(q);
-    console.log(
-      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
-    );
-    const clinics = querySnapshot.docs.map((doc34) => {
-      return { ...doc34.data(), id: doc34.id };
-    });
-    let filteredClinics = clinics;
-    if (filters.center) {
-      const center = filters.center;
-      const clinicsWithDistance = [];
-      filteredClinics.forEach((clinic) => {
-        const distance = (0, import_geofire_common6.distanceBetween)(
-          [center.latitude, center.longitude],
-          [clinic.location.latitude, clinic.location.longitude]
-        );
-        clinicsWithDistance.push({
-          ...clinic,
-          distance: distance / 1e3
-          // Convert to kilometers
-        });
-      });
-      filteredClinics = clinicsWithDistance;
-      filteredClinics.sort(
-        (a, b) => a.distance - b.distance
-      );
-    }
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        return filters.tags.every((tag) => clinic.tags.includes(tag));
-      });
-    }
-    if (filters.minRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
-      );
-    }
-    if (filters.maxRating !== void 0) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
-      );
-    }
-    lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-    clinicsResult = filteredClinics;
-  }
-  return {
-    clinics: clinicsResult,
-    lastDoc: lastVisibleDoc
-  };
-}
-
-// src/services/media/media.service.ts
-var import_firestore22 = require("firebase/firestore");
-var import_storage5 = require("firebase/storage");
-var import_firestore23 = require("firebase/firestore");
-var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
-  MediaAccessLevel2["PUBLIC"] = "public";
-  MediaAccessLevel2["PRIVATE"] = "private";
-  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
-  return MediaAccessLevel2;
-})(MediaAccessLevel || {});
-var MEDIA_METADATA_COLLECTION = "media_metadata";
-var MediaService = class extends BaseService {
-  constructor(db, auth, app) {
-    super(db, auth, app);
-  }
-  /**
-   * Upload a media file, store its metadata, and return the metadata including the URL.
-   * @param file - The file to upload.
-   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
-   * @param accessLevel - Access level (public, private, confidential).
-   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
-   * @param originalFileName - Optional: the original name of the file, if not using file.name.
-   * @returns Promise with the media metadata.
-   */
-  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
-    const mediaId = this.generateId();
-    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
-    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
-    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
-    console.log(`[MediaService] Uploading file to: ${filePath}`);
-    const storageRef = (0, import_storage5.ref)(this.storage, filePath);
-    try {
-      const uploadResult = await (0, import_storage5.uploadBytes)(storageRef, file, {
-        contentType: file.type
-      });
-      console.log("[MediaService] File uploaded successfully", uploadResult);
-      const downloadURL = await (0, import_storage5.getDownloadURL)(uploadResult.ref);
-      console.log("[MediaService] Got download URL:", downloadURL);
-      const metadata = {
-        id: mediaId,
-        name: fileNameToUse,
-        url: downloadURL,
-        contentType: file.type,
-        size: file.size,
-        createdAt: import_firestore22.Timestamp.now(),
-        accessLevel,
-        ownerId,
-        collectionName,
-        path: filePath
-      };
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore23.setDoc)(metadataDocRef, metadata);
-      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
-      return metadata;
-    } catch (error) {
-      console.error("[MediaService] Error during media upload:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get media metadata from Firestore by its ID.
-   * @param mediaId - ID of the media.
-   * @returns Promise with the media metadata or null if not found.
-   */
-  async getMediaMetadata(mediaId) {
-    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
-    const docRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-    const docSnap = await (0, import_firestore23.getDoc)(docRef);
-    if (docSnap.exists()) {
-      console.log("[MediaService] Metadata found:", docSnap.data());
-      return docSnap.data();
-    }
-    console.log("[MediaService] No metadata found for ID:", mediaId);
-    return null;
-  }
-  /**
-   * Get media metadata from Firestore by its public URL.
-   * @param url - The public URL of the media file.
-   * @returns Promise with the media metadata or null if not found.
-   */
-  async getMediaMetadataByUrl(url) {
-    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
-    const q = (0, import_firestore23.query)(
-      (0, import_firestore23.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      (0, import_firestore23.where)("url", "==", url),
-      (0, import_firestore23.limit)(1)
+      [center.latitude, center.longitude],
+      radiusInKm * 1e3
+      // Convert to meters
     );
-    try {
+    const matchingClinics = [];
+    for (const bound of bounds) {
+      const geoConstraints = [
+        ...constraints,
+        (0, import_firestore23.where)("location.geohash", ">=", bound[0]),
+        (0, import_firestore23.where)("location.geohash", "<=", bound[1])
+      ];
+      const q = (0, import_firestore23.query)((0, import_firestore23.collection)(db, CLINICS_COLLECTION), ...geoConstraints);
       const querySnapshot = await (0, import_firestore23.getDocs)(q);
-      if (!querySnapshot.empty) {
-        const metadata = querySnapshot.docs[0].data();
-        console.log("[MediaService] Metadata found by URL:", metadata);
-        return metadata;
+      console.log(
+        `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
+      );
+      for (const doc34 of querySnapshot.docs) {
+        const clinic = { ...doc34.data(), id: doc34.id };
+        const distance = (0, import_geofire_common6.distanceBetween)(
+          [center.latitude, center.longitude],
+          [clinic.location.latitude, clinic.location.longitude]
+        );
+        const distanceInKm = distance / 1e3;
+        if (distanceInKm <= radiusInKm) {
+          matchingClinics.push({
+            ...clinic,
+            distance: distanceInKm
+          });
+        }
       }
-      console.log("[MediaService] No metadata found for URL:", url);
-      return null;
-    } catch (error) {
-      console.error("[MediaService] Error fetching metadata by URL:", error);
-      throw error;
     }
-  }
-  /**
-   * Delete media from storage and remove metadata from Firestore.
-   * @param mediaId - ID of the media to delete.
-   */
-  async deleteMedia(mediaId) {
-    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (!metadata) {
-      console.warn(
-        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
-      );
-      return;
+    let filteredClinics = matchingClinics;
+    if (filters.tags && filters.tags.length > 1) {
+      filteredClinics = filteredClinics.filter((clinic) => {
+        return filters.tags.every((tag) => clinic.tags.includes(tag));
+      });
     }
-    const storageFileRef = (0, import_storage5.ref)(this.storage, metadata.path);
-    try {
-      await (0, import_storage5.deleteObject)(storageFileRef);
-      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore23.deleteDoc)(metadataDocRef);
-      console.log(
-        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+    if (filters.minRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
       );
-    } catch (error) {
-      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
-      throw error;
     }
-  }
-  /**
-   * Update media access level. This involves moving the file in Firebase Storage
-   * to a new path reflecting the new access level, and updating its metadata.
-   * @param mediaId - ID of the media to update.
-   * @param newAccessLevel - New access level.
-   * @returns Promise with the updated media metadata, or null if metadata not found.
-   */
-  async updateMediaAccessLevel(mediaId, newAccessLevel) {
-    var _a;
-    console.log(
-      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
-    );
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (!metadata) {
-      console.warn(
-        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+    if (filters.maxRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
       );
-      return null;
     }
-    if (metadata.accessLevel === newAccessLevel) {
-      console.log(
-        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
-      );
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      try {
-        await (0, import_firestore23.updateDoc)(metadataDocRef, { updatedAt: import_firestore22.Timestamp.now() });
-        return { ...metadata, updatedAt: import_firestore22.Timestamp.now() };
-      } catch (error) {
-        console.error(
-          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
-          error
+    filteredClinics.sort((a, b) => a.distance - b.distance);
+    if (filters.pagination && filters.pagination > 0) {
+      let startIndex = 0;
+      if (filters.lastDoc) {
+        const lastDocIndex = filteredClinics.findIndex(
+          (clinic) => clinic.id === filters.lastDoc.id
         );
-        throw error;
+        if (lastDocIndex !== -1) {
+          startIndex = lastDocIndex + 1;
+        }
       }
+      const paginatedClinics = filteredClinics.slice(
+        startIndex,
+        startIndex + filters.pagination
+      );
+      lastVisibleDoc = paginatedClinics.length > 0 ? paginatedClinics[paginatedClinics.length - 1] : null;
+      clinicsResult = paginatedClinics;
+    } else {
+      clinicsResult = filteredClinics;
     }
-    const oldStoragePath = metadata.path;
-    const fileNamePart = `${metadata.id}-${metadata.name}`;
-    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+  } else {
+    const q = (0, import_firestore23.query)((0, import_firestore23.collection)(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await (0, import_firestore23.getDocs)(q);
     console.log(
-      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    const oldStorageFileRef = (0, import_storage5.ref)(this.storage, oldStoragePath);
-    const newStorageFileRef = (0, import_storage5.ref)(this.storage, newStoragePath);
-    try {
-      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
-      const fileBytes = await (0, import_storage5.getBytes)(oldStorageFileRef);
-      console.log(
-        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
-      );
-      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
-      await (0, import_storage5.uploadBytes)(newStorageFileRef, fileBytes, {
-        contentType: metadata.contentType
-      });
-      console.log(
-        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
-      );
-      const newDownloadURL = await (0, import_storage5.getDownloadURL)(newStorageFileRef);
-      console.log(
-        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
-      );
-      const updateData = {
-        accessLevel: newAccessLevel,
-        path: newStoragePath,
-        url: newDownloadURL,
-        updatedAt: import_firestore22.Timestamp.now()
-      };
-      const metadataDocRef = (0, import_firestore23.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      console.log(
-        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
-        updateData
-      );
-      await (0, import_firestore23.updateDoc)(metadataDocRef, updateData);
-      console.log(
-        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
-      );
-      try {
-        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
-        await (0, import_storage5.deleteObject)(oldStorageFileRef);
-        console.log(
-          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
-        );
-      } catch (deleteError) {
-        console.error(
-          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
-          deleteError
+    const clinics = querySnapshot.docs.map((doc34) => {
+      return { ...doc34.data(), id: doc34.id };
+    });
+    let filteredClinics = clinics;
+    if (filters.center) {
+      const center = filters.center;
+      const clinicsWithDistance = [];
+      filteredClinics.forEach((clinic) => {
+        const distance = (0, import_geofire_common6.distanceBetween)(
+          [center.latitude, center.longitude],
+          [clinic.location.latitude, clinic.location.longitude]
         );
-      }
-      return { ...metadata, ...updateData };
-    } catch (error) {
-      console.error(
-        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
-        error
+        clinicsWithDistance.push({
+          ...clinic,
+          distance: distance / 1e3
+          // Convert to kilometers
+        });
+      });
+      filteredClinics = clinicsWithDistance;
+      filteredClinics.sort(
+        (a, b) => a.distance - b.distance
       );
-      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
-        console.warn(
-          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
-        );
-        try {
-          await (0, import_storage5.deleteObject)(newStorageFileRef);
-          console.warn(
-            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
-          );
-        } catch (cleanupError) {
-          console.error(
-            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
-            cleanupError
-          );
-        }
-      }
-      throw error;
-    }
-  }
-  /**
-   * List all media for an owner, optionally filtered by collection and access level.
-   * @param ownerId - ID of the owner.
-   * @param collectionName - Optional: Filter by collection name.
-   * @param accessLevel - Optional: Filter by access level.
-   * @param count - Optional: Number of items to fetch.
-   * @param startAfterId - Optional: ID of the document to start after (for pagination).
-   */
-  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
-    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
-    let qConstraints = [(0, import_firestore23.where)("ownerId", "==", ownerId)];
-    if (collectionName) {
-      qConstraints.push((0, import_firestore23.where)("collectionName", "==", collectionName));
-    }
-    if (accessLevel) {
-      qConstraints.push((0, import_firestore23.where)("accessLevel", "==", accessLevel));
     }
-    qConstraints.push((0, import_firestore23.orderBy)("createdAt", "desc"));
-    if (count) {
-      qConstraints.push((0, import_firestore23.limit)(count));
-    }
-    if (startAfterId) {
-      const startAfterDoc = await this.getMediaMetadata(startAfterId);
-      if (startAfterDoc) {
-      }
+    if (filters.tags && filters.tags.length > 1) {
+      filteredClinics = filteredClinics.filter((clinic) => {
+        return filters.tags.every((tag) => clinic.tags.includes(tag));
+      });
     }
-    const finalQuery = (0, import_firestore23.query)(
-      (0, import_firestore23.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      ...qConstraints
-    );
-    try {
-      const querySnapshot = await (0, import_firestore23.getDocs)(finalQuery);
-      const mediaList = querySnapshot.docs.map(
-        (doc34) => doc34.data()
+    if (filters.minRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating
       );
-      console.log(`[MediaService] Found ${mediaList.length} media items.`);
-      return mediaList;
-    } catch (error) {
-      console.error("[MediaService] Error listing media:", error);
-      throw error;
     }
-  }
-  /**
-   * Get download URL for media. (Convenience, as URL is in metadata)
-   * @param mediaId - ID of the media.
-   */
-  async getMediaDownloadUrl(mediaId) {
-    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (metadata && metadata.url) {
-      console.log(`[MediaService] URL found: ${metadata.url}`);
-      return metadata.url;
+    if (filters.maxRating !== void 0) {
+      filteredClinics = filteredClinics.filter(
+        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating
+      );
     }
-    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
-    return null;
+    lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+    clinicsResult = filteredClinics;
   }
-};
+  return {
+    clinics: clinicsResult,
+    lastDoc: lastVisibleDoc
+  };
+}
 
 // src/services/clinic/clinic.service.ts
 var ClinicService = class extends BaseService {
@@ -8533,7 +8759,8 @@ var ProcedureService = class extends BaseService {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
       description: practitioner.basicInfo.bio || "",
-      photo: practitioner.basicInfo.profileImageUrl || "",
+      photo: typeof practitioner.basicInfo.profileImageUrl === "string" ? practitioner.basicInfo.profileImageUrl : "",
+      // Default to empty string if not a processed URL
       rating: ((_a = practitioner.reviewInfo) == null ? void 0 : _a.averageRating) || 0,
       services: practitioner.procedures || []
     };
@@ -8667,7 +8894,8 @@ var ProcedureService = class extends BaseService {
         id: newPractitioner.id,
         name: `${newPractitioner.basicInfo.firstName} ${newPractitioner.basicInfo.lastName}`,
         description: newPractitioner.basicInfo.bio || "",
-        photo: newPractitioner.basicInfo.profileImageUrl || "",
+        photo: typeof newPractitioner.basicInfo.profileImageUrl === "string" ? newPractitioner.basicInfo.profileImageUrl : "",
+        // Default to empty string if not a processed URL
         rating: ((_a = newPractitioner.reviewInfo) == null ? void 0 : _a.averageRating) || 0,
         services: newPractitioner.procedures || []
       };