@blackcode_sa/metaestetics-api 1.7.19 → 1.7.21

package/dist/index.mjs

@@ -877,16 +877,16 @@ var BaseService = class {
 
 // src/services/user.service.ts
 import {
-  collection as collection7,
-  doc as doc9,
-  getDoc as getDoc12,
-  getDocs as getDocs7,
-  query as query7,
-  where as where7,
-  updateDoc as updateDoc9,
-  deleteDoc as deleteDoc3,
-  Timestamp as Timestamp10,
-  setDoc as setDoc8,
+  collection as collection8,
+  doc as doc10,
+  getDoc as getDoc13,
+  getDocs as getDocs8,
+  query as query8,
+  where as where8,
+  updateDoc as updateDoc10,
+  deleteDoc as deleteDoc4,
+  Timestamp as Timestamp11,
+  setDoc as setDoc9,
   serverTimestamp as serverTimestamp10
 } from "firebase/firestore";
 
@@ -987,432 +987,788 @@ import { z as z16 } from "zod";
 
 // src/services/patient/patient.service.ts
 import {
-  doc as doc6,
-  getDoc as getDoc9,
-  writeBatch
-} from "firebase/firestore";
-
-// src/services/patient/utils/profile.utils.ts
-import {
-  getDoc as getDoc5,
-  setDoc as setDoc4,
-  updateDoc as updateDoc3,
-  arrayUnion as arrayUnion2,
-  arrayRemove as arrayRemove2,
-  serverTimestamp as serverTimestamp4,
-  increment,
-  Timestamp as Timestamp4,
-  collection as collection3,
-  query as query3,
-  where as where3,
-  getDocs as getDocs3,
-  limit as limit2,
-  startAfter as startAfter2,
-  doc as doc4
+  doc as doc7,
+  getDoc as getDoc10,
+  writeBatch,
+  updateDoc as updateDoc7,
+  serverTimestamp as serverTimestamp7
 } from "firebase/firestore";
-import { ref, uploadBytes, getDownloadURL, deleteObject } from "firebase/storage";
-import { z as z8 } from "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
-import { z as z6 } from "zod";
-import { Timestamp as Timestamp2 } from "firebase/firestore";
-
-// src/validations/patient/medical-info.schema.ts
-import { z as z5 } from "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
-import { z as z4 } from "zod";
+// src/services/media/media.service.ts
 import { Timestamp } from "firebase/firestore";
-var timestampSchema2 = z4.union([
-  z4.object({
-    seconds: z4.number(),
-    nanoseconds: z4.number()
-  }),
-  z4.instanceof(Timestamp)
-]).transform((data) => {
-  if (data instanceof Timestamp) {
-    return data;
-  }
-  return new Timestamp(data.seconds, data.nanoseconds);
-});
-
-// src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = z5.union([
-  z5.nativeEnum(MedicationAllergySubtype),
-  z5.nativeEnum(FoodAllergySubtype),
-  z5.nativeEnum(EnvironmentalAllergySubtype),
-  z5.nativeEnum(CosmeticAllergySubtype),
-  z5.literal("other")
-]);
-var allergySchema = z5.object({
-  type: z5.nativeEnum(AllergyType),
-  subtype: allergySubtypeSchema,
-  name: z5.string().optional().nullable(),
-  severity: z5.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: z5.string().optional().nullable(),
-  diagnosed: timestampSchema2.optional().nullable(),
-  notes: z5.string().optional().nullable()
-});
-var vitalStatsSchema = z5.object({
-  height: z5.number().positive().optional(),
-  weight: z5.number().positive().optional(),
-  bloodType: z5.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: z5.object({
-    systolic: z5.number().min(70).max(200),
-    diastolic: z5.number().min(40).max(130),
-    lastMeasured: timestampSchema2
-  }).optional()
-});
-var blockingConditionSchema = z5.object({
-  condition: z5.nativeEnum(BlockingCondition),
-  diagnosedAt: timestampSchema2,
-  notes: z5.string().optional().nullable(),
-  isActive: z5.boolean()
-});
-var contraindicationSchema = z5.object({
-  condition: z5.nativeEnum(Contraindication),
-  lastOccurrence: timestampSchema2,
-  frequency: z5.enum(["rare", "occasional", "frequent"]),
-  notes: z5.string().optional().nullable(),
-  isActive: z5.boolean()
-});
-var medicationSchema = z5.object({
-  name: z5.string().min(1),
-  dosage: z5.string().min(1),
-  frequency: z5.string().min(1),
-  startDate: timestampSchema2.optional().nullable(),
-  endDate: timestampSchema2.optional().nullable(),
-  prescribedBy: z5.string().optional().nullable()
-});
-var patientMedicalInfoSchema = z5.object({
-  patientId: z5.string(),
-  vitalStats: vitalStatsSchema,
-  blockingConditions: z5.array(blockingConditionSchema),
-  contraindications: z5.array(contraindicationSchema),
-  allergies: z5.array(allergySchema),
-  currentMedications: z5.array(medicationSchema),
-  emergencyNotes: z5.string().optional(),
-  lastUpdated: timestampSchema2,
-  updatedBy: z5.string(),
-  verifiedBy: z5.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: z5.number().min(0)
-});
-var addBlockingConditionSchema = blockingConditionSchema;
-var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: z5.number().min(0)
-});
-var addContraindicationSchema = contraindicationSchema;
-var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: z5.number().min(0)
-});
-var addMedicationSchema = medicationSchema;
-var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: z5.number().min(0)
-});
-
-// src/validations/patient.schema.ts
-var locationDataSchema = z6.object({
-  latitude: z6.number().min(-90).max(90),
-  longitude: z6.number().min(-180).max(180),
-  geohash: z6.string().optional()
-});
-var addressDataSchema = z6.object({
-  address: z6.string(),
-  city: z6.string(),
-  country: z6.string(),
-  postalCode: z6.string()
-});
-var emergencyContactSchema = z6.object({
-  name: z6.string(),
-  relationship: z6.string(),
-  phoneNumber: z6.string(),
-  isNotifiable: z6.boolean()
-});
-var gamificationSchema = z6.object({
-  level: z6.number(),
-  points: z6.number()
-});
-var patientLocationInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
-  locationData: locationDataSchema,
-  createdAt: z6.instanceof(Timestamp2),
-  updatedAt: z6.instanceof(Timestamp2)
-});
-var createPatientLocationInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
-  locationData: locationDataSchema
-});
-var patientSensitiveInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
-  photoUrl: z6.string().optional(),
-  firstName: z6.string().min(2),
-  lastName: z6.string().min(2),
-  dateOfBirth: z6.instanceof(Timestamp2).nullable(),
-  gender: z6.nativeEnum(Gender),
-  email: z6.string().email().optional(),
-  phoneNumber: z6.string().optional(),
-  alternativePhoneNumber: z6.string().optional(),
-  addressData: addressDataSchema.optional(),
-  emergencyContacts: z6.array(emergencyContactSchema).optional(),
-  createdAt: z6.instanceof(Timestamp2),
-  updatedAt: z6.instanceof(Timestamp2)
-});
-var patientDoctorSchema = z6.object({
-  userRef: z6.string(),
-  assignedAt: z6.instanceof(Timestamp2),
-  assignedBy: z6.string().optional(),
-  isActive: z6.boolean(),
-  notes: z6.string().optional()
-});
-var patientClinicSchema = z6.object({
-  clinicId: z6.string(),
-  assignedAt: z6.instanceof(Timestamp2),
-  assignedBy: z6.string().optional(),
-  isActive: z6.boolean(),
-  notes: z6.string().optional()
-});
-var patientProfileSchema = z6.object({
-  id: z6.string(),
-  userRef: z6.string(),
-  displayName: z6.string(),
-  profilePhoto: z6.string().url().nullable(),
-  gamification: gamificationSchema,
-  expoTokens: z6.array(z6.string()),
-  isActive: z6.boolean(),
-  isVerified: z6.boolean(),
-  doctors: z6.array(patientDoctorSchema),
-  clinics: z6.array(patientClinicSchema),
-  doctorIds: z6.array(z6.string()),
-  clinicIds: z6.array(z6.string()),
-  createdAt: z6.instanceof(Timestamp2),
-  updatedAt: z6.instanceof(Timestamp2)
-});
-var createPatientProfileSchema = z6.object({
-  userRef: z6.string(),
-  displayName: z6.string(),
-  profilePhoto: z6.string().url().nullable().optional(),
-  expoTokens: z6.array(z6.string()),
-  gamification: gamificationSchema.optional(),
-  isActive: z6.boolean(),
-  isVerified: z6.boolean(),
-  doctors: z6.array(patientDoctorSchema).optional(),
-  clinics: z6.array(patientClinicSchema).optional(),
-  doctorIds: z6.array(z6.string()).optional(),
-  clinicIds: z6.array(z6.string()).optional()
-});
-var createPatientSensitiveInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
-  photoUrl: z6.string().optional(),
-  firstName: z6.string().min(2),
-  lastName: z6.string().min(2),
-  dateOfBirth: z6.instanceof(Timestamp2).nullable(),
-  gender: z6.nativeEnum(Gender),
-  email: z6.string().email().optional(),
-  phoneNumber: z6.string().optional(),
-  alternativePhoneNumber: z6.string().optional(),
-  addressData: addressDataSchema.optional(),
-  emergencyContacts: z6.array(emergencyContactSchema).optional()
-});
-var searchPatientsSchema = z6.object({
-  clinicId: z6.string().optional(),
-  practitionerId: z6.string().optional()
-}).refine((data) => data.clinicId || data.practitionerId, {
-  message: "At least one of clinicId or practitionerId must be provided",
-  path: []
-  // Optional: specify a path like ['clinicId'] or ['practitionerId']
-});
-var requesterInfoSchema = z6.object({
-  id: z6.string(),
-  role: z6.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: z6.string().optional(),
-  associatedPractitionerId: z6.string().optional()
-}).refine(
-  (data) => {
-    if (data.role === "clinic_admin") {
-      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
+import {
+  ref,
+  uploadBytes,
+  getDownloadURL,
+  deleteObject,
+  getBytes
+} from "firebase/storage";
 import {
   doc,
+  getDoc,
+  setDoc,
+  updateDoc,
   collection,
   query,
   where,
+  limit,
   getDocs,
-  getDoc as getDoc2
+  deleteDoc,
+  orderBy
+} from "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 = ref(this.storage, filePath);
+    try {
+      const uploadResult = await uploadBytes(storageRef, file, {
+        contentType: file.type
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await 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: Timestamp.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await 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 = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await 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 = query(
+      collection(this.db, MEDIA_METADATA_COLLECTION),
+      where("url", "==", url),
+      limit(1)
+    );
+    try {
+      const querySnapshot = await 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 = ref(this.storage, metadata.path);
+    try {
+      await deleteObject(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await 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 = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      try {
+        await updateDoc(metadataDocRef, { updatedAt: Timestamp.now() });
+        return { ...metadata, updatedAt: 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 = ref(this.storage, oldStoragePath);
+    const newStorageFileRef = ref(this.storage, newStoragePath);
+    try {
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await getBytes(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await uploadBytes(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await getDownloadURL(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
+      );
+      const updateData = {
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: Timestamp.now()
+      };
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
+      );
+      await updateDoc(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await 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 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 = [where("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push(where("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push(where("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push(orderBy("createdAt", "desc"));
+    if (count) {
+      qConstraints.push(limit(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = query(
+      collection(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+    try {
+      const querySnapshot = await 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
+import {
+  getDoc as getDoc6,
+  setDoc as setDoc5,
+  updateDoc as updateDoc4,
+  arrayUnion as arrayUnion2,
+  arrayRemove as arrayRemove2,
+  serverTimestamp as serverTimestamp4,
+  increment,
+  Timestamp as Timestamp5,
+  collection as collection4,
+  query as query4,
+  where as where4,
+  getDocs as getDocs4,
+  limit as limit3,
+  startAfter as startAfter2,
+  doc as doc5
+} from "firebase/firestore";
+import { z as z9 } from "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
+import { z as z7 } from "zod";
+import { Timestamp as Timestamp3 } from "firebase/firestore";
+
+// src/validations/media.schema.ts
+import { z as z4 } from "zod";
+var mediaResourceSchema = z4.union([
+  z4.string().url(),
+  z4.instanceof(File),
+  z4.instanceof(Blob)
+]);
+
+// src/validations/patient/medical-info.schema.ts
+import { z as z6 } from "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
+import { z as z5 } from "zod";
+import { Timestamp as Timestamp2 } from "firebase/firestore";
+var timestampSchema2 = z5.union([
+  z5.object({
+    seconds: z5.number(),
+    nanoseconds: z5.number()
+  }),
+  z5.instanceof(Timestamp2)
+]).transform((data) => {
+  if (data instanceof Timestamp2) {
+    return data;
+  }
+  return new Timestamp2(data.seconds, data.nanoseconds);
+});
+
+// src/validations/patient/medical-info.schema.ts
+var allergySubtypeSchema = z6.union([
+  z6.nativeEnum(MedicationAllergySubtype),
+  z6.nativeEnum(FoodAllergySubtype),
+  z6.nativeEnum(EnvironmentalAllergySubtype),
+  z6.nativeEnum(CosmeticAllergySubtype),
+  z6.literal("other")
+]);
+var allergySchema = z6.object({
+  type: z6.nativeEnum(AllergyType),
+  subtype: allergySubtypeSchema,
+  name: z6.string().optional().nullable(),
+  severity: z6.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: z6.string().optional().nullable(),
+  diagnosed: timestampSchema2.optional().nullable(),
+  notes: z6.string().optional().nullable()
+});
+var vitalStatsSchema = z6.object({
+  height: z6.number().positive().optional(),
+  weight: z6.number().positive().optional(),
+  bloodType: z6.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: z6.object({
+    systolic: z6.number().min(70).max(200),
+    diastolic: z6.number().min(40).max(130),
+    lastMeasured: timestampSchema2
+  }).optional()
+});
+var blockingConditionSchema = z6.object({
+  condition: z6.nativeEnum(BlockingCondition),
+  diagnosedAt: timestampSchema2,
+  notes: z6.string().optional().nullable(),
+  isActive: z6.boolean()
+});
+var contraindicationSchema = z6.object({
+  condition: z6.nativeEnum(Contraindication),
+  lastOccurrence: timestampSchema2,
+  frequency: z6.enum(["rare", "occasional", "frequent"]),
+  notes: z6.string().optional().nullable(),
+  isActive: z6.boolean()
+});
+var medicationSchema = z6.object({
+  name: z6.string().min(1),
+  dosage: z6.string().min(1),
+  frequency: z6.string().min(1),
+  startDate: timestampSchema2.optional().nullable(),
+  endDate: timestampSchema2.optional().nullable(),
+  prescribedBy: z6.string().optional().nullable()
+});
+var patientMedicalInfoSchema = z6.object({
+  patientId: z6.string(),
+  vitalStats: vitalStatsSchema,
+  blockingConditions: z6.array(blockingConditionSchema),
+  contraindications: z6.array(contraindicationSchema),
+  allergies: z6.array(allergySchema),
+  currentMedications: z6.array(medicationSchema),
+  emergencyNotes: z6.string().optional(),
+  lastUpdated: timestampSchema2,
+  updatedBy: z6.string(),
+  verifiedBy: z6.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: z6.number().min(0)
+});
+var addBlockingConditionSchema = blockingConditionSchema;
+var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
+  conditionIndex: z6.number().min(0)
+});
+var addContraindicationSchema = contraindicationSchema;
+var updateContraindicationSchema = contraindicationSchema.partial().extend({
+  contraindicationIndex: z6.number().min(0)
+});
+var addMedicationSchema = medicationSchema;
+var updateMedicationSchema = medicationSchema.partial().extend({
+  medicationIndex: z6.number().min(0)
+});
+
+// src/validations/patient.schema.ts
+var locationDataSchema = z7.object({
+  latitude: z7.number().min(-90).max(90),
+  longitude: z7.number().min(-180).max(180),
+  geohash: z7.string().optional()
+});
+var addressDataSchema = z7.object({
+  address: z7.string(),
+  city: z7.string(),
+  country: z7.string(),
+  postalCode: z7.string()
+});
+var emergencyContactSchema = z7.object({
+  name: z7.string(),
+  relationship: z7.string(),
+  phoneNumber: z7.string(),
+  isNotifiable: z7.boolean()
+});
+var gamificationSchema = z7.object({
+  level: z7.number(),
+  points: z7.number()
+});
+var patientLocationInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
+  locationData: locationDataSchema,
+  createdAt: z7.instanceof(Timestamp3),
+  updatedAt: z7.instanceof(Timestamp3)
+});
+var createPatientLocationInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
+  locationData: locationDataSchema
+});
+var patientSensitiveInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
+  firstName: z7.string().min(2),
+  lastName: z7.string().min(2),
+  dateOfBirth: z7.instanceof(Timestamp3).nullable(),
+  gender: z7.nativeEnum(Gender),
+  email: z7.string().email().optional(),
+  phoneNumber: z7.string().optional(),
+  alternativePhoneNumber: z7.string().optional(),
+  addressData: addressDataSchema.optional(),
+  emergencyContacts: z7.array(emergencyContactSchema).optional(),
+  createdAt: z7.instanceof(Timestamp3),
+  updatedAt: z7.instanceof(Timestamp3)
+});
+var patientDoctorSchema = z7.object({
+  userRef: z7.string(),
+  assignedAt: z7.instanceof(Timestamp3),
+  assignedBy: z7.string().optional(),
+  isActive: z7.boolean(),
+  notes: z7.string().optional()
+});
+var patientClinicSchema = z7.object({
+  clinicId: z7.string(),
+  assignedAt: z7.instanceof(Timestamp3),
+  assignedBy: z7.string().optional(),
+  isActive: z7.boolean(),
+  notes: z7.string().optional()
+});
+var patientProfileSchema = z7.object({
+  id: z7.string(),
+  userRef: z7.string(),
+  displayName: z7.string(),
+  gamification: gamificationSchema,
+  expoTokens: z7.array(z7.string()),
+  isActive: z7.boolean(),
+  isVerified: z7.boolean(),
+  phoneNumber: z7.string().nullable().optional(),
+  dateOfBirth: z7.instanceof(Timestamp3).nullable().optional(),
+  doctors: z7.array(patientDoctorSchema),
+  clinics: z7.array(patientClinicSchema),
+  doctorIds: z7.array(z7.string()),
+  clinicIds: z7.array(z7.string()),
+  createdAt: z7.instanceof(Timestamp3),
+  updatedAt: z7.instanceof(Timestamp3)
+});
+var createPatientProfileSchema = z7.object({
+  userRef: z7.string(),
+  displayName: z7.string(),
+  expoTokens: z7.array(z7.string()),
+  gamification: gamificationSchema.optional(),
+  isActive: z7.boolean(),
+  isVerified: z7.boolean(),
+  doctors: z7.array(patientDoctorSchema).optional(),
+  clinics: z7.array(patientClinicSchema).optional(),
+  doctorIds: z7.array(z7.string()).optional(),
+  clinicIds: z7.array(z7.string()).optional()
+});
+var createPatientSensitiveInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
+  photoUrl: mediaResourceSchema.nullable().optional(),
+  firstName: z7.string().min(2),
+  lastName: z7.string().min(2),
+  dateOfBirth: z7.instanceof(Timestamp3).nullable(),
+  gender: z7.nativeEnum(Gender),
+  email: z7.string().email().optional(),
+  phoneNumber: z7.string().optional(),
+  alternativePhoneNumber: z7.string().optional(),
+  addressData: addressDataSchema.optional(),
+  emergencyContacts: z7.array(emergencyContactSchema).optional()
+});
+var searchPatientsSchema = z7.object({
+  clinicId: z7.string().optional(),
+  practitionerId: z7.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 = z7.object({
+  id: z7.string(),
+  role: z7.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: z7.string().optional(),
+  associatedPractitionerId: z7.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
+import {
+  doc as doc2,
+  collection as collection2,
+  query as query2,
+  where as where2,
+  getDocs as getDocs2,
+  getDoc as getDoc3
 } from "firebase/firestore";
 
 // src/services/patient/utils/sensitive.utils.ts
 import {
-  getDoc,
-  updateDoc,
-  setDoc,
+  getDoc as getDoc2,
+  updateDoc as updateDoc2,
+  setDoc as setDoc2,
   serverTimestamp
 } from "firebase/firestore";
-import { z as z7 } from "zod";
-var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
+import { z as z8 } from "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 getDoc(
+    const sensitiveDoc = await getDoc2(
       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: serverTimestamp(),
       updatedAt: serverTimestamp()
     };
-    await setDoc(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
-    const createdDoc = await getDoc(getSensitiveInfoDocRef(db, data.patientId));
+    await setDoc2(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
+    const createdDoc = await getDoc2(getSensitiveInfoDocRef(db, data.patientId));
     if (!createdDoc.exists()) {
       throw new Error("Failed to create sensitive information");
     }
     return createdDoc.data();
   } catch (error) {
-    if (error instanceof z7.ZodError) {
+    if (error instanceof z8.ZodError) {
       throw new Error("Invalid sensitive info data: " + error.message);
     }
     throw error;
@@ -1420,17 +1776,32 @@ var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
 };
 var getSensitiveInfoUtil = async (db, patientId, requesterUserId) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
-  const sensitiveDoc = await getDoc(getSensitiveInfoDocRef(db, patientId));
+  const sensitiveDoc = await getDoc2(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,
+    photoUrl: processedPhotoUrl,
     updatedAt: serverTimestamp()
   };
-  await updateDoc(getSensitiveInfoDocRef(db, patientId), updateData);
-  const updatedDoc = await getDoc(getSensitiveInfoDocRef(db, patientId));
+  await updateDoc2(getSensitiveInfoDocRef(db, patientId), updateData);
+  const updatedDoc = await getDoc2(getSensitiveInfoDocRef(db, patientId));
   if (!updatedDoc.exists()) {
     throw new Error("Failed to retrieve updated sensitive information");
   }
@@ -1439,21 +1810,21 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
 
 // src/services/patient/utils/docs.utils.ts
 var getPatientDocRef = (db, patientId) => {
-  return doc(db, PATIENTS_COLLECTION, patientId);
+  return doc2(db, PATIENTS_COLLECTION, patientId);
 };
 var getPatientDocRefByUserRef = async (db, userRef) => {
-  const patientsRef = collection(db, PATIENTS_COLLECTION);
-  const q = query(patientsRef, where("userRef", "==", userRef));
-  const querySnapshot = await getDocs(q);
+  const patientsRef = collection2(db, PATIENTS_COLLECTION);
+  const q = query2(patientsRef, where2("userRef", "==", userRef));
+  const querySnapshot = await getDocs2(q);
   if (querySnapshot.empty) {
     throw new Error("Patient profile not found");
   }
-  return doc(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
+  return doc2(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 doc(
+  return doc2(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1464,7 +1835,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 doc(
+  return doc2(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1475,7 +1846,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 doc(
+  return doc2(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1492,7 +1863,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
     console.log(
       `[initSensitiveInfoDocIfNotExists] Got document reference: ${sensitiveInfoRef.path}`
     );
-    const sensitiveDoc = await getDoc2(sensitiveInfoRef);
+    const sensitiveDoc = await getDoc3(sensitiveInfoRef);
     console.log(
       `[initSensitiveInfoDocIfNotExists] Document exists: ${sensitiveDoc.exists()}`
     );
@@ -1516,7 +1887,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
         )
       );
       await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef);
-      const verifyDoc = await getDoc2(sensitiveInfoRef);
+      const verifyDoc = await getDoc3(sensitiveInfoRef);
       console.log(
         `[initSensitiveInfoDocIfNotExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1534,24 +1905,24 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
 
 // src/services/patient/utils/medical.utils.ts
 import {
-  getDoc as getDoc4,
-  updateDoc as updateDoc2,
-  setDoc as setDoc3,
+  getDoc as getDoc5,
+  updateDoc as updateDoc3,
+  setDoc as setDoc4,
   serverTimestamp as serverTimestamp3,
   arrayUnion,
-  Timestamp as Timestamp3
+  Timestamp as Timestamp4
 } from "firebase/firestore";
 
 // src/services/patient/utils/practitioner.utils.ts
 import {
-  collection as collection2,
-  query as query2,
-  where as where2,
-  getDocs as getDocs2,
-  limit,
+  collection as collection3,
+  query as query3,
+  where as where3,
+  getDocs as getDocs3,
+  limit as limit2,
   startAfter,
-  doc as doc2,
-  getDoc as getDoc3
+  doc as doc3,
+  getDoc as getDoc4
 } from "firebase/firestore";
 
 // src/types/practitioner/index.ts
@@ -1577,23 +1948,23 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
       `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
       options
     );
-    const patientsCollection = collection2(db, PATIENTS_COLLECTION);
+    const patientsCollection = collection3(db, PATIENTS_COLLECTION);
     const constraints = [
-      where2("doctorIds", "array-contains", practitionerId)
+      where3("doctorIds", "array-contains", practitionerId)
     ];
-    let q = query2(patientsCollection, ...constraints);
+    let q = query3(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = query2(q, limit(options.limit));
+      q = query3(q, limit2(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await getDoc3(
-        doc2(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await getDoc4(
+        doc3(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = query2(q, startAfter(startAfterDoc));
+        q = query3(q, startAfter(startAfterDoc));
       }
     }
-    const patientsSnapshot = await getDocs2(q);
+    const patientsSnapshot = await getDocs3(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -1626,7 +1997,7 @@ var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, option
     const patientProfilesWithDetails = await Promise.all(
       patientProfiles.map(async (profile) => {
         try {
-          const sensitiveInfoDoc = await getDoc3(
+          const sensitiveInfoDoc = await getDoc4(
             getSensitiveInfoDocRef(db, profile.id)
           );
           const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
@@ -1662,13 +2033,13 @@ var getPractitionerProfileByUserRef = async (db, userRef) => {
     console.log(
       `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
     );
-    const practitionersCollection = collection2(db, PRACTITIONERS_COLLECTION);
-    const q = query2(
+    const practitionersCollection = collection3(db, PRACTITIONERS_COLLECTION);
+    const q = query3(
       practitionersCollection,
-      where2("userRef", "==", userRef),
-      limit(1)
+      where3("userRef", "==", userRef),
+      limit2(1)
     );
-    const querySnapshot = await getDocs2(q);
+    const querySnapshot = await getDocs3(q);
     if (querySnapshot.empty) {
       console.log(
         `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
@@ -1702,7 +2073,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
     console.log(
       `[ensureMedicalInfoExists] Got document reference: ${medicalInfoRef.path}`
     );
-    const medicalInfoDoc = await getDoc4(medicalInfoRef);
+    const medicalInfoDoc = await getDoc5(medicalInfoRef);
     console.log(
       `[ensureMedicalInfoExists] Document exists: ${medicalInfoDoc.exists()}`
     );
@@ -1720,9 +2091,9 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
           (key, value) => value && typeof value === "object" && value.constructor && value.constructor.name === "Object" ? "[serverTimestamp]" : value
         )
       );
-      await setDoc3(medicalInfoRef, defaultData);
+      await setDoc4(medicalInfoRef, defaultData);
       console.log(`[ensureMedicalInfoExists] Document created successfully`);
-      const verifyDoc = await getDoc4(medicalInfoRef);
+      const verifyDoc = await getDoc5(medicalInfoRef);
       console.log(
         `[ensureMedicalInfoExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1738,7 +2109,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
 };
 var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
   var _a;
-  const patientDoc = await getDoc4(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) {
     throw new Error("Patient profile not found");
   }
@@ -1771,17 +2142,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 setDoc3(getMedicalInfoDocRef(db, patientId), {
+  await setDoc4(getMedicalInfoDocRef(db, patientId), {
     ...validatedData,
     patientId,
-    lastUpdated: Timestamp3.now(),
+    lastUpdated: Timestamp4.now(),
     updatedBy: userRef
   });
 };
 var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const docRef = getMedicalInfoDocRef(db, patientId);
-  const snapshot = await getDoc4(docRef);
+  const snapshot = await getDoc5(docRef);
   if (!snapshot.exists()) {
     throw new Error("Medicinske informacije nisu prona\u0111ene");
   }
@@ -1790,7 +2161,7 @@ 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 updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     vitalStats: validatedData,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1799,7 +2170,7 @@ var updateVitalStatsUtil = async (db, patientId, data, userRef) => {
 var addAllergyUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addAllergySchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     allergies: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1808,7 +2179,7 @@ var addAllergyUtil = async (db, patientId, data, userRef) => {
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const docSnapshot = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const docSnapshot = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!docSnapshot.exists()) throw new Error("Medical info not found");
   const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1819,14 +2190,14 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
     ...updatedAllergies[allergyIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1835,7 +2206,7 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
   const updatedAllergies = medicalInfo.allergies.filter(
     (_, index) => index !== allergyIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1844,7 +2215,7 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
 var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addBlockingConditionSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1853,7 +2224,7 @@ var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -1864,14 +2235,14 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
     ...updatedConditions[conditionIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -1880,7 +2251,7 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef)
   const updatedConditions = medicalInfo.blockingConditions.filter(
     (_, index) => index !== conditionIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1889,7 +2260,7 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef)
 var addContraindicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addContraindicationSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     contraindications: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1898,7 +2269,7 @@ var addContraindicationUtil = async (db, patientId, data, userRef) => {
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -1909,14 +2280,14 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
     ...updatedContraindications[contraindicationIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -1925,7 +2296,7 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, us
   const updatedContraindications = medicalInfo.contraindications.filter(
     (_, index) => index !== contraindicationIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1934,7 +2305,7 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, us
 var addMedicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addMedicationSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     currentMedications: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1943,7 +2314,7 @@ var addMedicationUtil = async (db, patientId, data, userRef) => {
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -1954,14 +2325,14 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
     ...updatedMedications[medicationIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -1970,7 +2341,7 @@ var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
   const updatedMedications = medicalInfo.currentMedications.filter(
     (_, index) => index !== medicationIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1989,7 +2360,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,
@@ -2006,10 +2376,10 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
     };
     patientProfileSchema.parse({
       ...patientData,
-      createdAt: Timestamp4.now(),
-      updatedAt: Timestamp4.now()
+      createdAt: Timestamp5.now(),
+      updatedAt: Timestamp5.now()
     });
-    await setDoc4(getPatientDocRef(db, patientId), patientData);
+    await setDoc5(getPatientDocRef(db, patientId), patientData);
     console.log(`[createPatientProfileUtil] Creating sensitive info document`);
     let sensitiveInfoSuccess = false;
     try {
@@ -2023,69 +2393,91 @@ 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 getDoc5(getPatientDocRef(db, patientId));
+    const patientDoc = await getDoc6(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 z8.ZodError) {
+    console.error(
+      `[createPatientProfileUtil] Error in patient profile creation:`,
+      error
+    );
+    if (error instanceof z9.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
   }
 };
 var getPatientProfileUtil = async (db, patientId) => {
-  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc6(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? patientDoc.data() : null;
 };
 var getPatientProfileByUserRefUtil = async (db, userRef) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await getDoc5(docRef);
+    const patientDoc = await getDoc6(docRef);
     return patientDoc.exists() ? patientDoc.data() : null;
   } catch (error) {
     return null;
   }
 };
 var addExpoTokenUtil = async (db, patientId, token) => {
-  await updateDoc3(getPatientDocRef(db, patientId), {
+  await updateDoc4(getPatientDocRef(db, patientId), {
     expoTokens: arrayUnion2(token),
     updatedAt: serverTimestamp4()
   });
 };
 var removeExpoTokenUtil = async (db, patientId, token) => {
-  await updateDoc3(getPatientDocRef(db, patientId), {
+  await updateDoc4(getPatientDocRef(db, patientId), {
     expoTokens: arrayRemove2(token),
     updatedAt: serverTimestamp4()
   });
 };
 var addPointsUtil = async (db, patientId, points) => {
-  await updateDoc3(getPatientDocRef(db, patientId), {
+  await updateDoc4(getPatientDocRef(db, patientId), {
     "gamification.points": increment(points),
     updatedAt: serverTimestamp4()
   });
@@ -2096,8 +2488,8 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
       ...data,
       updatedAt: serverTimestamp4()
     };
-    await updateDoc3(getPatientDocRef(db, patientId), updateData);
-    const updatedDoc = await getDoc5(getPatientDocRef(db, patientId));
+    await updateDoc4(getPatientDocRef(db, patientId), updateData);
+    const updatedDoc = await getDoc6(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
       throw new Error("Patient profile not found after update");
     }
@@ -2110,7 +2502,7 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
 var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await getDoc5(docRef);
+    const patientDoc = await getDoc6(docRef);
     if (!patientDoc.exists()) {
       throw new Error("Patient profile not found");
     }
@@ -2118,49 +2510,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 = ref(storage, `patient-photos/${patientId}/profile-photo`);
-  await uploadBytes(photoRef, file);
-  return getDownloadURL(photoRef);
-};
-var updateProfilePhotoUtil = async (storage, db, patientId, file) => {
-  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const oldPhotoRef = ref(storage, patientData.profilePhoto);
-      await deleteObject(oldPhotoRef);
-    } catch (error) {
-      console.warn("Failed to delete old profile photo:", error);
-    }
-  }
-  const newPhotoUrl = await uploadProfilePhotoUtil(storage, patientId, file);
-  await updateDoc3(getPatientDocRef(db, patientId), {
-    profilePhoto: newPhotoUrl,
-    updatedAt: serverTimestamp4()
-  });
-  return newPhotoUrl;
-};
-var deleteProfilePhotoUtil = async (storage, db, patientId) => {
-  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const photoRef = ref(storage, patientData.profilePhoto);
-      await 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 updateDoc3(getPatientDocRef(db, patientId), {
-    profilePhoto: null,
-    updatedAt: serverTimestamp4()
-  });
 };
 var testCreateSubDocuments = async (db, patientId, userRef) => {
   console.log(
@@ -2169,33 +2522,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: Timestamp4.now(),
+      dateOfBirth: Timestamp5.now(),
       gender: "prefer_not_to_say" /* PREFER_NOT_TO_SAY */,
       email: "test@example.com",
       phoneNumber: "",
-      createdAt: Timestamp4.now(),
-      updatedAt: Timestamp4.now()
+      createdAt: Timestamp5.now(),
+      updatedAt: Timestamp5.now()
     };
-    await setDoc4(sensitiveInfoRef, defaultSensitiveInfo);
-    console.log(`[testCreateSubDocuments] Sensitive info document created directly`);
+    await setDoc5(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: Timestamp4.now(),
+      lastUpdated: Timestamp5.now(),
       updatedBy: userRef
     };
-    await setDoc4(medicalInfoRef, defaultMedicalInfo);
-    console.log(`[testCreateSubDocuments] Medical info document created directly`);
+    await setDoc5(medicalInfoRef, defaultMedicalInfo);
+    console.log(
+      `[testCreateSubDocuments] Medical info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Test completed successfully`);
   } catch (error) {
     console.error(`[testCreateSubDocuments] Error:`, error);
@@ -2206,10 +2567,12 @@ var searchPatientsUtil = async (db, params, requester) => {
   searchPatientsSchema.parse(params);
   requesterInfoSchema.parse(requester);
   const constraints = [];
-  const patientsCollectionRef = collection3(db, PATIENTS_COLLECTION);
+  const patientsCollectionRef = collection4(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(
@@ -2217,13 +2580,19 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push(where3("clinicIds", "array-contains", requester.associatedClinicId));
+    constraints.push(
+      where4("clinicIds", "array-contains", requester.associatedClinicId)
+    );
     if (params.practitionerId) {
-      constraints.push(where3("doctorIds", "array-contains", params.practitionerId));
+      constraints.push(
+        where4("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(
@@ -2231,18 +2600,24 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push(where3("doctorIds", "array-contains", requester.associatedPractitionerId));
+    constraints.push(
+      where4("doctorIds", "array-contains", requester.associatedPractitionerId)
+    );
     if (params.clinicId) {
-      constraints.push(where3("clinicIds", "array-contains", params.clinicId));
+      constraints.push(where4("clinicIds", "array-contains", params.clinicId));
     }
   } else {
     throw new Error("Invalid requester role.");
   }
   try {
-    const finalQuery = query3(patientsCollectionRef, ...constraints);
-    const querySnapshot = await getDocs3(finalQuery);
-    const patients = querySnapshot.docs.map((doc34) => doc34.data());
-    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
+    const finalQuery = query4(patientsCollectionRef, ...constraints);
+    const querySnapshot = await getDocs4(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);
@@ -2251,19 +2626,24 @@ var searchPatientsUtil = async (db, params, requester) => {
 };
 var getAllPatientsUtil = async (db, options) => {
   try {
-    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
-    const patientsCollection = collection3(db, PATIENTS_COLLECTION);
-    let q = query3(patientsCollection);
+    console.log(
+      `[getAllPatientsUtil] Fetching patients with options:`,
+      options
+    );
+    const patientsCollection = collection4(db, PATIENTS_COLLECTION);
+    let q = query4(patientsCollection);
     if (options == null ? void 0 : options.limit) {
-      q = query3(q, limit2(options.limit));
+      q = query4(q, limit3(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await getDoc5(doc4(db, PATIENTS_COLLECTION, options.startAfter));
+      const startAfterDoc = await getDoc6(
+        doc5(db, PATIENTS_COLLECTION, options.startAfter)
+      );
       if (startAfterDoc.exists()) {
-        q = query3(q, startAfter2(startAfterDoc));
+        q = query4(q, startAfter2(startAfterDoc));
       }
     }
-    const patientsSnapshot = await getDocs3(q);
+    const patientsSnapshot = await getDocs4(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2280,12 +2660,12 @@ var getAllPatientsUtil = async (db, options) => {
 
 // src/services/patient/utils/location.utils.ts
 import {
-  getDoc as getDoc6,
-  updateDoc as updateDoc4,
-  setDoc as setDoc5,
+  getDoc as getDoc7,
+  updateDoc as updateDoc5,
+  setDoc as setDoc6,
   serverTimestamp as serverTimestamp5
 } from "firebase/firestore";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 import { geohashForLocation } from "geofire-common";
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -2297,7 +2677,7 @@ var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
     locationData,
     updatedAt: serverTimestamp5()
   };
-  await updateDoc4(getLocationInfoDocRef(db, patientId), updateData);
+  await updateDoc5(getLocationInfoDocRef(db, patientId), updateData);
 };
 var createLocationInfoUtil = async (db, data, requesterId) => {
   try {
@@ -2317,14 +2697,14 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
       createdAt: serverTimestamp5(),
       updatedAt: serverTimestamp5()
     };
-    await setDoc5(getLocationInfoDocRef(db, data.patientId), locationData);
-    const locationDoc = await getDoc6(getLocationInfoDocRef(db, data.patientId));
+    await setDoc6(getLocationInfoDocRef(db, data.patientId), locationData);
+    const locationDoc = await getDoc7(getLocationInfoDocRef(db, data.patientId));
     if (!locationDoc.exists()) {
       throw new Error("Failed to create location information");
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof z9.ZodError) {
+    if (error instanceof z10.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -2334,7 +2714,7 @@ var getLocationInfoUtil = async (db, patientId, requesterId) => {
   if (patientId !== requesterId) {
     throw new Error("Unauthorized access to location information");
   }
-  const locationDoc = await getDoc6(getLocationInfoDocRef(db, patientId));
+  const locationDoc = await getDoc7(getLocationInfoDocRef(db, patientId));
   return locationDoc.exists() ? locationDoc.data() : null;
 };
 var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
@@ -2352,7 +2732,7 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
     };
   }
   updateData.updatedAt = serverTimestamp5();
-  await updateDoc4(getLocationInfoDocRef(db, patientId), updateData);
+  await updateDoc5(getLocationInfoDocRef(db, patientId), updateData);
   const updatedInfo = await getLocationInfoUtil(db, patientId, requesterId);
   if (!updatedInfo) {
     throw new Error("Failed to retrieve updated location information");
@@ -2362,22 +2742,22 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
 
 // src/services/patient/utils/medical-stuff.utils.ts
 import {
-  getDoc as getDoc7,
-  updateDoc as updateDoc5,
+  getDoc as getDoc8,
+  updateDoc as updateDoc6,
   arrayUnion as arrayUnion3,
   arrayRemove as arrayRemove3,
   serverTimestamp as serverTimestamp6,
-  Timestamp as Timestamp5
+  Timestamp as Timestamp6
 } from "firebase/firestore";
 var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
   var _a;
   const newDoctor = {
     userRef: doctorRef,
-    assignedAt: Timestamp5.now(),
+    assignedAt: Timestamp6.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await getDoc7(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc8(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(
@@ -2392,23 +2772,23 @@ var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
     updatedDoctors[existingDoctorIndex] = {
       ...updatedDoctors[existingDoctorIndex],
       isActive: true,
-      assignedAt: Timestamp5.now(),
+      assignedAt: Timestamp6.now(),
       assignedBy
     };
     updates.doctors = updatedDoctors;
   } else {
     updates.doctors = arrayUnion3(newDoctor);
   }
-  await updateDoc5(getPatientDocRef(db, patientId), updates);
+  await updateDoc6(getPatientDocRef(db, patientId), updates);
 };
 var removeDoctorUtil = async (db, patientId, doctorRef) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await getDoc7(patientDocRef);
+  const patientDoc = await getDoc8(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 updateDoc5(patientDocRef, {
+  await updateDoc6(patientDocRef, {
     doctors: updatedDoctors,
     // Set the filtered array
     doctorIds: arrayRemove3(doctorRef),
@@ -2420,11 +2800,11 @@ var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
   var _a;
   const newClinic = {
     clinicId,
-    assignedAt: Timestamp5.now(),
+    assignedAt: Timestamp6.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await getDoc7(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc8(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(
@@ -2439,23 +2819,23 @@ var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
     updatedClinics[existingClinicIndex] = {
       ...updatedClinics[existingClinicIndex],
       isActive: true,
-      assignedAt: Timestamp5.now(),
+      assignedAt: Timestamp6.now(),
       assignedBy
     };
     updates.clinics = updatedClinics;
   } else {
     updates.clinics = arrayUnion3(newClinic);
   }
-  await updateDoc5(getPatientDocRef(db, patientId), updates);
+  await updateDoc6(getPatientDocRef(db, patientId), updates);
 };
 var removeClinicUtil = async (db, patientId, clinicId) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await getDoc7(patientDocRef);
+  const patientDoc = await getDoc8(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 updateDoc5(patientDocRef, {
+  await updateDoc6(patientDocRef, {
     clinics: updatedClinics,
     // Set the filtered array
     clinicIds: arrayRemove3(clinicId),
@@ -2466,14 +2846,14 @@ var removeClinicUtil = async (db, patientId, clinicId) => {
 
 // src/services/patient/utils/clinic.utils.ts
 import {
-  collection as collection4,
-  query as query4,
-  where as where4,
-  getDocs as getDocs4,
-  limit as limit3,
+  collection as collection5,
+  query as query5,
+  where as where5,
+  getDocs as getDocs5,
+  limit as limit4,
   startAfter as startAfter3,
-  doc as doc5,
-  getDoc as getDoc8
+  doc as doc6,
+  getDoc as getDoc9
 } from "firebase/firestore";
 var getPatientsByClinicUtil = async (db, clinicId, options) => {
   try {
@@ -2481,23 +2861,23 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
       `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
       options
     );
-    const patientsCollection = collection4(db, PATIENTS_COLLECTION);
+    const patientsCollection = collection5(db, PATIENTS_COLLECTION);
     const constraints = [
-      where4("clinicIds", "array-contains", clinicId)
+      where5("clinicIds", "array-contains", clinicId)
     ];
-    let q = query4(patientsCollection, ...constraints);
+    let q = query5(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = query4(q, limit3(options.limit));
+      q = query5(q, limit4(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await getDoc8(
-        doc5(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await getDoc9(
+        doc6(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = query4(q, startAfter3(startAfterDoc));
+        q = query5(q, startAfter3(startAfterDoc));
       }
     }
-    const patientsSnapshot = await getDocs4(q);
+    const patientsSnapshot = await getDocs5(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2521,6 +2901,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) {
@@ -2557,7 +2938,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);
@@ -2568,7 +2954,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) {
@@ -2701,8 +3093,8 @@ var PatientService = class extends BaseService {
     if (!this.auth.currentUser) {
       throw new Error("No authenticated user");
     }
-    const userDoc = await getDoc9(
-      doc6(this.db, "users", this.auth.currentUser.uid)
+    const userDoc = await getDoc10(
+      doc7(this.db, "users", this.auth.currentUser.uid)
     );
     if (!userDoc.exists()) {
       throw new Error("User not found");
@@ -2737,14 +3129,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 updateDoc7(getSensitiveInfoDocRef(this.db, patientId), {
+      photoUrl: mediaMetadata.url,
+      updatedAt: serverTimestamp7()
+    });
+    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 updateDoc7(getSensitiveInfoDocRef(this.db, patientId), {
+        photoUrl: null,
+        updatedAt: serverTimestamp7()
+      });
+    }
+  }
+  /**
+   * 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) {
@@ -2838,16 +3329,16 @@ var PatientService = class extends BaseService {
 
 // src/services/clinic/utils/admin.utils.ts
 import {
-  collection as collection5,
-  doc as doc7,
-  getDoc as getDoc10,
-  getDocs as getDocs5,
-  query as query5,
-  where as where5,
-  updateDoc as updateDoc7,
-  setDoc as setDoc6,
-  deleteDoc,
-  Timestamp as Timestamp7,
+  collection as collection6,
+  doc as doc8,
+  getDoc as getDoc11,
+  getDocs as getDocs6,
+  query as query6,
+  where as where6,
+  updateDoc as updateDoc8,
+  setDoc as setDoc7,
+  deleteDoc as deleteDoc2,
+  Timestamp as Timestamp8,
   serverTimestamp as serverTimestamp8
 } from "firebase/firestore";
 
@@ -2976,131 +3467,131 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 
 // src/validations/clinic.schema.ts
 import { z as z13 } from "zod";
-import { Timestamp as Timestamp6 } from "firebase/firestore";
+import { Timestamp as Timestamp7 } from "firebase/firestore";
 
 // src/validations/reviews.schema.ts
-import { z as z10 } from "zod";
-var baseReviewSchema = z10.object({
-  id: z10.string().min(1),
-  patientId: z10.string().min(1),
-  fullReviewId: z10.string().min(1),
-  createdAt: z10.date(),
-  updatedAt: z10.date(),
-  comment: z10.string().min(1).max(2e3),
-  isVerified: z10.boolean(),
-  isPublished: z10.boolean()
+import { z as z11 } from "zod";
+var baseReviewSchema = z11.object({
+  id: z11.string().min(1),
+  patientId: z11.string().min(1),
+  fullReviewId: z11.string().min(1),
+  createdAt: z11.date(),
+  updatedAt: z11.date(),
+  comment: z11.string().min(1).max(2e3),
+  isVerified: z11.boolean(),
+  isPublished: z11.boolean()
 });
-var baseReviewCreateSchema = z10.object({
-  patientId: z10.string().min(1),
-  comment: z10.string().min(1).max(2e3),
-  isVerified: z10.boolean().default(false),
-  isPublished: z10.boolean().default(true)
+var baseReviewCreateSchema = z11.object({
+  patientId: z11.string().min(1),
+  comment: z11.string().min(1).max(2e3),
+  isVerified: z11.boolean().default(false),
+  isPublished: z11.boolean().default(true)
 });
 var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: z10.string().min(1),
-  cleanliness: z10.number().min(1).max(5),
-  facilities: z10.number().min(1).max(5),
-  staffFriendliness: z10.number().min(1).max(5),
-  waitingTime: z10.number().min(1).max(5),
-  accessibility: z10.number().min(1).max(5),
-  overallRating: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  clinicId: z11.string().min(1),
+  cleanliness: z11.number().min(1).max(5),
+  facilities: z11.number().min(1).max(5),
+  staffFriendliness: z11.number().min(1).max(5),
+  waitingTime: z11.number().min(1).max(5),
+  accessibility: z11.number().min(1).max(5),
+  overallRating: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: z10.string().min(1),
-  cleanliness: z10.number().min(1).max(5),
-  facilities: z10.number().min(1).max(5),
-  staffFriendliness: z10.number().min(1).max(5),
-  waitingTime: z10.number().min(1).max(5),
-  accessibility: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  clinicId: z11.string().min(1),
+  cleanliness: z11.number().min(1).max(5),
+  facilities: z11.number().min(1).max(5),
+  staffFriendliness: z11.number().min(1).max(5),
+  waitingTime: z11.number().min(1).max(5),
+  accessibility: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: z10.string().min(1),
-  knowledgeAndExpertise: z10.number().min(1).max(5),
-  communicationSkills: z10.number().min(1).max(5),
-  bedSideManner: z10.number().min(1).max(5),
-  thoroughness: z10.number().min(1).max(5),
-  trustworthiness: z10.number().min(1).max(5),
-  overallRating: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  practitionerId: z11.string().min(1),
+  knowledgeAndExpertise: z11.number().min(1).max(5),
+  communicationSkills: z11.number().min(1).max(5),
+  bedSideManner: z11.number().min(1).max(5),
+  thoroughness: z11.number().min(1).max(5),
+  trustworthiness: z11.number().min(1).max(5),
+  overallRating: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: z10.string().min(1),
-  knowledgeAndExpertise: z10.number().min(1).max(5),
-  communicationSkills: z10.number().min(1).max(5),
-  bedSideManner: z10.number().min(1).max(5),
-  thoroughness: z10.number().min(1).max(5),
-  trustworthiness: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  practitionerId: z11.string().min(1),
+  knowledgeAndExpertise: z11.number().min(1).max(5),
+  communicationSkills: z11.number().min(1).max(5),
+  bedSideManner: z11.number().min(1).max(5),
+  thoroughness: z11.number().min(1).max(5),
+  trustworthiness: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: z10.string().min(1),
-  effectivenessOfTreatment: z10.number().min(1).max(5),
-  outcomeExplanation: z10.number().min(1).max(5),
-  painManagement: z10.number().min(1).max(5),
-  followUpCare: z10.number().min(1).max(5),
-  valueForMoney: z10.number().min(1).max(5),
-  overallRating: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  procedureId: z11.string().min(1),
+  effectivenessOfTreatment: z11.number().min(1).max(5),
+  outcomeExplanation: z11.number().min(1).max(5),
+  painManagement: z11.number().min(1).max(5),
+  followUpCare: z11.number().min(1).max(5),
+  valueForMoney: z11.number().min(1).max(5),
+  overallRating: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: z10.string().min(1),
-  effectivenessOfTreatment: z10.number().min(1).max(5),
-  outcomeExplanation: z10.number().min(1).max(5),
-  painManagement: z10.number().min(1).max(5),
-  followUpCare: z10.number().min(1).max(5),
-  valueForMoney: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  procedureId: z11.string().min(1),
+  effectivenessOfTreatment: z11.number().min(1).max(5),
+  outcomeExplanation: z11.number().min(1).max(5),
+  painManagement: z11.number().min(1).max(5),
+  followUpCare: z11.number().min(1).max(5),
+  valueForMoney: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
-var clinicReviewInfoSchema = z10.object({
-  totalReviews: z10.number().min(0),
-  averageRating: z10.number().min(0).max(5),
-  cleanliness: z10.number().min(0).max(5),
-  facilities: z10.number().min(0).max(5),
-  staffFriendliness: z10.number().min(0).max(5),
-  waitingTime: z10.number().min(0).max(5),
-  accessibility: z10.number().min(0).max(5),
-  recommendationPercentage: z10.number().min(0).max(100)
+var clinicReviewInfoSchema = z11.object({
+  totalReviews: z11.number().min(0),
+  averageRating: z11.number().min(0).max(5),
+  cleanliness: z11.number().min(0).max(5),
+  facilities: z11.number().min(0).max(5),
+  staffFriendliness: z11.number().min(0).max(5),
+  waitingTime: z11.number().min(0).max(5),
+  accessibility: z11.number().min(0).max(5),
+  recommendationPercentage: z11.number().min(0).max(100)
 });
-var practitionerReviewInfoSchema = z10.object({
-  totalReviews: z10.number().min(0),
-  averageRating: z10.number().min(0).max(5),
-  knowledgeAndExpertise: z10.number().min(0).max(5),
-  communicationSkills: z10.number().min(0).max(5),
-  bedSideManner: z10.number().min(0).max(5),
-  thoroughness: z10.number().min(0).max(5),
-  trustworthiness: z10.number().min(0).max(5),
-  recommendationPercentage: z10.number().min(0).max(100)
+var practitionerReviewInfoSchema = z11.object({
+  totalReviews: z11.number().min(0),
+  averageRating: z11.number().min(0).max(5),
+  knowledgeAndExpertise: z11.number().min(0).max(5),
+  communicationSkills: z11.number().min(0).max(5),
+  bedSideManner: z11.number().min(0).max(5),
+  thoroughness: z11.number().min(0).max(5),
+  trustworthiness: z11.number().min(0).max(5),
+  recommendationPercentage: z11.number().min(0).max(100)
 });
-var procedureReviewInfoSchema = z10.object({
-  totalReviews: z10.number().min(0),
-  averageRating: z10.number().min(0).max(5),
-  effectivenessOfTreatment: z10.number().min(0).max(5),
-  outcomeExplanation: z10.number().min(0).max(5),
-  painManagement: z10.number().min(0).max(5),
-  followUpCare: z10.number().min(0).max(5),
-  valueForMoney: z10.number().min(0).max(5),
-  recommendationPercentage: z10.number().min(0).max(100)
+var procedureReviewInfoSchema = z11.object({
+  totalReviews: z11.number().min(0),
+  averageRating: z11.number().min(0).max(5),
+  effectivenessOfTreatment: z11.number().min(0).max(5),
+  outcomeExplanation: z11.number().min(0).max(5),
+  painManagement: z11.number().min(0).max(5),
+  followUpCare: z11.number().min(0).max(5),
+  valueForMoney: z11.number().min(0).max(5),
+  recommendationPercentage: z11.number().min(0).max(100)
 });
-var reviewSchema = z10.object({
-  id: z10.string().min(1),
-  appointmentId: z10.string().min(1),
-  patientId: z10.string().min(1),
-  createdAt: z10.date(),
-  updatedAt: z10.date(),
+var reviewSchema = z11.object({
+  id: z11.string().min(1),
+  appointmentId: z11.string().min(1),
+  patientId: z11.string().min(1),
+  createdAt: z11.date(),
+  updatedAt: z11.date(),
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
-  overallComment: z10.string().min(1).max(2e3),
-  overallRating: z10.number().min(1).max(5)
+  overallComment: z11.string().min(1).max(2e3),
+  overallRating: z11.number().min(1).max(5)
 });
-var createReviewSchema = z10.object({
-  patientId: z10.string().min(1),
+var createReviewSchema = z11.object({
+  patientId: z11.string().min(1),
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: z10.string().min(1).max(2e3)
+  overallComment: z11.string().min(1).max(2e3)
 }).refine(
   (data) => {
     return data.clinicReview || data.practitionerReview || data.procedureReview;
@@ -3112,7 +3603,7 @@ var createReviewSchema = z10.object({
 );
 
 // src/validations/shared.schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/backoffice/types/static/procedure-family.types.ts
 var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
@@ -3141,65 +3632,57 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
 })(Currency || {});
 
 // src/validations/shared.schema.ts
-var sharedClinicContactInfoSchema = z11.object({
-  email: z11.string().email(),
-  phoneNumber: z11.string(),
-  alternativePhoneNumber: z11.string().nullable().optional(),
-  website: z11.string().nullable().optional()
+var sharedClinicContactInfoSchema = z12.object({
+  email: z12.string().email(),
+  phoneNumber: z12.string(),
+  alternativePhoneNumber: z12.string().nullable().optional(),
+  website: z12.string().nullable().optional()
 });
-var sharedClinicLocationSchema = z11.object({
-  address: z11.string(),
-  city: z11.string(),
-  country: z11.string(),
-  postalCode: z11.string(),
-  latitude: z11.number().min(-90).max(90),
-  longitude: z11.number().min(-180).max(180),
-  geohash: z11.string().nullable().optional()
+var sharedClinicLocationSchema = z12.object({
+  address: z12.string(),
+  city: z12.string(),
+  country: z12.string(),
+  postalCode: z12.string(),
+  latitude: z12.number().min(-90).max(90),
+  longitude: z12.number().min(-180).max(180),
+  geohash: z12.string().nullable().optional()
 });
-var procedureSummaryInfoSchema = z11.object({
-  id: z11.string().min(1),
-  name: z11.string().min(1),
-  description: z11.string().optional(),
-  photo: z11.string().optional(),
-  family: z11.nativeEnum(ProcedureFamily),
-  categoryName: z11.string(),
-  subcategoryName: z11.string(),
-  technologyName: z11.string(),
-  price: z11.number().nonnegative(),
-  pricingMeasure: z11.nativeEnum(PricingMeasure),
-  currency: z11.nativeEnum(Currency),
-  duration: z11.number().int().positive(),
-  clinicId: z11.string().min(1),
-  clinicName: z11.string().min(1),
-  practitionerId: z11.string().min(1),
-  practitionerName: z11.string().min(1)
+var procedureSummaryInfoSchema = z12.object({
+  id: z12.string().min(1),
+  name: z12.string().min(1),
+  description: z12.string().optional(),
+  photo: z12.string().optional(),
+  family: z12.nativeEnum(ProcedureFamily),
+  categoryName: z12.string(),
+  subcategoryName: z12.string(),
+  technologyName: z12.string(),
+  price: z12.number().nonnegative(),
+  pricingMeasure: z12.nativeEnum(PricingMeasure),
+  currency: z12.nativeEnum(Currency),
+  duration: z12.number().int().positive(),
+  clinicId: z12.string().min(1),
+  clinicName: z12.string().min(1),
+  practitionerId: z12.string().min(1),
+  practitionerName: z12.string().min(1)
 });
-var clinicInfoSchema = z11.object({
-  id: z11.string(),
-  featuredPhoto: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
+var clinicInfoSchema = z12.object({
+  id: z12.string(),
+  featuredPhoto: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
   location: sharedClinicLocationSchema,
   contactInfo: sharedClinicContactInfoSchema
 });
-var doctorInfoSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
-  photo: z11.string(),
-  rating: z11.number().min(0).max(5),
-  services: z11.array(z11.string())
+var doctorInfoSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
+  photo: z12.string(),
+  rating: z12.number().min(0).max(5),
+  services: z12.array(z12.string())
   // List of procedure IDs practitioner offers
 });
 
-// src/validations/media.schema.ts
-import { z as z12 } from "zod";
-var mediaResourceSchema = z12.union([
-  z12.string(),
-  z12.instanceof(File),
-  z12.instanceof(Blob)
-]);
-
 // src/validations/clinic.schema.ts
 var clinicContactInfoSchema = z13.object({
   email: z13.string().email(),
@@ -3259,8 +3742,8 @@ var clinicAdminSchema = z13.object({
   clinicsManagedInfo: z13.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
   roleTitle: z13.string(),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
-  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
+  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   isActive: z13.boolean()
 });
 var adminTokenSchema = z13.object({
@@ -3269,9 +3752,9 @@ var adminTokenSchema = z13.object({
   email: z13.string().email().optional().nullable(),
   status: z13.nativeEnum(AdminTokenStatus),
   usedByUserRef: z13.string().optional(),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
-  expiresAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6))
+  expiresAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7))
   // Timestamp
 });
 var createAdminTokenSchema = z13.object({
@@ -3291,9 +3774,9 @@ var clinicGroupSchema = z13.object({
   adminsInfo: z13.array(adminInfoSchema),
   adminTokens: z13.array(adminTokenSchema),
   ownerId: z13.string().nullable(),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
-  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
   isActive: z13.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
@@ -3335,9 +3818,9 @@ var clinicSchema = z13.object({
   // Use the correct schema for aggregated procedure info
   reviewInfo: clinicReviewInfoSchema,
   admins: z13.array(z13.string()),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
-  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
   isActive: z13.boolean(),
   isVerified: z13.boolean(),
@@ -3559,7 +4042,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
   const adminData = {
-    id: doc7(collection5(db, CLINIC_ADMINS_COLLECTION)).id,
+    id: doc8(collection6(db, CLINIC_ADMINS_COLLECTION)).id,
     // Generate a new ID for the admin document
     userRef: validatedData.userRef,
     clinicGroupId: clinicGroupId || "",
@@ -3579,8 +4062,8 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: Timestamp7.now(),
-      updatedAt: Timestamp7.now()
+      createdAt: Timestamp8.now(),
+      updatedAt: Timestamp8.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -3594,7 +4077,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     adminId: adminData.id
   });
   try {
-    await setDoc6(doc7(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    await setDoc7(doc8(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
     console.log("[CLINIC_ADMIN] Admin saved successfully");
   } catch (firestoreError) {
     console.error(
@@ -3643,30 +4126,30 @@ async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   return !!group;
 }
 async function getClinicAdmin(db, adminId) {
-  const docRef = doc7(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await getDoc10(docRef);
+  const docRef = doc8(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await getDoc11(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicAdminByUserRef(db, userRef) {
-  const q = query5(
-    collection5(db, CLINIC_ADMINS_COLLECTION),
-    where5("userRef", "==", userRef)
+  const q = query6(
+    collection6(db, CLINIC_ADMINS_COLLECTION),
+    where6("userRef", "==", userRef)
   );
-  const querySnapshot = await getDocs5(q);
+  const querySnapshot = await getDocs6(q);
   if (querySnapshot.empty) {
     return null;
   }
   return querySnapshot.docs[0].data();
 }
 async function getClinicAdminsByGroup(db, clinicGroupId) {
-  const q = query5(
-    collection5(db, CLINIC_ADMINS_COLLECTION),
-    where5("clinicGroupId", "==", clinicGroupId)
+  const q = query6(
+    collection6(db, CLINIC_ADMINS_COLLECTION),
+    where6("clinicGroupId", "==", clinicGroupId)
   );
-  const querySnapshot = await getDocs5(q);
+  const querySnapshot = await getDocs6(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
@@ -3678,7 +4161,7 @@ async function updateClinicAdmin(db, adminId, data) {
     ...data,
     updatedAt: serverTimestamp8()
   };
-  await updateDoc7(doc7(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+  await updateDoc8(doc8(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
   const updatedAdmin = await getClinicAdmin(db, adminId);
   if (!updatedAdmin) {
     throw new Error("Failed to retrieve updated admin");
@@ -3690,7 +4173,7 @@ async function deleteClinicAdmin(db, adminId) {
   if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  await deleteDoc(doc7(db, CLINIC_ADMINS_COLLECTION, adminId));
+  await deleteDoc2(doc8(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3934,27 +4417,27 @@ var ClinicAdminService = class extends BaseService {
 
 // src/services/practitioner/practitioner.service.ts
 import {
-  collection as collection6,
-  doc as doc8,
-  getDoc as getDoc11,
-  getDocs as getDocs6,
-  query as query6,
-  where as where6,
-  updateDoc as updateDoc8,
-  setDoc as setDoc7,
-  deleteDoc as deleteDoc2,
-  Timestamp as Timestamp9,
+  collection as collection7,
+  doc as doc9,
+  getDoc as getDoc12,
+  getDocs as getDocs7,
+  query as query7,
+  where as where7,
+  updateDoc as updateDoc9,
+  setDoc as setDoc8,
+  deleteDoc as deleteDoc3,
+  Timestamp as Timestamp10,
   serverTimestamp as serverTimestamp9,
-  limit as limit4,
+  limit as limit5,
   startAfter as startAfter4,
-  orderBy,
+  orderBy as orderBy2,
   arrayUnion as arrayUnion5,
   arrayRemove as arrayRemove4
 } from "firebase/firestore";
 
 // src/validations/practitioner.schema.ts
 import { z as z14 } from "zod";
-import { Timestamp as Timestamp8 } from "firebase/firestore";
+import { Timestamp as Timestamp9 } from "firebase/firestore";
 
 // src/backoffice/types/static/certification.types.ts
 var CertificationLevel = /* @__PURE__ */ ((CertificationLevel2) => {
@@ -3987,9 +4470,9 @@ var practitionerBasicInfoSchema = z14.object({
   title: z14.string().min(2).max(100),
   email: z14.string().email(),
   phoneNumber: z14.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: z14.instanceof(Timestamp8).or(z14.date()),
+  dateOfBirth: z14.instanceof(Timestamp9).or(z14.date()),
   gender: z14.enum(["male", "female", "other"]),
-  profileImageUrl: z14.string().url().optional(),
+  profileImageUrl: mediaResourceSchema.optional(),
   bio: z14.string().max(1e3).optional(),
   languages: z14.array(z14.string()).min(1)
 });
@@ -3998,8 +4481,8 @@ var practitionerCertificationSchema = z14.object({
   specialties: z14.array(z14.nativeEnum(CertificationSpecialty)),
   licenseNumber: z14.string().min(3).max(50),
   issuingAuthority: z14.string().min(2).max(100),
-  issueDate: z14.instanceof(Timestamp8).or(z14.date()),
-  expiryDate: z14.instanceof(Timestamp8).or(z14.date()).optional(),
+  issueDate: z14.instanceof(Timestamp9).or(z14.date()),
+  expiryDate: z14.instanceof(Timestamp9).or(z14.date()).optional(),
   verificationStatus: z14.enum(["pending", "verified", "rejected"])
 });
 var timeSlotSchema = z14.object({
@@ -4016,8 +4499,8 @@ var practitionerWorkingHoursSchema = z14.object({
   friday: timeSlotSchema,
   saturday: timeSlotSchema,
   sunday: timeSlotSchema,
-  createdAt: z14.instanceof(Timestamp8).or(z14.date()),
-  updatedAt: z14.instanceof(Timestamp8).or(z14.date())
+  createdAt: z14.instanceof(Timestamp9).or(z14.date()),
+  updatedAt: z14.instanceof(Timestamp9).or(z14.date())
 });
 var practitionerClinicWorkingHoursSchema = z14.object({
   clinicId: z14.string().min(1),
@@ -4031,8 +4514,8 @@ var practitionerClinicWorkingHoursSchema = z14.object({
     sunday: timeSlotSchema
   }),
   isActive: z14.boolean(),
-  createdAt: z14.instanceof(Timestamp8).or(z14.date()),
-  updatedAt: z14.instanceof(Timestamp8).or(z14.date())
+  createdAt: z14.instanceof(Timestamp9).or(z14.date()),
+  updatedAt: z14.instanceof(Timestamp9).or(z14.date())
 });
 var practitionerSchema = z14.object({
   id: z14.string().min(1),
@@ -4048,8 +4531,8 @@ var practitionerSchema = z14.object({
   isActive: z14.boolean(),
   isVerified: z14.boolean(),
   status: z14.nativeEnum(PractitionerStatus),
-  createdAt: z14.instanceof(Timestamp8).or(z14.date()),
-  updatedAt: z14.instanceof(Timestamp8).or(z14.date())
+  createdAt: z14.instanceof(Timestamp9).or(z14.date()),
+  updatedAt: z14.instanceof(Timestamp9).or(z14.date())
 });
 var createPractitionerSchema = z14.object({
   userRef: z14.string().min(1),
@@ -4081,10 +4564,10 @@ var practitionerTokenSchema = z14.object({
   clinicId: z14.string().min(1),
   status: z14.nativeEnum(PractitionerTokenStatus),
   createdBy: z14.string().min(1),
-  createdAt: z14.instanceof(Timestamp8).or(z14.date()),
-  expiresAt: z14.instanceof(Timestamp8).or(z14.date()),
+  createdAt: z14.instanceof(Timestamp9).or(z14.date()),
+  expiresAt: z14.instanceof(Timestamp9).or(z14.date()),
   usedBy: z14.string().optional(),
-  usedAt: z14.instanceof(Timestamp8).or(z14.date()).optional()
+  usedAt: z14.instanceof(Timestamp9).or(z14.date()).optional()
 });
 var createPractitionerTokenSchema = z14.object({
   practitionerId: z14.string().min(1),
@@ -4101,7 +4584,7 @@ var practitionerSignupSchema = z14.object({
   profileData: z14.object({
     basicInfo: z14.object({
       phoneNumber: z14.string().optional(),
-      profileImageUrl: z14.string().optional(),
+      profileImageUrl: mediaResourceSchema.optional(),
       gender: z14.enum(["male", "female", "other"]).optional(),
       bio: z14.string().optional()
     }).optional(),
@@ -4116,6 +4599,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) {
@@ -4126,6 +4610,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
    */
@@ -4146,7 +4677,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 || [],
@@ -4162,15 +4696,15 @@ var PractitionerService = class extends BaseService {
       };
       practitionerSchema.parse({
         ...practitioner,
-        createdAt: Timestamp9.now(),
-        updatedAt: Timestamp9.now()
+        createdAt: Timestamp10.now(),
+        updatedAt: Timestamp10.now()
       });
-      const practitionerRef = doc8(
+      const practitionerRef = doc9(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      await setDoc7(practitionerRef, practitioner);
+      await setDoc8(practitionerRef, practitioner);
       const createdPractitioner = await this.getPractitioner(practitionerId);
       if (!createdPractitioner) {
         throw new Error(
@@ -4246,7 +4780,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 || [],
@@ -4263,11 +4800,11 @@ var PractitionerService = class extends BaseService {
       practitionerSchema.parse({
         ...practitionerData,
         userRef: "temp-for-validation",
-        createdAt: Timestamp9.now(),
-        updatedAt: Timestamp9.now()
+        createdAt: Timestamp10.now(),
+        updatedAt: Timestamp10.now()
       });
-      await setDoc7(
-        doc8(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
+      await setDoc8(
+        doc9(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
         practitionerData
       );
       const savedPractitioner = await this.getPractitioner(practitionerData.id);
@@ -4284,12 +4821,12 @@ var PractitionerService = class extends BaseService {
         clinicId,
         status: "active" /* ACTIVE */,
         createdBy,
-        createdAt: Timestamp9.now(),
-        expiresAt: Timestamp9.fromDate(expiration)
+        createdAt: Timestamp10.now(),
+        expiresAt: Timestamp10.fromDate(expiration)
       };
       practitionerTokenSchema.parse(token);
       const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
-      await setDoc7(doc8(this.db, tokenPath), token);
+      await setDoc8(doc9(this.db, tokenPath), token);
       return { practitioner: savedPractitioner, token };
     } catch (error) {
       if (error instanceof z15.ZodError) {
@@ -4337,12 +4874,12 @@ var PractitionerService = class extends BaseService {
         clinicId: validatedData.clinicId,
         status: "active" /* ACTIVE */,
         createdBy,
-        createdAt: Timestamp9.now(),
-        expiresAt: Timestamp9.fromDate(expiration)
+        createdAt: Timestamp10.now(),
+        expiresAt: Timestamp10.fromDate(expiration)
       };
       practitionerTokenSchema.parse(token);
       const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
-      await setDoc7(doc8(this.db, tokenPath), token);
+      await setDoc8(doc9(this.db, tokenPath), token);
       return token;
     } catch (error) {
       if (error instanceof z15.ZodError) {
@@ -4357,16 +4894,16 @@ var PractitionerService = class extends BaseService {
    * @returns Array of active tokens
    */
   async getPractitionerActiveTokens(practitionerId) {
-    const tokensRef = collection6(
+    const tokensRef = collection7(
       this.db,
       `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
     );
-    const q = query6(
+    const q = query7(
       tokensRef,
-      where6("status", "==", "active" /* ACTIVE */),
-      where6("expiresAt", ">", Timestamp9.now())
+      where7("status", "==", "active" /* ACTIVE */),
+      where7("expiresAt", ">", Timestamp10.now())
     );
-    const querySnapshot = await getDocs6(q);
+    const querySnapshot = await getDocs7(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
@@ -4375,11 +4912,11 @@ var PractitionerService = class extends BaseService {
    * @returns The token if found and valid, null otherwise
    */
   async validateToken(tokenString) {
-    const practitionersRef = collection6(this.db, PRACTITIONERS_COLLECTION);
-    const practitionersSnapshot = await getDocs6(practitionersRef);
+    const practitionersRef = collection7(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await getDocs7(practitionersRef);
     for (const practitionerDoc of practitionersSnapshot.docs) {
       const practitionerId = practitionerDoc.id;
-      const tokensRef = collection6(
+      const tokensRef = collection7(
         this.db,
         `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
       );
@@ -4387,17 +4924,17 @@ var PractitionerService = class extends BaseService {
         `[PRACTITIONER] Validating token for practitioner ${practitionerId}`,
         {
           tokenString,
-          timestamp: Timestamp9.now().toDate()
+          timestamp: Timestamp10.now().toDate()
         }
       );
-      const q = query6(
+      const q = query7(
         tokensRef,
-        where6("token", "==", tokenString),
-        where6("status", "==", "active" /* ACTIVE */),
-        where6("expiresAt", ">", Timestamp9.now())
+        where7("token", "==", tokenString),
+        where7("status", "==", "active" /* ACTIVE */),
+        where7("expiresAt", ">", Timestamp10.now())
       );
       try {
-        const tokenSnapshot = await getDocs6(q);
+        const tokenSnapshot = await getDocs7(q);
         console.log(
           `[PRACTITIONER] Token query results for practitioner ${practitionerId}`,
           {
@@ -4430,22 +4967,22 @@ var PractitionerService = class extends BaseService {
    * @param userId ID of the user using the token
    */
   async markTokenAsUsed(tokenId, practitionerId, userId) {
-    const tokenRef = doc8(
+    const tokenRef = doc9(
       this.db,
       `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
     );
-    await updateDoc8(tokenRef, {
+    await updateDoc9(tokenRef, {
       status: "used" /* USED */,
       usedBy: userId,
-      usedAt: Timestamp9.now()
+      usedAt: Timestamp10.now()
     });
   }
   /**
    * Dohvata zdravstvenog radnika po ID-u
    */
   async getPractitioner(practitionerId) {
-    const practitionerDoc = await getDoc11(
-      doc8(this.db, PRACTITIONERS_COLLECTION, practitionerId)
+    const practitionerDoc = await getDoc12(
+      doc9(this.db, PRACTITIONERS_COLLECTION, practitionerId)
     );
     if (!practitionerDoc.exists()) {
       return null;
@@ -4456,11 +4993,11 @@ var PractitionerService = class extends BaseService {
    * Dohvata zdravstvenog radnika po User ID-u
    */
   async getPractitionerByUserRef(userRef) {
-    const q = query6(
-      collection6(this.db, PRACTITIONERS_COLLECTION),
-      where6("userRef", "==", userRef)
+    const q = query7(
+      collection7(this.db, PRACTITIONERS_COLLECTION),
+      where7("userRef", "==", userRef)
     );
-    const querySnapshot = await getDocs6(q);
+    const querySnapshot = await getDocs7(q);
     if (querySnapshot.empty) {
       return null;
     }
@@ -4470,37 +5007,37 @@ var PractitionerService = class extends BaseService {
    * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */
   async getPractitionersByClinic(clinicId) {
-    const q = query6(
-      collection6(this.db, PRACTITIONERS_COLLECTION),
-      where6("clinics", "array-contains", clinicId),
-      where6("isActive", "==", true),
-      where6("status", "==", "active" /* ACTIVE */)
+    const q = query7(
+      collection7(this.db, PRACTITIONERS_COLLECTION),
+      where7("clinics", "array-contains", clinicId),
+      where7("isActive", "==", true),
+      where7("status", "==", "active" /* ACTIVE */)
     );
-    const querySnapshot = await getDocs6(q);
+    const querySnapshot = await getDocs7(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku
    */
   async getAllPractitionersByClinic(clinicId) {
-    const q = query6(
-      collection6(this.db, PRACTITIONERS_COLLECTION),
-      where6("clinics", "array-contains", clinicId),
-      where6("isActive", "==", true)
+    const q = query7(
+      collection7(this.db, PRACTITIONERS_COLLECTION),
+      where7("clinics", "array-contains", clinicId),
+      where7("isActive", "==", true)
     );
-    const querySnapshot = await getDocs6(q);
+    const querySnapshot = await getDocs7(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 = query6(
-      collection6(this.db, PRACTITIONERS_COLLECTION),
-      where6("clinics", "array-contains", clinicId),
-      where6("status", "==", "draft" /* DRAFT */)
+    const q = query7(
+      collection7(this.db, PRACTITIONERS_COLLECTION),
+      where7("clinics", "array-contains", clinicId),
+      where7("status", "==", "draft" /* DRAFT */)
     );
-    const querySnapshot = await getDocs6(q);
+    const querySnapshot = await getDocs7(q);
     return querySnapshot.docs.map((doc34) => doc34.data());
   }
   /**
@@ -4509,21 +5046,28 @@ var PractitionerService = class extends BaseService {
   async updatePractitioner(practitionerId, data) {
     try {
       const validData = data;
-      const practitionerRef = doc8(
+      const practitionerRef = doc9(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      const practitionerDoc = await getDoc11(practitionerRef);
+      const practitionerDoc = await getDoc12(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,
+        ...processedData,
         updatedAt: serverTimestamp9()
       };
-      await updateDoc8(practitionerRef, updateData);
+      await updateDoc9(practitionerRef, updateData);
       const updatedPractitioner = await this.getPractitioner(practitionerId);
       if (!updatedPractitioner) {
         throw new Error(
@@ -4545,12 +5089,12 @@ var PractitionerService = class extends BaseService {
   async addClinic(practitionerId, clinicId) {
     var _a;
     try {
-      const practitionerRef = doc8(
+      const practitionerRef = doc9(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      const practitionerDoc = await getDoc11(practitionerRef);
+      const practitionerDoc = await getDoc12(practitionerRef);
       if (!practitionerDoc.exists()) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
@@ -4561,7 +5105,7 @@ var PractitionerService = class extends BaseService {
         );
         return;
       }
-      await updateDoc8(practitionerRef, {
+      await updateDoc9(practitionerRef, {
         clinics: arrayUnion5(clinicId),
         updatedAt: serverTimestamp9()
       });
@@ -4578,16 +5122,16 @@ var PractitionerService = class extends BaseService {
    */
   async removeClinic(practitionerId, clinicId) {
     try {
-      const practitionerRef = doc8(
+      const practitionerRef = doc9(
         this.db,
         PRACTITIONERS_COLLECTION,
         practitionerId
       );
-      const practitionerDoc = await getDoc11(practitionerRef);
+      const practitionerDoc = await getDoc12(practitionerRef);
       if (!practitionerDoc.exists()) {
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
-      await updateDoc8(practitionerRef, {
+      await updateDoc9(practitionerRef, {
         clinics: arrayRemove4(clinicId),
         updatedAt: serverTimestamp9()
       });
@@ -4623,7 +5167,7 @@ var PractitionerService = class extends BaseService {
     if (!practitioner) {
       throw new Error("Practitioner not found");
     }
-    await deleteDoc2(doc8(this.db, PRACTITIONERS_COLLECTION, practitionerId));
+    await deleteDoc3(doc9(this.db, PRACTITIONERS_COLLECTION, practitionerId));
   }
   /**
    * Validates a registration token and claims the associated draft practitioner profile
@@ -4692,21 +5236,21 @@ var PractitionerService = class extends BaseService {
     try {
       const constraints = [];
       if (!(options == null ? void 0 : options.includeDraftPractitioners)) {
-        constraints.push(where6("status", "==", "active" /* ACTIVE */));
+        constraints.push(where7("status", "==", "active" /* ACTIVE */));
       }
-      constraints.push(orderBy("basicInfo.lastName", "asc"));
-      constraints.push(orderBy("basicInfo.firstName", "asc"));
+      constraints.push(orderBy2("basicInfo.lastName", "asc"));
+      constraints.push(orderBy2("basicInfo.firstName", "asc"));
       if ((options == null ? void 0 : options.pagination) && options.pagination > 0) {
         if (options.lastDoc) {
           constraints.push(startAfter4(options.lastDoc));
         }
-        constraints.push(limit4(options.pagination));
+        constraints.push(limit5(options.pagination));
       }
-      const q = query6(
-        collection6(this.db, PRACTITIONERS_COLLECTION),
+      const q = query7(
+        collection7(this.db, PRACTITIONERS_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await getDocs6(q);
+      const querySnapshot = await getDocs7(q);
       const practitioners = querySnapshot.docs.map(
         (doc34) => doc34.data()
       );
@@ -4751,31 +5295,31 @@ var PractitionerService = class extends BaseService {
       );
       const constraints = [];
       if (!filters.includeDraftPractitioners) {
-        constraints.push(where6("status", "==", "active" /* ACTIVE */));
+        constraints.push(where7("status", "==", "active" /* ACTIVE */));
       }
-      constraints.push(where6("isActive", "==", true));
+      constraints.push(where7("isActive", "==", true));
       if (filters.certifications && filters.certifications.length > 0) {
         constraints.push(
-          where6(
+          where7(
             "certification.certifications",
             "array-contains-any",
             filters.certifications
           )
         );
       }
-      constraints.push(orderBy("basicInfo.lastName", "asc"));
-      constraints.push(orderBy("basicInfo.firstName", "asc"));
+      constraints.push(orderBy2("basicInfo.lastName", "asc"));
+      constraints.push(orderBy2("basicInfo.firstName", "asc"));
       if (filters.pagination && filters.pagination > 0) {
         if (filters.lastDoc) {
           constraints.push(startAfter4(filters.lastDoc));
         }
-        constraints.push(limit4(filters.pagination));
+        constraints.push(limit5(filters.pagination));
       }
-      const q = query6(
-        collection6(this.db, PRACTITIONERS_COLLECTION),
+      const q = query7(
+        collection7(this.db, PRACTITIONERS_COLLECTION),
         ...constraints
       );
-      const querySnapshot = await getDocs6(q);
+      const querySnapshot = await getDocs7(q);
       console.log(
         `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
       );
@@ -4901,7 +5445,7 @@ var UserService = class extends BaseService {
       updatedAt: serverTimestamp10(),
       lastLoginAt: serverTimestamp10()
     };
-    await setDoc8(doc9(this.db, USERS_COLLECTION, userData.uid), userData);
+    await setDoc9(doc10(this.db, USERS_COLLECTION, userData.uid), userData);
     if (options == null ? void 0 : options.skipProfileCreation) {
       return this.getUserById(userData.uid);
     }
@@ -4910,7 +5454,7 @@ var UserService = class extends BaseService {
       roles,
       options
     );
-    await updateDoc9(doc9(this.db, USERS_COLLECTION, userData.uid), profiles);
+    await updateDoc10(doc10(this.db, USERS_COLLECTION, userData.uid), profiles);
     return this.getUserById(userData.uid);
   }
   /**
@@ -4988,7 +5532,7 @@ var UserService = class extends BaseService {
               email: "",
               phoneNumber: "",
               title: "",
-              dateOfBirth: Timestamp10.now(),
+              dateOfBirth: Timestamp11.now(),
               gender: "other",
               languages: ["Serbian"]
             },
@@ -4997,7 +5541,7 @@ var UserService = class extends BaseService {
               specialties: [],
               licenseNumber: "",
               issuingAuthority: "",
-              issueDate: Timestamp10.now(),
+              issueDate: Timestamp11.now(),
               verificationStatus: "pending"
             },
             isActive: true,
@@ -5013,7 +5557,7 @@ var UserService = class extends BaseService {
    * Dohvata korisnika po ID-u
    */
   async getUserById(uid) {
-    const userDoc = await getDoc12(doc9(this.db, USERS_COLLECTION, uid));
+    const userDoc = await getDoc13(doc10(this.db, USERS_COLLECTION, uid));
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5024,19 +5568,19 @@ var UserService = class extends BaseService {
    * Dohvata korisnika po email-u
    */
   async getUserByEmail(email) {
-    const usersRef = collection7(this.db, USERS_COLLECTION);
-    const q = query7(usersRef, where7("email", "==", email));
-    const querySnapshot = await getDocs7(q);
+    const usersRef = collection8(this.db, USERS_COLLECTION);
+    const q = query8(usersRef, where8("email", "==", email));
+    const querySnapshot = await getDocs8(q);
     if (querySnapshot.empty) return null;
     const userData = querySnapshot.docs[0].data();
     return userSchema.parse(userData);
   }
   async getUsersByRole(role) {
     const constraints = [
-      where7("roles", "array-contains", role)
+      where8("roles", "array-contains", role)
     ];
-    const q = query7(collection7(this.db, USERS_COLLECTION), ...constraints);
-    const querySnapshot = await getDocs7(q);
+    const q = query8(collection8(this.db, USERS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs8(q);
     const users = querySnapshot.docs.map((doc34) => doc34.data());
     return Promise.all(users.map((userData) => userSchema.parse(userData)));
   }
@@ -5044,24 +5588,24 @@ var UserService = class extends BaseService {
    * Ažurira timestamp poslednjeg logovanja
    */
   async updateUserLoginTimestamp(uid) {
-    const userRef = doc9(this.db, USERS_COLLECTION, uid);
-    const userDoc = await getDoc12(userRef);
+    const userRef = doc10(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc13(userRef);
     if (!userDoc.exists()) {
       throw AUTH_ERRORS.USER_NOT_FOUND;
     }
-    await updateDoc9(userRef, {
+    await updateDoc10(userRef, {
       lastLoginAt: serverTimestamp10(),
       updatedAt: serverTimestamp10()
     });
     return this.getUserById(uid);
   }
   async upgradeAnonymousUser(uid, email) {
-    const userRef = doc9(this.db, USERS_COLLECTION, uid);
-    const userDoc = await getDoc12(userRef);
+    const userRef = doc10(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc13(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
-    await updateDoc9(userRef, {
+    await updateDoc10(userRef, {
       email,
       isAnonymous: false,
       updatedAt: serverTimestamp10()
@@ -5069,8 +5613,8 @@ var UserService = class extends BaseService {
     return this.getUserById(uid);
   }
   async updateUser(uid, updates) {
-    const userRef = doc9(this.db, USERS_COLLECTION, uid);
-    const userDoc = await getDoc12(userRef);
+    const userRef = doc10(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc13(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5082,7 +5626,7 @@ var UserService = class extends BaseService {
         updatedAt: serverTimestamp10()
       };
       userSchema.parse(updatedUser);
-      await updateDoc9(userRef, {
+      await updateDoc10(userRef, {
         ...updates,
         updatedAt: serverTimestamp10()
       });
@@ -5101,7 +5645,7 @@ 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 updateDoc9(doc9(this.db, USERS_COLLECTION, uid), {
+    await updateDoc10(doc10(this.db, USERS_COLLECTION, uid), {
       roles: [...user.roles, role],
       ...profiles,
       updatedAt: serverTimestamp10()
@@ -5136,15 +5680,15 @@ var UserService = class extends BaseService {
         }
         break;
     }
-    await updateDoc9(doc9(this.db, USERS_COLLECTION, uid), {
+    await updateDoc10(doc10(this.db, USERS_COLLECTION, uid), {
       roles: user.roles.filter((r) => r !== role),
       updatedAt: serverTimestamp10()
     });
   }
   // Delete operations
   async deleteUser(uid) {
-    const userRef = doc9(this.db, USERS_COLLECTION, uid);
-    const userDoc = await getDoc12(userRef);
+    const userRef = doc10(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc13(userRef);
     if (!userDoc.exists()) {
       throw USER_ERRORS.NOT_FOUND;
     }
@@ -5165,7 +5709,7 @@ var UserService = class extends BaseService {
           userData.adminProfile
         );
       }
-      await deleteDoc3(userRef);
+      await deleteDoc4(userRef);
     } catch (error) {
       throw error;
     }
@@ -5174,15 +5718,15 @@ var UserService = class extends BaseService {
 
 // src/services/clinic/utils/clinic-group.utils.ts
 import {
-  collection as collection8,
-  doc as doc10,
-  getDoc as getDoc13,
-  getDocs as getDocs8,
-  query as query8,
-  where as where8,
-  updateDoc as updateDoc10,
-  setDoc as setDoc9,
-  Timestamp as Timestamp11
+  collection as collection9,
+  doc as doc11,
+  getDoc as getDoc14,
+  getDocs as getDocs9,
+  query as query9,
+  where as where9,
+  updateDoc as updateDoc11,
+  setDoc as setDoc10,
+  Timestamp as Timestamp12
 } from "firebase/firestore";
 import { geohashForLocation as geohashForLocation2 } from "geofire-common";
 import { z as z17 } from "zod";
@@ -5306,9 +5850,9 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
       throw geohashError;
     }
   }
-  const now = Timestamp11.now();
+  const now = Timestamp12.now();
   console.log("[CLINIC_GROUP] Preparing clinic group data object");
-  const groupId = doc10(collection8(db, CLINIC_GROUPS_COLLECTION)).id;
+  const groupId = doc11(collection9(db, CLINIC_GROUPS_COLLECTION)).id;
   console.log("[CLINIC_GROUP] Logo value:", {
     logoValue: validatedData.logo,
     logoType: validatedData.logo === null ? "null" : typeof validatedData.logo
@@ -5358,7 +5902,7 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
       groupId: groupData.id
     });
     try {
-      await setDoc9(doc10(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
+      await setDoc10(doc11(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
       console.log("[CLINIC_GROUP] Clinic group saved successfully");
     } catch (firestoreError) {
       console.error(
@@ -5404,19 +5948,19 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
   }
 }
 async function getClinicGroup(db, groupId) {
-  const docRef = doc10(db, CLINIC_GROUPS_COLLECTION, groupId);
-  const docSnap = await getDoc13(docRef);
+  const docRef = doc11(db, CLINIC_GROUPS_COLLECTION, groupId);
+  const docSnap = await getDoc14(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getAllActiveGroups(db) {
-  const q = query8(
-    collection8(db, CLINIC_GROUPS_COLLECTION),
-    where8("isActive", "==", true)
+  const q = query9(
+    collection9(db, CLINIC_GROUPS_COLLECTION),
+    where9("isActive", "==", true)
   );
-  const querySnapshot = await getDocs8(q);
+  const querySnapshot = await getDocs9(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicGroup(db, groupId, data, app) {
@@ -5445,10 +5989,10 @@ async function updateClinicGroup(db, groupId, data, app) {
   }
   updatedData = {
     ...updatedData,
-    updatedAt: Timestamp11.now()
+    updatedAt: Timestamp12.now()
   };
   console.log("[CLINIC_GROUP] Updating clinic group in Firestore");
-  await updateDoc10(doc10(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
+  await updateDoc11(doc11(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
   console.log("[CLINIC_GROUP] Clinic group updated successfully");
   const updatedGroup = await getClinicGroup(db, groupId);
   if (!updatedGroup) {
@@ -5529,10 +6073,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 = Timestamp11.now();
+  const now = Timestamp12.now();
   const expiresInDays = (data == null ? void 0 : data.expiresInDays) || 7;
   const email = (data == null ? void 0 : data.email) || null;
-  const expiresAt = new Timestamp11(
+  const expiresAt = new Timestamp12(
     now.seconds + expiresInDays * 24 * 60 * 60,
     now.nanoseconds
   );
@@ -5566,7 +6110,7 @@ async function verifyAndUseAdminToken(db, groupId, token, userRef, app) {
   if (adminToken.status !== "active" /* ACTIVE */) {
     throw new Error("Admin token is not active");
   }
-  const now = Timestamp11.now();
+  const now = Timestamp12.now();
   if (adminToken.expiresAt.seconds < now.seconds) {
     const updatedTokens2 = group.adminTokens.map(
       (t) => t.id === adminToken.id ? { ...t, status: "expired" /* EXPIRED */ } : t
@@ -5849,16 +6393,16 @@ import { z as z19 } from "zod";
 
 // src/services/clinic/utils/clinic.utils.ts
 import {
-  collection as collection9,
-  doc as doc11,
-  getDoc as getDoc14,
-  getDocs as getDocs9,
-  query as query9,
-  where as where9,
-  updateDoc as updateDoc11,
-  setDoc as setDoc10,
-  Timestamp as Timestamp12,
-  limit as limit5,
+  collection as collection10,
+  doc as doc12,
+  getDoc as getDoc15,
+  getDocs as getDocs10,
+  query as query10,
+  where as where10,
+  updateDoc as updateDoc12,
+  setDoc as setDoc11,
+  Timestamp as Timestamp13,
+  limit as limit6,
   startAfter as startAfter5
 } from "firebase/firestore";
 import {
@@ -5868,20 +6412,20 @@ import {
 } from "geofire-common";
 import { z as z18 } from "zod";
 async function getClinic(db, clinicId) {
-  const docRef = doc11(db, CLINICS_COLLECTION, clinicId);
-  const docSnap = await getDoc14(docRef);
+  const docRef = doc12(db, CLINICS_COLLECTION, clinicId);
+  const docSnap = await getDoc15(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicsByGroup(db, groupId) {
-  const q = query9(
-    collection9(db, CLINICS_COLLECTION),
-    where9("clinicGroupId", "==", groupId),
-    where9("isActive", "==", true)
+  const q = query10(
+    collection10(db, CLINICS_COLLECTION),
+    where10("clinicGroupId", "==", groupId),
+    where10("isActive", "==", true)
   );
-  const querySnapshot = await getDocs9(q);
+  const querySnapshot = await getDocs10(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
@@ -6037,11 +6581,11 @@ async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app
   }
   updatedData = {
     ...updatedData,
-    updatedAt: Timestamp12.now()
+    updatedAt: Timestamp13.now()
   };
   console.log("[CLINIC] Updating clinic in Firestore");
   try {
-    await updateDoc11(doc11(db, CLINICS_COLLECTION, clinicId), updatedData);
+    await updateDoc12(doc12(db, CLINICS_COLLECTION, clinicId), updatedData);
     console.log("[CLINIC] Clinic updated successfully");
   } catch (updateError) {
     console.error("[CLINIC] Error updating clinic in Firestore:", updateError);
@@ -6070,12 +6614,12 @@ async function getClinicsByAdmin(db, adminId, options = {}, clinicAdminService,
   if (clinicIds.length === 0) {
     return [];
   }
-  const constraints = [where9("id", "in", clinicIds)];
+  const constraints = [where10("id", "in", clinicIds)];
   if (options.isActive !== void 0) {
-    constraints.push(where9("isActive", "==", options.isActive));
+    constraints.push(where10("isActive", "==", options.isActive));
   }
-  const q = query9(collection9(db, CLINICS_COLLECTION), ...constraints);
-  const querySnapshot = await getDocs9(q);
+  const q = query10(collection10(db, CLINICS_COLLECTION), ...constraints);
+  const querySnapshot = await getDocs10(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGroupService) {
@@ -6089,8 +6633,8 @@ async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGr
 }
 async function getClinicById(db, clinicId) {
   try {
-    const clinicRef = doc11(db, CLINICS_COLLECTION, clinicId);
-    const clinicSnapshot = await getDoc14(clinicRef);
+    const clinicRef = doc12(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await getDoc15(clinicRef);
     if (!clinicSnapshot.exists()) {
       return null;
     }
@@ -6106,20 +6650,20 @@ async function getClinicById(db, clinicId) {
 }
 async function getAllClinics(db, pagination, lastDoc) {
   try {
-    const clinicsCollection = collection9(db, CLINICS_COLLECTION);
-    let clinicsQuery = query9(clinicsCollection);
+    const clinicsCollection = collection10(db, CLINICS_COLLECTION);
+    let clinicsQuery = query10(clinicsCollection);
     if (pagination && pagination > 0) {
       if (lastDoc) {
-        clinicsQuery = query9(
+        clinicsQuery = query10(
           clinicsCollection,
           startAfter5(lastDoc),
-          limit5(pagination)
+          limit6(pagination)
         );
       } else {
-        clinicsQuery = query9(clinicsCollection, limit5(pagination));
+        clinicsQuery = query10(clinicsCollection, limit6(pagination));
       }
     }
-    const clinicsSnapshot = await getDocs9(clinicsQuery);
+    const clinicsSnapshot = await getDocs10(clinicsQuery);
     const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
     const clinics = clinicsSnapshot.docs.map((doc34) => {
       const data = doc34.data();
@@ -6146,12 +6690,12 @@ async function getAllClinicsInRange(db, center, rangeInKm, pagination, lastDoc)
   let lastDocSnapshot = null;
   for (const b of bounds) {
     const constraints = [
-      where9("location.geohash", ">=", b[0]),
-      where9("location.geohash", "<=", b[1]),
-      where9("isActive", "==", true)
+      where10("location.geohash", ">=", b[0]),
+      where10("location.geohash", "<=", b[1]),
+      where10("isActive", "==", true)
     ];
-    const q = query9(collection9(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await getDocs9(q);
+    const q = query10(collection10(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs10(q);
     for (const doc34 of querySnapshot.docs) {
       const clinic = doc34.data();
       const distance = distanceBetween2(
@@ -6247,10 +6791,10 @@ async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminServic
 
 // src/services/clinic/utils/search.utils.ts
 import {
-  collection as collection10,
-  query as query10,
-  where as where10,
-  getDocs as getDocs10
+  collection as collection11,
+  query as query11,
+  where as where11,
+  getDocs as getDocs11
 } from "firebase/firestore";
 import { geohashQueryBounds as geohashQueryBounds2, distanceBetween as distanceBetween3 } from "geofire-common";
 async function findClinicsInRadius(db, center, radiusInKm, filters) {
@@ -6261,20 +6805,20 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
   const matchingDocs = [];
   for (const b of bounds) {
     const constraints = [
-      where10("location.geohash", ">=", b[0]),
-      where10("location.geohash", "<=", b[1]),
-      where10("isActive", "==", true)
+      where11("location.geohash", ">=", b[0]),
+      where11("location.geohash", "<=", b[1]),
+      where11("isActive", "==", true)
     ];
     if (filters == null ? void 0 : filters.services) {
       constraints.push(
-        where10("services", "array-contains-any", filters.services)
+        where11("services", "array-contains-any", filters.services)
       );
     }
     if ((filters == null ? void 0 : filters.tags) && filters.tags.length > 0) {
-      constraints.push(where10("tags", "array-contains-any", filters.tags));
+      constraints.push(where11("tags", "array-contains-any", filters.tags));
     }
-    const q = query10(collection10(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await getDocs10(q);
+    const q = query11(collection11(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs11(q);
     for (const doc34 of querySnapshot.docs) {
       const clinic = doc34.data();
       const distance = distanceBetween3(
@@ -6302,13 +6846,13 @@ async function findClinicsInRadius(db, center, radiusInKm, filters) {
 
 // src/services/clinic/utils/filter.utils.ts
 import {
-  collection as collection11,
-  query as query11,
-  where as where11,
-  getDocs as getDocs11,
+  collection as collection12,
+  query as query12,
+  where as where12,
+  getDocs as getDocs12,
   startAfter as startAfter6,
-  limit as limit6,
-  orderBy as orderBy2
+  limit as limit7,
+  orderBy as orderBy3
 } from "firebase/firestore";
 import { geohashQueryBounds as geohashQueryBounds3, distanceBetween as distanceBetween4 } from "geofire-common";
 async function getClinicsByFilters(db, filters) {
@@ -6319,37 +6863,37 @@ async function getClinicsByFilters(db, filters) {
   const isGeoQuery = filters.center && filters.radiusInKm && filters.radiusInKm > 0;
   const constraints = [];
   if (filters.isActive !== void 0) {
-    constraints.push(where11("isActive", "==", filters.isActive));
+    constraints.push(where12("isActive", "==", filters.isActive));
   } else {
-    constraints.push(where11("isActive", "==", true));
+    constraints.push(where12("isActive", "==", true));
   }
   if (filters.tags && filters.tags.length > 0) {
-    constraints.push(where11("tags", "array-contains", filters.tags[0]));
+    constraints.push(where12("tags", "array-contains", filters.tags[0]));
   }
   if (filters.procedureTechnology) {
     constraints.push(
-      where11("servicesInfo.technology", "==", filters.procedureTechnology)
+      where12("servicesInfo.technology", "==", filters.procedureTechnology)
     );
   } else if (filters.procedureSubcategory) {
     constraints.push(
-      where11("servicesInfo.subCategory", "==", filters.procedureSubcategory)
+      where12("servicesInfo.subCategory", "==", filters.procedureSubcategory)
     );
   } else if (filters.procedureCategory) {
     constraints.push(
-      where11("servicesInfo.category", "==", filters.procedureCategory)
+      where12("servicesInfo.category", "==", filters.procedureCategory)
     );
   } else if (filters.procedureFamily) {
     constraints.push(
-      where11("servicesInfo.procedureFamily", "==", filters.procedureFamily)
+      where12("servicesInfo.procedureFamily", "==", filters.procedureFamily)
     );
   }
   if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
     constraints.push(startAfter6(filters.lastDoc));
-    constraints.push(limit6(filters.pagination));
+    constraints.push(limit7(filters.pagination));
   } else if (filters.pagination && filters.pagination > 0) {
-    constraints.push(limit6(filters.pagination));
+    constraints.push(limit7(filters.pagination));
   }
-  constraints.push(orderBy2("location.geohash"));
+  constraints.push(orderBy3("location.geohash"));
   let clinicsResult = [];
   let lastVisibleDoc = null;
   if (isGeoQuery) {
@@ -6357,440 +6901,124 @@ async function getClinicsByFilters(db, filters) {
     const radiusInKm = filters.radiusInKm;
     const bounds = geohashQueryBounds3(
       [center.latitude, center.longitude],
-      radiusInKm * 1e3
-      // Convert to meters
-    );
-    const matchingClinics = [];
-    for (const bound of bounds) {
-      const geoConstraints = [
-        ...constraints,
-        where11("location.geohash", ">=", bound[0]),
-        where11("location.geohash", "<=", bound[1])
-      ];
-      const q = query11(collection11(db, CLINICS_COLLECTION), ...geoConstraints);
-      const querySnapshot = await getDocs11(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 = distanceBetween4(
-          [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 = query11(collection11(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await getDocs11(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 = distanceBetween4(
-          [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
-import { Timestamp as Timestamp13 } from "firebase/firestore";
-import {
-  ref as ref3,
-  uploadBytes as uploadBytes3,
-  getDownloadURL as getDownloadURL3,
-  deleteObject as deleteObject3,
-  getBytes
-} from "firebase/storage";
-import {
-  doc as doc12,
-  getDoc as getDoc15,
-  setDoc as setDoc11,
-  updateDoc as updateDoc12,
-  collection as collection12,
-  query as query12,
-  where as where12,
-  limit as limit7,
-  getDocs as getDocs12,
-  deleteDoc as deleteDoc6,
-  orderBy as orderBy3
-} from "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 = ref3(this.storage, filePath);
-    try {
-      const uploadResult = await uploadBytes3(storageRef, file, {
-        contentType: file.type
-      });
-      console.log("[MediaService] File uploaded successfully", uploadResult);
-      const downloadURL = await getDownloadURL3(uploadResult.ref);
-      console.log("[MediaService] Got download URL:", downloadURL);
-      const metadata = {
-        id: mediaId,
-        name: fileNameToUse,
-        url: downloadURL,
-        contentType: file.type,
-        size: file.size,
-        createdAt: Timestamp13.now(),
-        accessLevel,
-        ownerId,
-        collectionName,
-        path: filePath
-      };
-      const metadataDocRef = doc12(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await setDoc11(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 = doc12(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-    const docSnap = await getDoc15(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 = query12(
-      collection12(this.db, MEDIA_METADATA_COLLECTION),
-      where12("url", "==", url),
-      limit7(1)
+      radiusInKm * 1e3
+      // Convert to meters
     );
-    try {
+    const matchingClinics = [];
+    for (const bound of bounds) {
+      const geoConstraints = [
+        ...constraints,
+        where12("location.geohash", ">=", bound[0]),
+        where12("location.geohash", "<=", bound[1])
+      ];
+      const q = query12(collection12(db, CLINICS_COLLECTION), ...geoConstraints);
       const querySnapshot = await getDocs12(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 = distanceBetween4(
+          [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 = ref3(this.storage, metadata.path);
-    try {
-      await deleteObject3(storageFileRef);
-      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
-      const metadataDocRef = doc12(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await deleteDoc6(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 = doc12(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      try {
-        await updateDoc12(metadataDocRef, { updatedAt: Timestamp13.now() });
-        return { ...metadata, updatedAt: Timestamp13.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 = query12(collection12(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs12(q);
     console.log(
-      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
     );
-    const oldStorageFileRef = ref3(this.storage, oldStoragePath);
-    const newStorageFileRef = ref3(this.storage, newStoragePath);
-    try {
-      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
-      const fileBytes = await getBytes(oldStorageFileRef);
-      console.log(
-        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
-      );
-      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
-      await uploadBytes3(newStorageFileRef, fileBytes, {
-        contentType: metadata.contentType
-      });
-      console.log(
-        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
-      );
-      const newDownloadURL = await getDownloadURL3(newStorageFileRef);
-      console.log(
-        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
-      );
-      const updateData = {
-        accessLevel: newAccessLevel,
-        path: newStoragePath,
-        url: newDownloadURL,
-        updatedAt: Timestamp13.now()
-      };
-      const metadataDocRef = doc12(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      console.log(
-        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
-        updateData
-      );
-      await updateDoc12(metadataDocRef, updateData);
-      console.log(
-        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
-      );
-      try {
-        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
-        await deleteObject3(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 = distanceBetween4(
+          [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 deleteObject3(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 = [where12("ownerId", "==", ownerId)];
-    if (collectionName) {
-      qConstraints.push(where12("collectionName", "==", collectionName));
-    }
-    if (accessLevel) {
-      qConstraints.push(where12("accessLevel", "==", accessLevel));
     }
-    qConstraints.push(orderBy3("createdAt", "desc"));
-    if (count) {
-      qConstraints.push(limit7(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 = query12(
-      collection12(this.db, MEDIA_METADATA_COLLECTION),
-      ...qConstraints
-    );
-    try {
-      const querySnapshot = await getDocs12(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 {
@@ -8522,7 +8750,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 || []
     };
@@ -8656,7 +8885,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 || []
       };