@blackcode_sa/metaestetics-api 1.7.20 → 1.7.21

package/dist/index.js

@@ -1194,12 +1194,309 @@ var USER_ERRORS = {
 var import_zod16 = require("zod");
 
 // src/services/patient/patient.service.ts
-var import_firestore12 = require("firebase/firestore");
+var import_firestore14 = require("firebase/firestore");
 
-// src/services/patient/utils/profile.utils.ts
-var import_firestore8 = require("firebase/firestore");
+// src/services/media/media.service.ts
+var import_firestore2 = require("firebase/firestore");
 var import_storage3 = require("firebase/storage");
-var import_zod8 = require("zod");
+var import_firestore3 = require("firebase/firestore");
+var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
+  MediaAccessLevel2["PUBLIC"] = "public";
+  MediaAccessLevel2["PRIVATE"] = "private";
+  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
+  return MediaAccessLevel2;
+})(MediaAccessLevel || {});
+var MEDIA_METADATA_COLLECTION = "media_metadata";
+var MediaService = class extends BaseService {
+  constructor(db, auth, app) {
+    super(db, auth, app);
+  }
+  /**
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
+   */
+  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+    const storageRef = (0, import_storage3.ref)(this.storage, filePath);
+    try {
+      const uploadResult = await (0, import_storage3.uploadBytes)(storageRef, file, {
+        contentType: file.type
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await (0, import_storage3.getDownloadURL)(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+      const metadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: import_firestore2.Timestamp.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore3.setDoc)(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+      return metadata;
+    } catch (error) {
+      console.error("[MediaService] Error during media upload:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId) {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await (0, import_firestore3.getDoc)(docRef);
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data();
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url) {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = (0, import_firestore3.query)(
+      (0, import_firestore3.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      (0, import_firestore3.where)("url", "==", url),
+      (0, import_firestore3.limit)(1)
+    );
+    try {
+      const querySnapshot = await (0, import_firestore3.getDocs)(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data();
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
+      }
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
+    } catch (error) {
+      console.error("[MediaService] Error fetching metadata by URL:", error);
+      throw error;
+    }
+  }
+  /**
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
+   */
+  async deleteMedia(mediaId) {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
+      );
+      return;
+    }
+    const storageFileRef = (0, import_storage3.ref)(this.storage, metadata.path);
+    try {
+      await (0, import_storage3.deleteObject)(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore3.deleteDoc)(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+      );
+    } catch (error) {
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Update media access level. This involves moving the file in Firebase Storage
+   * to a new path reflecting the new access level, and updating its metadata.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata, or null if metadata not found.
+   */
+  async updateMediaAccessLevel(mediaId, newAccessLevel) {
+    var _a;
+    console.log(
+      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+    );
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+      );
+      return null;
+    }
+    if (metadata.accessLevel === newAccessLevel) {
+      console.log(
+        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
+      );
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      try {
+        await (0, import_firestore3.updateDoc)(metadataDocRef, { updatedAt: import_firestore2.Timestamp.now() });
+        return { ...metadata, updatedAt: import_firestore2.Timestamp.now() };
+      } catch (error) {
+        console.error(
+          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    const oldStoragePath = metadata.path;
+    const fileNamePart = `${metadata.id}-${metadata.name}`;
+    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+    console.log(
+      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+    );
+    const oldStorageFileRef = (0, import_storage3.ref)(this.storage, oldStoragePath);
+    const newStorageFileRef = (0, import_storage3.ref)(this.storage, newStoragePath);
+    try {
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await (0, import_storage3.getBytes)(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await (0, import_storage3.uploadBytes)(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await (0, import_storage3.getDownloadURL)(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
+      );
+      const updateData = {
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: import_firestore2.Timestamp.now()
+      };
+      const metadataDocRef = (0, import_firestore3.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
+      );
+      await (0, import_firestore3.updateDoc)(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await (0, import_storage3.deleteObject)(oldStorageFileRef);
+        console.log(
+          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
+        );
+      } catch (deleteError) {
+        console.error(
+          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
+          deleteError
+        );
+      }
+      return { ...metadata, ...updateData };
+    } catch (error) {
+      console.error(
+        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
+        error
+      );
+      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
+        console.warn(
+          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
+        );
+        try {
+          await (0, import_storage3.deleteObject)(newStorageFileRef);
+          console.warn(
+            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
+          );
+        } catch (cleanupError) {
+          console.error(
+            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
+            cleanupError
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
+   */
+  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints = [(0, import_firestore3.where)("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push((0, import_firestore3.where)("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push((0, import_firestore3.where)("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push((0, import_firestore3.orderBy)("createdAt", "desc"));
+    if (count) {
+      qConstraints.push((0, import_firestore3.limit)(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = (0, import_firestore3.query)(
+      (0, import_firestore3.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+    try {
+      const querySnapshot = await (0, import_firestore3.getDocs)(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc34) => doc34.data()
+      );
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
+    } catch (error) {
+      console.error("[MediaService] Error listing media:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
+   */
+  async getMediaDownloadUrl(mediaId) {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
+    }
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
+  }
+};
+
+// src/services/patient/utils/profile.utils.ts
+var import_firestore10 = require("firebase/firestore");
+var import_zod9 = require("zod");
 
 // src/types/patient/medical-info.types.ts
 var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
@@ -1228,11 +1525,19 @@ var Gender = /* @__PURE__ */ ((Gender2) => {
 })(Gender || {});
 
 // src/validations/patient.schema.ts
-var import_zod6 = require("zod");
-var import_firestore3 = require("firebase/firestore");
+var import_zod7 = require("zod");
+var import_firestore5 = require("firebase/firestore");
+
+// src/validations/media.schema.ts
+var import_zod4 = require("zod");
+var mediaResourceSchema = import_zod4.z.union([
+  import_zod4.z.string().url(),
+  import_zod4.z.instanceof(File),
+  import_zod4.z.instanceof(Blob)
+]);
 
 // src/validations/patient/medical-info.schema.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/types/patient/allergies.ts
 var AllergyType = /* @__PURE__ */ ((AllergyType2) => {
@@ -1321,80 +1626,80 @@ var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
 })(Contraindication || {});
 
 // src/validations/common.schema.ts
-var import_zod4 = require("zod");
-var import_firestore2 = require("firebase/firestore");
-var timestampSchema2 = import_zod4.z.union([
-  import_zod4.z.object({
-    seconds: import_zod4.z.number(),
-    nanoseconds: import_zod4.z.number()
+var import_zod5 = require("zod");
+var import_firestore4 = require("firebase/firestore");
+var timestampSchema2 = import_zod5.z.union([
+  import_zod5.z.object({
+    seconds: import_zod5.z.number(),
+    nanoseconds: import_zod5.z.number()
   }),
-  import_zod4.z.instanceof(import_firestore2.Timestamp)
+  import_zod5.z.instanceof(import_firestore4.Timestamp)
 ]).transform((data) => {
-  if (data instanceof import_firestore2.Timestamp) {
+  if (data instanceof import_firestore4.Timestamp) {
     return data;
   }
-  return new import_firestore2.Timestamp(data.seconds, data.nanoseconds);
+  return new import_firestore4.Timestamp(data.seconds, data.nanoseconds);
 });
 
 // src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = import_zod5.z.union([
-  import_zod5.z.nativeEnum(MedicationAllergySubtype),
-  import_zod5.z.nativeEnum(FoodAllergySubtype),
-  import_zod5.z.nativeEnum(EnvironmentalAllergySubtype),
-  import_zod5.z.nativeEnum(CosmeticAllergySubtype),
-  import_zod5.z.literal("other")
+var allergySubtypeSchema = import_zod6.z.union([
+  import_zod6.z.nativeEnum(MedicationAllergySubtype),
+  import_zod6.z.nativeEnum(FoodAllergySubtype),
+  import_zod6.z.nativeEnum(EnvironmentalAllergySubtype),
+  import_zod6.z.nativeEnum(CosmeticAllergySubtype),
+  import_zod6.z.literal("other")
 ]);
-var allergySchema = import_zod5.z.object({
-  type: import_zod5.z.nativeEnum(AllergyType),
+var allergySchema = import_zod6.z.object({
+  type: import_zod6.z.nativeEnum(AllergyType),
   subtype: allergySubtypeSchema,
-  name: import_zod5.z.string().optional().nullable(),
-  severity: import_zod5.z.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: import_zod5.z.string().optional().nullable(),
+  name: import_zod6.z.string().optional().nullable(),
+  severity: import_zod6.z.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: import_zod6.z.string().optional().nullable(),
   diagnosed: timestampSchema2.optional().nullable(),
-  notes: import_zod5.z.string().optional().nullable()
+  notes: import_zod6.z.string().optional().nullable()
 });
-var vitalStatsSchema = import_zod5.z.object({
-  height: import_zod5.z.number().positive().optional(),
-  weight: import_zod5.z.number().positive().optional(),
-  bloodType: import_zod5.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: import_zod5.z.object({
-    systolic: import_zod5.z.number().min(70).max(200),
-    diastolic: import_zod5.z.number().min(40).max(130),
+var vitalStatsSchema = import_zod6.z.object({
+  height: import_zod6.z.number().positive().optional(),
+  weight: import_zod6.z.number().positive().optional(),
+  bloodType: import_zod6.z.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: import_zod6.z.object({
+    systolic: import_zod6.z.number().min(70).max(200),
+    diastolic: import_zod6.z.number().min(40).max(130),
     lastMeasured: timestampSchema2
   }).optional()
 });
-var blockingConditionSchema = import_zod5.z.object({
-  condition: import_zod5.z.nativeEnum(BlockingCondition),
+var blockingConditionSchema = import_zod6.z.object({
+  condition: import_zod6.z.nativeEnum(BlockingCondition),
   diagnosedAt: timestampSchema2,
-  notes: import_zod5.z.string().optional().nullable(),
-  isActive: import_zod5.z.boolean()
+  notes: import_zod6.z.string().optional().nullable(),
+  isActive: import_zod6.z.boolean()
 });
-var contraindicationSchema = import_zod5.z.object({
-  condition: import_zod5.z.nativeEnum(Contraindication),
+var contraindicationSchema = import_zod6.z.object({
+  condition: import_zod6.z.nativeEnum(Contraindication),
   lastOccurrence: timestampSchema2,
-  frequency: import_zod5.z.enum(["rare", "occasional", "frequent"]),
-  notes: import_zod5.z.string().optional().nullable(),
-  isActive: import_zod5.z.boolean()
+  frequency: import_zod6.z.enum(["rare", "occasional", "frequent"]),
+  notes: import_zod6.z.string().optional().nullable(),
+  isActive: import_zod6.z.boolean()
 });
-var medicationSchema = import_zod5.z.object({
-  name: import_zod5.z.string().min(1),
-  dosage: import_zod5.z.string().min(1),
-  frequency: import_zod5.z.string().min(1),
+var medicationSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  dosage: import_zod6.z.string().min(1),
+  frequency: import_zod6.z.string().min(1),
   startDate: timestampSchema2.optional().nullable(),
   endDate: timestampSchema2.optional().nullable(),
-  prescribedBy: import_zod5.z.string().optional().nullable()
+  prescribedBy: import_zod6.z.string().optional().nullable()
 });
-var patientMedicalInfoSchema = import_zod5.z.object({
-  patientId: import_zod5.z.string(),
+var patientMedicalInfoSchema = import_zod6.z.object({
+  patientId: import_zod6.z.string(),
   vitalStats: vitalStatsSchema,
-  blockingConditions: import_zod5.z.array(blockingConditionSchema),
-  contraindications: import_zod5.z.array(contraindicationSchema),
-  allergies: import_zod5.z.array(allergySchema),
-  currentMedications: import_zod5.z.array(medicationSchema),
-  emergencyNotes: import_zod5.z.string().optional(),
+  blockingConditions: import_zod6.z.array(blockingConditionSchema),
+  contraindications: import_zod6.z.array(contraindicationSchema),
+  allergies: import_zod6.z.array(allergySchema),
+  currentMedications: import_zod6.z.array(medicationSchema),
+  emergencyNotes: import_zod6.z.string().optional(),
   lastUpdated: timestampSchema2,
-  updatedBy: import_zod5.z.string(),
-  verifiedBy: import_zod5.z.string().optional(),
+  updatedBy: import_zod6.z.string(),
+  verifiedBy: import_zod6.z.string().optional(),
   verifiedAt: timestampSchema2.optional()
 });
 var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
@@ -1408,141 +1713,140 @@ var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
 var updateVitalStatsSchema = vitalStatsSchema;
 var addAllergySchema = allergySchema;
 var updateAllergySchema = allergySchema.partial().extend({
-  allergyIndex: import_zod5.z.number().min(0)
+  allergyIndex: import_zod6.z.number().min(0)
 });
 var addBlockingConditionSchema = blockingConditionSchema;
 var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: import_zod5.z.number().min(0)
+  conditionIndex: import_zod6.z.number().min(0)
 });
 var addContraindicationSchema = contraindicationSchema;
 var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: import_zod5.z.number().min(0)
+  contraindicationIndex: import_zod6.z.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
 var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: import_zod5.z.number().min(0)
+  medicationIndex: import_zod6.z.number().min(0)
 });
 
 // src/validations/patient.schema.ts
-var locationDataSchema = import_zod6.z.object({
-  latitude: import_zod6.z.number().min(-90).max(90),
-  longitude: import_zod6.z.number().min(-180).max(180),
-  geohash: import_zod6.z.string().optional()
+var locationDataSchema = import_zod7.z.object({
+  latitude: import_zod7.z.number().min(-90).max(90),
+  longitude: import_zod7.z.number().min(-180).max(180),
+  geohash: import_zod7.z.string().optional()
 });
-var addressDataSchema = import_zod6.z.object({
-  address: import_zod6.z.string(),
-  city: import_zod6.z.string(),
-  country: import_zod6.z.string(),
-  postalCode: import_zod6.z.string()
+var addressDataSchema = import_zod7.z.object({
+  address: import_zod7.z.string(),
+  city: import_zod7.z.string(),
+  country: import_zod7.z.string(),
+  postalCode: import_zod7.z.string()
 });
-var emergencyContactSchema = import_zod6.z.object({
-  name: import_zod6.z.string(),
-  relationship: import_zod6.z.string(),
-  phoneNumber: import_zod6.z.string(),
-  isNotifiable: import_zod6.z.boolean()
+var emergencyContactSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  relationship: import_zod7.z.string(),
+  phoneNumber: import_zod7.z.string(),
+  isNotifiable: import_zod7.z.boolean()
 });
-var gamificationSchema = import_zod6.z.object({
-  level: import_zod6.z.number(),
-  points: import_zod6.z.number()
+var gamificationSchema = import_zod7.z.object({
+  level: import_zod7.z.number(),
+  points: import_zod7.z.number()
 });
-var patientLocationInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
+var patientLocationInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
   locationData: locationDataSchema,
-  createdAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  updatedAt: import_zod6.z.instanceof(import_firestore3.Timestamp)
+  createdAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore5.Timestamp)
 });
-var createPatientLocationInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
+var createPatientLocationInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
   locationData: locationDataSchema
 });
-var patientSensitiveInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  photoUrl: import_zod6.z.string().optional(),
-  firstName: import_zod6.z.string().min(2),
-  lastName: import_zod6.z.string().min(2),
-  dateOfBirth: import_zod6.z.instanceof(import_firestore3.Timestamp).nullable(),
-  gender: import_zod6.z.nativeEnum(Gender),
-  email: import_zod6.z.string().email().optional(),
-  phoneNumber: import_zod6.z.string().optional(),
-  alternativePhoneNumber: import_zod6.z.string().optional(),
+var patientSensitiveInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  firstName: import_zod7.z.string().min(2),
+  lastName: import_zod7.z.string().min(2),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore5.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  email: import_zod7.z.string().email().optional(),
+  phoneNumber: import_zod7.z.string().optional(),
+  alternativePhoneNumber: import_zod7.z.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod6.z.array(emergencyContactSchema).optional(),
-  createdAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  updatedAt: import_zod6.z.instanceof(import_firestore3.Timestamp)
+  emergencyContacts: import_zod7.z.array(emergencyContactSchema).optional(),
+  createdAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore5.Timestamp)
 });
-var patientDoctorSchema = import_zod6.z.object({
-  userRef: import_zod6.z.string(),
-  assignedAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  assignedBy: import_zod6.z.string().optional(),
-  isActive: import_zod6.z.boolean(),
-  notes: import_zod6.z.string().optional()
+var patientDoctorSchema = import_zod7.z.object({
+  userRef: import_zod7.z.string(),
+  assignedAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  assignedBy: import_zod7.z.string().optional(),
+  isActive: import_zod7.z.boolean(),
+  notes: import_zod7.z.string().optional()
 });
-var patientClinicSchema = import_zod6.z.object({
-  clinicId: import_zod6.z.string(),
-  assignedAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  assignedBy: import_zod6.z.string().optional(),
-  isActive: import_zod6.z.boolean(),
-  notes: import_zod6.z.string().optional()
+var patientClinicSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string(),
+  assignedAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  assignedBy: import_zod7.z.string().optional(),
+  isActive: import_zod7.z.boolean(),
+  notes: import_zod7.z.string().optional()
 });
-var patientProfileSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  displayName: import_zod6.z.string(),
-  profilePhoto: import_zod6.z.string().url().nullable(),
+var patientProfileSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  displayName: import_zod7.z.string(),
   gamification: gamificationSchema,
-  expoTokens: import_zod6.z.array(import_zod6.z.string()),
-  isActive: import_zod6.z.boolean(),
-  isVerified: import_zod6.z.boolean(),
-  doctors: import_zod6.z.array(patientDoctorSchema),
-  clinics: import_zod6.z.array(patientClinicSchema),
-  doctorIds: import_zod6.z.array(import_zod6.z.string()),
-  clinicIds: import_zod6.z.array(import_zod6.z.string()),
-  createdAt: import_zod6.z.instanceof(import_firestore3.Timestamp),
-  updatedAt: import_zod6.z.instanceof(import_firestore3.Timestamp)
+  expoTokens: import_zod7.z.array(import_zod7.z.string()),
+  isActive: import_zod7.z.boolean(),
+  isVerified: import_zod7.z.boolean(),
+  phoneNumber: import_zod7.z.string().nullable().optional(),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore5.Timestamp).nullable().optional(),
+  doctors: import_zod7.z.array(patientDoctorSchema),
+  clinics: import_zod7.z.array(patientClinicSchema),
+  doctorIds: import_zod7.z.array(import_zod7.z.string()),
+  clinicIds: import_zod7.z.array(import_zod7.z.string()),
+  createdAt: import_zod7.z.instanceof(import_firestore5.Timestamp),
+  updatedAt: import_zod7.z.instanceof(import_firestore5.Timestamp)
 });
-var createPatientProfileSchema = import_zod6.z.object({
-  userRef: import_zod6.z.string(),
-  displayName: import_zod6.z.string(),
-  profilePhoto: import_zod6.z.string().url().nullable().optional(),
-  expoTokens: import_zod6.z.array(import_zod6.z.string()),
+var createPatientProfileSchema = import_zod7.z.object({
+  userRef: import_zod7.z.string(),
+  displayName: import_zod7.z.string(),
+  expoTokens: import_zod7.z.array(import_zod7.z.string()),
   gamification: gamificationSchema.optional(),
-  isActive: import_zod6.z.boolean(),
-  isVerified: import_zod6.z.boolean(),
-  doctors: import_zod6.z.array(patientDoctorSchema).optional(),
-  clinics: import_zod6.z.array(patientClinicSchema).optional(),
-  doctorIds: import_zod6.z.array(import_zod6.z.string()).optional(),
-  clinicIds: import_zod6.z.array(import_zod6.z.string()).optional()
+  isActive: import_zod7.z.boolean(),
+  isVerified: import_zod7.z.boolean(),
+  doctors: import_zod7.z.array(patientDoctorSchema).optional(),
+  clinics: import_zod7.z.array(patientClinicSchema).optional(),
+  doctorIds: import_zod7.z.array(import_zod7.z.string()).optional(),
+  clinicIds: import_zod7.z.array(import_zod7.z.string()).optional()
 });
-var createPatientSensitiveInfoSchema = import_zod6.z.object({
-  patientId: import_zod6.z.string(),
-  userRef: import_zod6.z.string(),
-  photoUrl: import_zod6.z.string().optional(),
-  firstName: import_zod6.z.string().min(2),
-  lastName: import_zod6.z.string().min(2),
-  dateOfBirth: import_zod6.z.instanceof(import_firestore3.Timestamp).nullable(),
-  gender: import_zod6.z.nativeEnum(Gender),
-  email: import_zod6.z.string().email().optional(),
-  phoneNumber: import_zod6.z.string().optional(),
-  alternativePhoneNumber: import_zod6.z.string().optional(),
+var createPatientSensitiveInfoSchema = import_zod7.z.object({
+  patientId: import_zod7.z.string(),
+  userRef: import_zod7.z.string(),
+  photoUrl: mediaResourceSchema.nullable().optional(),
+  firstName: import_zod7.z.string().min(2),
+  lastName: import_zod7.z.string().min(2),
+  dateOfBirth: import_zod7.z.instanceof(import_firestore5.Timestamp).nullable(),
+  gender: import_zod7.z.nativeEnum(Gender),
+  email: import_zod7.z.string().email().optional(),
+  phoneNumber: import_zod7.z.string().optional(),
+  alternativePhoneNumber: import_zod7.z.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: import_zod6.z.array(emergencyContactSchema).optional()
+  emergencyContacts: import_zod7.z.array(emergencyContactSchema).optional()
 });
-var searchPatientsSchema = import_zod6.z.object({
-  clinicId: import_zod6.z.string().optional(),
-  practitionerId: import_zod6.z.string().optional()
+var searchPatientsSchema = import_zod7.z.object({
+  clinicId: import_zod7.z.string().optional(),
+  practitionerId: import_zod7.z.string().optional()
 }).refine((data) => data.clinicId || data.practitionerId, {
   message: "At least one of clinicId or practitionerId must be provided",
   path: []
   // Optional: specify a path like ['clinicId'] or ['practitionerId']
 });
-var requesterInfoSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  role: import_zod6.z.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: import_zod6.z.string().optional(),
-  associatedPractitionerId: import_zod6.z.string().optional()
+var requesterInfoSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  role: import_zod7.z.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: import_zod7.z.string().optional(),
+  associatedPractitionerId: import_zod7.z.string().optional()
 }).refine(
   (data) => {
     if (data.role === "clinic_admin") {
@@ -1559,36 +1863,68 @@ var requesterInfoSchema = import_zod6.z.object({
 );
 
 // src/services/patient/utils/docs.utils.ts
-var import_firestore5 = require("firebase/firestore");
+var import_firestore7 = require("firebase/firestore");
 
 // src/services/patient/utils/sensitive.utils.ts
-var import_firestore4 = require("firebase/firestore");
-var import_zod7 = require("zod");
-var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
+var import_firestore6 = require("firebase/firestore");
+var import_zod8 = require("zod");
+var handlePhotoUrlUpload = async (photoUrl, patientId, mediaService) => {
+  if (!photoUrl) {
+    return null;
+  }
+  if (typeof photoUrl === "string") {
+    return photoUrl;
+  }
+  if (photoUrl instanceof File || photoUrl instanceof Blob) {
+    const mediaMetadata = await mediaService.uploadMedia(
+      photoUrl,
+      patientId,
+      // Using patientId as ownerId
+      "private" /* PRIVATE */,
+      // Sensitive info should be private
+      "patient_sensitive_photos",
+      photoUrl instanceof File ? photoUrl.name : `sensitive_photo_${patientId}`
+    );
+    return mediaMetadata.url;
+  }
+  return null;
+};
+var createSensitiveInfoUtil = async (db, data, requesterUserId, mediaService) => {
   try {
     if (data.userRef !== requesterUserId) {
       throw new Error("Only patient can create their sensitive information");
     }
     const validatedData = createPatientSensitiveInfoSchema.parse(data);
-    const sensitiveDoc = await (0, import_firestore4.getDoc)(
+    const sensitiveDoc = await (0, import_firestore6.getDoc)(
       getSensitiveInfoDocRef(db, data.patientId)
     );
     if (sensitiveDoc.exists()) {
       throw new Error("Sensitive information already exists for this patient");
     }
+    let processedPhotoUrl = null;
+    if (validatedData.photoUrl && mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        validatedData.photoUrl,
+        data.patientId,
+        mediaService
+      );
+    } else if (typeof validatedData.photoUrl === "string") {
+      processedPhotoUrl = validatedData.photoUrl;
+    }
     const sensitiveInfoData = {
       ...validatedData,
-      createdAt: (0, import_firestore4.serverTimestamp)(),
-      updatedAt: (0, import_firestore4.serverTimestamp)()
+      photoUrl: processedPhotoUrl,
+      createdAt: (0, import_firestore6.serverTimestamp)(),
+      updatedAt: (0, import_firestore6.serverTimestamp)()
     };
-    await (0, import_firestore4.setDoc)(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
-    const createdDoc = await (0, import_firestore4.getDoc)(getSensitiveInfoDocRef(db, data.patientId));
+    await (0, import_firestore6.setDoc)(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
+    const createdDoc = await (0, import_firestore6.getDoc)(getSensitiveInfoDocRef(db, data.patientId));
     if (!createdDoc.exists()) {
       throw new Error("Failed to create sensitive information");
     }
     return createdDoc.data();
   } catch (error) {
-    if (error instanceof import_zod7.z.ZodError) {
+    if (error instanceof import_zod8.z.ZodError) {
       throw new Error("Invalid sensitive info data: " + error.message);
     }
     throw error;
@@ -1596,17 +1932,32 @@ var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
 };
 var getSensitiveInfoUtil = async (db, patientId, requesterUserId) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
-  const sensitiveDoc = await (0, import_firestore4.getDoc)(getSensitiveInfoDocRef(db, patientId));
+  const sensitiveDoc = await (0, import_firestore6.getDoc)(getSensitiveInfoDocRef(db, patientId));
   return sensitiveDoc.exists() ? sensitiveDoc.data() : null;
 };
-var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
+var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId, mediaService) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
+  let processedPhotoUrl = void 0;
+  if (data.photoUrl !== void 0) {
+    if (mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        data.photoUrl,
+        patientId,
+        mediaService
+      );
+    } else if (typeof data.photoUrl === "string" || data.photoUrl === null) {
+      processedPhotoUrl = data.photoUrl;
+    } else {
+      throw new Error("MediaService required to process photo upload");
+    }
+  }
   const updateData = {
     ...data,
-    updatedAt: (0, import_firestore4.serverTimestamp)()
+    photoUrl: processedPhotoUrl,
+    updatedAt: (0, import_firestore6.serverTimestamp)()
   };
-  await (0, import_firestore4.updateDoc)(getSensitiveInfoDocRef(db, patientId), updateData);
-  const updatedDoc = await (0, import_firestore4.getDoc)(getSensitiveInfoDocRef(db, patientId));
+  await (0, import_firestore6.updateDoc)(getSensitiveInfoDocRef(db, patientId), updateData);
+  const updatedDoc = await (0, import_firestore6.getDoc)(getSensitiveInfoDocRef(db, patientId));
   if (!updatedDoc.exists()) {
     throw new Error("Failed to retrieve updated sensitive information");
   }
@@ -1615,21 +1966,21 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
 
 // src/services/patient/utils/docs.utils.ts
 var getPatientDocRef = (db, patientId) => {
-  return (0, import_firestore5.doc)(db, PATIENTS_COLLECTION, patientId);
+  return (0, import_firestore7.doc)(db, PATIENTS_COLLECTION, patientId);
 };
 var getPatientDocRefByUserRef = async (db, userRef) => {
-  const patientsRef = (0, import_firestore5.collection)(db, PATIENTS_COLLECTION);
-  const q = (0, import_firestore5.query)(patientsRef, (0, import_firestore5.where)("userRef", "==", userRef));
-  const querySnapshot = await (0, import_firestore5.getDocs)(q);
+  const patientsRef = (0, import_firestore7.collection)(db, PATIENTS_COLLECTION);
+  const q = (0, import_firestore7.query)(patientsRef, (0, import_firestore7.where)("userRef", "==", userRef));
+  const querySnapshot = await (0, import_firestore7.getDocs)(q);
   if (querySnapshot.empty) {
     throw new Error("Patient profile not found");
   }
-  return (0, import_firestore5.doc)(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
+  return (0, import_firestore7.doc)(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
 };
 var getSensitiveInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_SENSITIVE_INFO_COLLECTION}/${patientId}`;
   console.log(`[getSensitiveInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore5.doc)(
+  return (0, import_firestore7.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1640,7 +1991,7 @@ var getSensitiveInfoDocRef = (db, patientId) => {
 var getLocationInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_LOCATION_INFO_COLLECTION}/${patientId}`;
   console.log(`[getLocationInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore5.doc)(
+  return (0, import_firestore7.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1651,7 +2002,7 @@ var getLocationInfoDocRef = (db, patientId) => {
 var getMedicalInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_MEDICAL_INFO_COLLECTION}/${patientId}`;
   console.log(`[getMedicalInfoDocRef] Creating reference with path: ${path}`);
-  return (0, import_firestore5.doc)(
+  return (0, import_firestore7.doc)(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1668,7 +2019,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
     console.log(
       `[initSensitiveInfoDocIfNotExists] Got document reference: ${sensitiveInfoRef.path}`
     );
-    const sensitiveDoc = await (0, import_firestore5.getDoc)(sensitiveInfoRef);
+    const sensitiveDoc = await (0, import_firestore7.getDoc)(sensitiveInfoRef);
     console.log(
       `[initSensitiveInfoDocIfNotExists] Document exists: ${sensitiveDoc.exists()}`
     );
@@ -1692,7 +2043,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
         )
       );
       await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef);
-      const verifyDoc = await (0, import_firestore5.getDoc)(sensitiveInfoRef);
+      const verifyDoc = await (0, import_firestore7.getDoc)(sensitiveInfoRef);
       console.log(
         `[initSensitiveInfoDocIfNotExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1709,10 +2060,10 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
 };
 
 // src/services/patient/utils/medical.utils.ts
-var import_firestore7 = require("firebase/firestore");
+var import_firestore9 = require("firebase/firestore");
 
 // src/services/patient/utils/practitioner.utils.ts
-var import_firestore6 = require("firebase/firestore");
+var import_firestore8 = require("firebase/firestore");
 
 // src/types/practitioner/index.ts
 var PRACTITIONERS_COLLECTION = "practitioners";
@@ -1737,23 +2088,23 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
       `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore6.collection)(db, PATIENTS_COLLECTION);
+    const patientsCollection = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
     const constraints = [
-      (0, import_firestore6.where)("doctorIds", "array-contains", practitionerId)
+      (0, import_firestore8.where)("doctorIds", "array-contains", practitionerId)
     ];
-    let q = (0, import_firestore6.query)(patientsCollection, ...constraints);
+    let q = (0, import_firestore8.query)(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore6.query)(q, (0, import_firestore6.limit)(options.limit));
+      q = (0, import_firestore8.query)(q, (0, import_firestore8.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore6.getDoc)(
-        (0, import_firestore6.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore8.getDoc)(
+        (0, import_firestore8.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore6.query)(q, (0, import_firestore6.startAfter)(startAfterDoc));
+        q = (0, import_firestore8.query)(q, (0, import_firestore8.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore6.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore8.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -1786,7 +2137,7 @@ var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, option
     const patientProfilesWithDetails = await Promise.all(
       patientProfiles.map(async (profile) => {
         try {
-          const sensitiveInfoDoc = await (0, import_firestore6.getDoc)(
+          const sensitiveInfoDoc = await (0, import_firestore8.getDoc)(
             getSensitiveInfoDocRef(db, profile.id)
           );
           const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
@@ -1822,13 +2173,13 @@ var getPractitionerProfileByUserRef = async (db, userRef) => {
     console.log(
       `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
     );
-    const practitionersCollection = (0, import_firestore6.collection)(db, PRACTITIONERS_COLLECTION);
-    const q = (0, import_firestore6.query)(
+    const practitionersCollection = (0, import_firestore8.collection)(db, PRACTITIONERS_COLLECTION);
+    const q = (0, import_firestore8.query)(
       practitionersCollection,
-      (0, import_firestore6.where)("userRef", "==", userRef),
-      (0, import_firestore6.limit)(1)
+      (0, import_firestore8.where)("userRef", "==", userRef),
+      (0, import_firestore8.limit)(1)
     );
-    const querySnapshot = await (0, import_firestore6.getDocs)(q);
+    const querySnapshot = await (0, import_firestore8.getDocs)(q);
     if (querySnapshot.empty) {
       console.log(
         `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
@@ -1862,7 +2213,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
     console.log(
       `[ensureMedicalInfoExists] Got document reference: ${medicalInfoRef.path}`
     );
-    const medicalInfoDoc = await (0, import_firestore7.getDoc)(medicalInfoRef);
+    const medicalInfoDoc = await (0, import_firestore9.getDoc)(medicalInfoRef);
     console.log(
       `[ensureMedicalInfoExists] Document exists: ${medicalInfoDoc.exists()}`
     );
@@ -1870,7 +2221,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
       const defaultData = {
         ...DEFAULT_MEDICAL_INFO,
         patientId,
-        lastUpdated: (0, import_firestore7.serverTimestamp)(),
+        lastUpdated: (0, import_firestore9.serverTimestamp)(),
         updatedBy: userRef
       };
       console.log(
@@ -1880,9 +2231,9 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
           (key, value) => value && typeof value === "object" && value.constructor && value.constructor.name === "Object" ? "[serverTimestamp]" : value
         )
       );
-      await (0, import_firestore7.setDoc)(medicalInfoRef, defaultData);
+      await (0, import_firestore9.setDoc)(medicalInfoRef, defaultData);
       console.log(`[ensureMedicalInfoExists] Document created successfully`);
-      const verifyDoc = await (0, import_firestore7.getDoc)(medicalInfoRef);
+      const verifyDoc = await (0, import_firestore9.getDoc)(medicalInfoRef);
       console.log(
         `[ensureMedicalInfoExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1898,7 +2249,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
 };
 var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
   var _a;
-  const patientDoc = await (0, import_firestore7.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore9.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) {
     throw new Error("Patient profile not found");
   }
@@ -1931,17 +2282,17 @@ var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
 var createMedicalInfoUtil = async (db, patientId, data, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const validatedData = createPatientMedicalInfoSchema.parse(data);
-  await (0, import_firestore7.setDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.setDoc)(getMedicalInfoDocRef(db, patientId), {
     ...validatedData,
     patientId,
-    lastUpdated: import_firestore7.Timestamp.now(),
+    lastUpdated: import_firestore9.Timestamp.now(),
     updatedBy: userRef
   });
 };
 var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const docRef = getMedicalInfoDocRef(db, patientId);
-  const snapshot = await (0, import_firestore7.getDoc)(docRef);
+  const snapshot = await (0, import_firestore9.getDoc)(docRef);
   if (!snapshot.exists()) {
     throw new Error("Medicinske informacije nisu prona\u0111ene");
   }
@@ -1950,25 +2301,25 @@ var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
 var updateVitalStatsUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = updateVitalStatsSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     vitalStats: validatedData,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addAllergyUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addAllergySchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    allergies: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    allergies: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const docSnapshot = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const docSnapshot = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!docSnapshot.exists()) throw new Error("Medical info not found");
   const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1979,14 +2330,14 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
     ...updatedAllergies[allergyIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1995,25 +2346,25 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
   const updatedAllergies = medicalInfo.allergies.filter(
     (_, index) => index !== allergyIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addBlockingConditionSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    blockingConditions: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    blockingConditions: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -2024,14 +2375,14 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
     ...updatedConditions[conditionIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -2040,25 +2391,25 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef)
   const updatedConditions = medicalInfo.blockingConditions.filter(
     (_, index) => index !== conditionIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addContraindicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addContraindicationSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    contraindications: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    contraindications: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -2069,14 +2420,14 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
     ...updatedContraindications[contraindicationIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -2085,25 +2436,25 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, us
   const updatedContraindications = medicalInfo.contraindications.filter(
     (_, index) => index !== contraindicationIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var addMedicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addMedicationSchema.parse(data);
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
-    currentMedications: (0, import_firestore7.arrayUnion)(validatedData),
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+    currentMedications: (0, import_firestore9.arrayUnion)(validatedData),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -2114,14 +2465,14 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
     ...updatedMedications[medicationIndex],
     ...updateData
   };
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc34 = await (0, import_firestore7.getDoc)(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await (0, import_firestore9.getDoc)(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -2130,9 +2481,9 @@ var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
   const updatedMedications = medicalInfo.currentMedications.filter(
     (_, index) => index !== medicationIndex
   );
-  await (0, import_firestore7.updateDoc)(getMedicalInfoDocRef(db, patientId), {
+  await (0, import_firestore9.updateDoc)(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
-    lastUpdated: (0, import_firestore7.serverTimestamp)(),
+    lastUpdated: (0, import_firestore9.serverTimestamp)(),
     updatedBy: userRef
   });
 };
@@ -2149,7 +2500,6 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       id: patientId,
       userRef: validatedData.userRef,
       displayName: validatedData.displayName,
-      profilePhoto: validatedData.profilePhoto || null,
       expoTokens: validatedData.expoTokens,
       gamification: validatedData.gamification || {
         level: 1,
@@ -2161,15 +2511,15 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       clinics: validatedData.clinics || [],
       doctorIds: ((_a = validatedData.doctors) == null ? void 0 : _a.map((d) => d.userRef)) || [],
       clinicIds: ((_b = validatedData.clinics) == null ? void 0 : _b.map((c) => c.clinicId)) || [],
-      createdAt: (0, import_firestore8.serverTimestamp)(),
-      updatedAt: (0, import_firestore8.serverTimestamp)()
+      createdAt: (0, import_firestore10.serverTimestamp)(),
+      updatedAt: (0, import_firestore10.serverTimestamp)()
     };
     patientProfileSchema.parse({
       ...patientData,
-      createdAt: import_firestore8.Timestamp.now(),
-      updatedAt: import_firestore8.Timestamp.now()
+      createdAt: import_firestore10.Timestamp.now(),
+      updatedAt: import_firestore10.Timestamp.now()
     });
-    await (0, import_firestore8.setDoc)(getPatientDocRef(db, patientId), patientData);
+    await (0, import_firestore10.setDoc)(getPatientDocRef(db, patientId), patientData);
     console.log(`[createPatientProfileUtil] Creating sensitive info document`);
     let sensitiveInfoSuccess = false;
     try {
@@ -2183,81 +2533,103 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       );
       sensitiveInfoSuccess = true;
     } catch (sensitiveError) {
-      console.error(`[createPatientProfileUtil] Error creating sensitive info:`, sensitiveError);
+      console.error(
+        `[createPatientProfileUtil] Error creating sensitive info:`,
+        sensitiveError
+      );
     }
     console.log(`[createPatientProfileUtil] Creating medical info document`);
     let medicalInfoSuccess = false;
     try {
       await ensureMedicalInfoExists(db, patientId, validatedData.userRef);
-      console.log(`[createPatientProfileUtil] Medical info document created successfully`);
+      console.log(
+        `[createPatientProfileUtil] Medical info document created successfully`
+      );
       medicalInfoSuccess = true;
     } catch (medicalError) {
-      console.error(`[createPatientProfileUtil] Error creating medical info:`, medicalError);
+      console.error(
+        `[createPatientProfileUtil] Error creating medical info:`,
+        medicalError
+      );
     }
     if (!sensitiveInfoSuccess || !medicalInfoSuccess) {
-      console.log(`[createPatientProfileUtil] Using fallback method to create documents`);
+      console.log(
+        `[createPatientProfileUtil] Using fallback method to create documents`
+      );
       try {
         await testCreateSubDocuments(db, patientId, validatedData.userRef);
-        console.log(`[createPatientProfileUtil] Fallback method completed successfully`);
+        console.log(
+          `[createPatientProfileUtil] Fallback method completed successfully`
+        );
       } catch (fallbackError) {
-        console.error(`[createPatientProfileUtil] Fallback method failed:`, fallbackError);
+        console.error(
+          `[createPatientProfileUtil] Fallback method failed:`,
+          fallbackError
+        );
       }
     }
     console.log(`[createPatientProfileUtil] Verifying patient document exists`);
-    const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
+    const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
     if (!patientDoc.exists()) {
-      console.error(`[createPatientProfileUtil] Patient document not found after creation`);
+      console.error(
+        `[createPatientProfileUtil] Patient document not found after creation`
+      );
       throw new Error("Failed to create patient profile");
     }
-    console.log(`[createPatientProfileUtil] Patient profile creation completed successfully`);
+    console.log(
+      `[createPatientProfileUtil] Patient profile creation completed successfully`
+    );
     return patientDoc.data();
   } catch (error) {
-    console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
-    if (error instanceof import_zod8.z.ZodError) {
+    console.error(
+      `[createPatientProfileUtil] Error in patient profile creation:`,
+      error
+    );
+    if (error instanceof import_zod9.z.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
   }
 };
 var getPatientProfileUtil = async (db, patientId) => {
-  const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? patientDoc.data() : null;
 };
 var getPatientProfileByUserRefUtil = async (db, userRef) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await (0, import_firestore8.getDoc)(docRef);
+    const patientDoc = await (0, import_firestore10.getDoc)(docRef);
     return patientDoc.exists() ? patientDoc.data() : null;
   } catch (error) {
     return null;
   }
 };
 var addExpoTokenUtil = async (db, patientId, token) => {
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    expoTokens: (0, import_firestore8.arrayUnion)(token),
-    updatedAt: (0, import_firestore8.serverTimestamp)()
+  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), {
+    expoTokens: (0, import_firestore10.arrayUnion)(token),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   });
 };
 var removeExpoTokenUtil = async (db, patientId, token) => {
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    expoTokens: (0, import_firestore8.arrayRemove)(token),
-    updatedAt: (0, import_firestore8.serverTimestamp)()
+  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), {
+    expoTokens: (0, import_firestore10.arrayRemove)(token),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   });
 };
 var addPointsUtil = async (db, patientId, points) => {
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    "gamification.points": (0, import_firestore8.increment)(points),
-    updatedAt: (0, import_firestore8.serverTimestamp)()
+  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), {
+    "gamification.points": (0, import_firestore10.increment)(points),
+    updatedAt: (0, import_firestore10.serverTimestamp)()
   });
 };
 var updatePatientProfileUtil = async (db, patientId, data) => {
   try {
     const updateData = {
       ...data,
-      updatedAt: (0, import_firestore8.serverTimestamp)()
+      updatedAt: (0, import_firestore10.serverTimestamp)()
     };
-    await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), updateData);
-    const updatedDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
+    await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), updateData);
+    const updatedDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
       throw new Error("Patient profile not found after update");
     }
@@ -2270,7 +2642,7 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
 var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await (0, import_firestore8.getDoc)(docRef);
+    const patientDoc = await (0, import_firestore10.getDoc)(docRef);
     if (!patientDoc.exists()) {
       throw new Error("Patient profile not found");
     }
@@ -2278,49 +2650,10 @@ var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
     return updatePatientProfileUtil(db, patientData.id, data);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to update patient profile by user ref: ${errorMessage}`);
-  }
-};
-var uploadProfilePhotoUtil = async (storage, patientId, file) => {
-  const photoRef = (0, import_storage3.ref)(storage, `patient-photos/${patientId}/profile-photo`);
-  await (0, import_storage3.uploadBytes)(photoRef, file);
-  return (0, import_storage3.getDownloadURL)(photoRef);
-};
-var updateProfilePhotoUtil = async (storage, db, patientId, file) => {
-  const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const oldPhotoRef = (0, import_storage3.ref)(storage, patientData.profilePhoto);
-      await (0, import_storage3.deleteObject)(oldPhotoRef);
-    } catch (error) {
-      console.warn("Failed to delete old profile photo:", error);
-    }
-  }
-  const newPhotoUrl = await uploadProfilePhotoUtil(storage, patientId, file);
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    profilePhoto: newPhotoUrl,
-    updatedAt: (0, import_firestore8.serverTimestamp)()
-  });
-  return newPhotoUrl;
-};
-var deleteProfilePhotoUtil = async (storage, db, patientId) => {
-  const patientDoc = await (0, import_firestore8.getDoc)(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const photoRef = (0, import_storage3.ref)(storage, patientData.profilePhoto);
-      await (0, import_storage3.deleteObject)(photoRef);
-    } catch (error) {
-      console.warn("Failed to delete profile photo:", error);
-    }
+    throw new Error(
+      `Failed to update patient profile by user ref: ${errorMessage}`
+    );
   }
-  await (0, import_firestore8.updateDoc)(getPatientDocRef(db, patientId), {
-    profilePhoto: null,
-    updatedAt: (0, import_firestore8.serverTimestamp)()
-  });
 };
 var testCreateSubDocuments = async (db, patientId, userRef) => {
   console.log(
@@ -2329,33 +2662,41 @@ var testCreateSubDocuments = async (db, patientId, userRef) => {
   try {
     console.log(`[testCreateSubDocuments] Testing sensitive info creation`);
     const sensitiveInfoRef = getSensitiveInfoDocRef(db, patientId);
-    console.log(`[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`);
+    console.log(
+      `[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`
+    );
     const defaultSensitiveInfo = {
       patientId,
       userRef,
       photoUrl: "",
       firstName: "Name",
       lastName: "Surname",
-      dateOfBirth: import_firestore8.Timestamp.now(),
+      dateOfBirth: import_firestore10.Timestamp.now(),
       gender: "prefer_not_to_say" /* PREFER_NOT_TO_SAY */,
       email: "test@example.com",
       phoneNumber: "",
-      createdAt: import_firestore8.Timestamp.now(),
-      updatedAt: import_firestore8.Timestamp.now()
+      createdAt: import_firestore10.Timestamp.now(),
+      updatedAt: import_firestore10.Timestamp.now()
     };
-    await (0, import_firestore8.setDoc)(sensitiveInfoRef, defaultSensitiveInfo);
-    console.log(`[testCreateSubDocuments] Sensitive info document created directly`);
+    await (0, import_firestore10.setDoc)(sensitiveInfoRef, defaultSensitiveInfo);
+    console.log(
+      `[testCreateSubDocuments] Sensitive info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Testing medical info creation`);
     const medicalInfoRef = getMedicalInfoDocRef(db, patientId);
-    console.log(`[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`);
+    console.log(
+      `[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`
+    );
     const defaultMedicalInfo = {
       ...DEFAULT_MEDICAL_INFO,
       patientId,
-      lastUpdated: import_firestore8.Timestamp.now(),
+      lastUpdated: import_firestore10.Timestamp.now(),
       updatedBy: userRef
     };
-    await (0, import_firestore8.setDoc)(medicalInfoRef, defaultMedicalInfo);
-    console.log(`[testCreateSubDocuments] Medical info document created directly`);
+    await (0, import_firestore10.setDoc)(medicalInfoRef, defaultMedicalInfo);
+    console.log(
+      `[testCreateSubDocuments] Medical info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Test completed successfully`);
   } catch (error) {
     console.error(`[testCreateSubDocuments] Error:`, error);
@@ -2366,10 +2707,12 @@ var searchPatientsUtil = async (db, params, requester) => {
   searchPatientsSchema.parse(params);
   requesterInfoSchema.parse(requester);
   const constraints = [];
-  const patientsCollectionRef = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
+  const patientsCollectionRef = (0, import_firestore10.collection)(db, PATIENTS_COLLECTION);
   if (requester.role === "clinic_admin") {
     if (!requester.associatedClinicId) {
-      throw new Error("Associated clinic ID is required for clinic admin search.");
+      throw new Error(
+        "Associated clinic ID is required for clinic admin search."
+      );
     }
     if (params.clinicId && params.clinicId !== requester.associatedClinicId) {
       console.warn(
@@ -2377,13 +2720,19 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push((0, import_firestore8.where)("clinicIds", "array-contains", requester.associatedClinicId));
+    constraints.push(
+      (0, import_firestore10.where)("clinicIds", "array-contains", requester.associatedClinicId)
+    );
     if (params.practitionerId) {
-      constraints.push((0, import_firestore8.where)("doctorIds", "array-contains", params.practitionerId));
+      constraints.push(
+        (0, import_firestore10.where)("doctorIds", "array-contains", params.practitionerId)
+      );
     }
   } else if (requester.role === "practitioner") {
     if (!requester.associatedPractitionerId) {
-      throw new Error("Associated practitioner ID is required for practitioner search.");
+      throw new Error(
+        "Associated practitioner ID is required for practitioner search."
+      );
     }
     if (params.practitionerId && params.practitionerId !== requester.associatedPractitionerId) {
       console.warn(
@@ -2391,18 +2740,24 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push((0, import_firestore8.where)("doctorIds", "array-contains", requester.associatedPractitionerId));
+    constraints.push(
+      (0, import_firestore10.where)("doctorIds", "array-contains", requester.associatedPractitionerId)
+    );
     if (params.clinicId) {
-      constraints.push((0, import_firestore8.where)("clinicIds", "array-contains", params.clinicId));
+      constraints.push((0, import_firestore10.where)("clinicIds", "array-contains", params.clinicId));
     }
   } else {
     throw new Error("Invalid requester role.");
   }
   try {
-    const finalQuery = (0, import_firestore8.query)(patientsCollectionRef, ...constraints);
-    const querySnapshot = await (0, import_firestore8.getDocs)(finalQuery);
-    const patients = querySnapshot.docs.map((doc34) => doc34.data());
-    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
+    const finalQuery = (0, import_firestore10.query)(patientsCollectionRef, ...constraints);
+    const querySnapshot = await (0, import_firestore10.getDocs)(finalQuery);
+    const patients = querySnapshot.docs.map(
+      (doc34) => doc34.data()
+    );
+    console.log(
+      `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
+    );
     return patients;
   } catch (error) {
     console.error("[searchPatientsUtil] Error searching patients:", error);
@@ -2411,19 +2766,24 @@ var searchPatientsUtil = async (db, params, requester) => {
 };
 var getAllPatientsUtil = async (db, options) => {
   try {
-    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
-    const patientsCollection = (0, import_firestore8.collection)(db, PATIENTS_COLLECTION);
-    let q = (0, import_firestore8.query)(patientsCollection);
+    console.log(
+      `[getAllPatientsUtil] Fetching patients with options:`,
+      options
+    );
+    const patientsCollection = (0, import_firestore10.collection)(db, PATIENTS_COLLECTION);
+    let q = (0, import_firestore10.query)(patientsCollection);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore8.query)(q, (0, import_firestore8.limit)(options.limit));
+      q = (0, import_firestore10.query)(q, (0, import_firestore10.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore8.getDoc)((0, import_firestore8.doc)(db, PATIENTS_COLLECTION, options.startAfter));
+      const startAfterDoc = await (0, import_firestore10.getDoc)(
+        (0, import_firestore10.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore8.query)(q, (0, import_firestore8.startAfter)(startAfterDoc));
+        q = (0, import_firestore10.query)(q, (0, import_firestore10.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore8.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore10.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2439,8 +2799,8 @@ var getAllPatientsUtil = async (db, options) => {
 };
 
 // src/services/patient/utils/location.utils.ts
-var import_firestore9 = require("firebase/firestore");
-var import_zod9 = require("zod");
+var import_firestore11 = require("firebase/firestore");
+var import_zod10 = require("zod");
 var import_geofire_common = require("geofire-common");
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -2450,9 +2810,9 @@ var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   };
   const updateData = {
     locationData,
-    updatedAt: (0, import_firestore9.serverTimestamp)()
+    updatedAt: (0, import_firestore11.serverTimestamp)()
   };
-  await (0, import_firestore9.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
+  await (0, import_firestore11.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
 };
 var createLocationInfoUtil = async (db, data, requesterId) => {
   try {
@@ -2469,17 +2829,17 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
           validatedData.locationData.longitude
         ])
       },
-      createdAt: (0, import_firestore9.serverTimestamp)(),
-      updatedAt: (0, import_firestore9.serverTimestamp)()
+      createdAt: (0, import_firestore11.serverTimestamp)(),
+      updatedAt: (0, import_firestore11.serverTimestamp)()
     };
-    await (0, import_firestore9.setDoc)(getLocationInfoDocRef(db, data.patientId), locationData);
-    const locationDoc = await (0, import_firestore9.getDoc)(getLocationInfoDocRef(db, data.patientId));
+    await (0, import_firestore11.setDoc)(getLocationInfoDocRef(db, data.patientId), locationData);
+    const locationDoc = await (0, import_firestore11.getDoc)(getLocationInfoDocRef(db, data.patientId));
     if (!locationDoc.exists()) {
       throw new Error("Failed to create location information");
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof import_zod9.z.ZodError) {
+    if (error instanceof import_zod10.z.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -2489,7 +2849,7 @@ var getLocationInfoUtil = async (db, patientId, requesterId) => {
   if (patientId !== requesterId) {
     throw new Error("Unauthorized access to location information");
   }
-  const locationDoc = await (0, import_firestore9.getDoc)(getLocationInfoDocRef(db, patientId));
+  const locationDoc = await (0, import_firestore11.getDoc)(getLocationInfoDocRef(db, patientId));
   return locationDoc.exists() ? locationDoc.data() : null;
 };
 var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
@@ -2506,8 +2866,8 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
       ])
     };
   }
-  updateData.updatedAt = (0, import_firestore9.serverTimestamp)();
-  await (0, import_firestore9.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
+  updateData.updatedAt = (0, import_firestore11.serverTimestamp)();
+  await (0, import_firestore11.updateDoc)(getLocationInfoDocRef(db, patientId), updateData);
   const updatedInfo = await getLocationInfoUtil(db, patientId, requesterId);
   if (!updatedInfo) {
     throw new Error("Failed to retrieve updated location information");
@@ -2516,127 +2876,127 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
 };
 
 // src/services/patient/utils/medical-stuff.utils.ts
-var import_firestore10 = require("firebase/firestore");
+var import_firestore12 = require("firebase/firestore");
 var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
   var _a;
   const newDoctor = {
     userRef: doctorRef,
-    assignedAt: import_firestore10.Timestamp.now(),
+    assignedAt: import_firestore12.Timestamp.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore12.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingDoctorIndex = (_a = patientData.doctors) == null ? void 0 : _a.findIndex(
     (d) => d.userRef === doctorRef
   );
   const updates = {
-    updatedAt: (0, import_firestore10.serverTimestamp)(),
-    doctorIds: (0, import_firestore10.arrayUnion)(doctorRef)
+    updatedAt: (0, import_firestore12.serverTimestamp)(),
+    doctorIds: (0, import_firestore12.arrayUnion)(doctorRef)
   };
   if (existingDoctorIndex !== void 0 && existingDoctorIndex > -1) {
     const updatedDoctors = [...patientData.doctors];
     updatedDoctors[existingDoctorIndex] = {
       ...updatedDoctors[existingDoctorIndex],
       isActive: true,
-      assignedAt: import_firestore10.Timestamp.now(),
+      assignedAt: import_firestore12.Timestamp.now(),
       assignedBy
     };
     updates.doctors = updatedDoctors;
   } else {
-    updates.doctors = (0, import_firestore10.arrayUnion)(newDoctor);
+    updates.doctors = (0, import_firestore12.arrayUnion)(newDoctor);
   }
-  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), updates);
+  await (0, import_firestore12.updateDoc)(getPatientDocRef(db, patientId), updates);
 };
 var removeDoctorUtil = async (db, patientId, doctorRef) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await (0, import_firestore10.getDoc)(patientDocRef);
+  const patientDoc = await (0, import_firestore12.getDoc)(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedDoctors = ((_a = patientData.doctors) == null ? void 0 : _a.filter((doctor) => doctor.userRef !== doctorRef)) || [];
-  await (0, import_firestore10.updateDoc)(patientDocRef, {
+  await (0, import_firestore12.updateDoc)(patientDocRef, {
     doctors: updatedDoctors,
     // Set the filtered array
-    doctorIds: (0, import_firestore10.arrayRemove)(doctorRef),
+    doctorIds: (0, import_firestore12.arrayRemove)(doctorRef),
     // Remove ID from the denormalized list
-    updatedAt: (0, import_firestore10.serverTimestamp)()
+    updatedAt: (0, import_firestore12.serverTimestamp)()
   });
 };
 var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
   var _a;
   const newClinic = {
     clinicId,
-    assignedAt: import_firestore10.Timestamp.now(),
+    assignedAt: import_firestore12.Timestamp.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await (0, import_firestore10.getDoc)(getPatientDocRef(db, patientId));
+  const patientDoc = await (0, import_firestore12.getDoc)(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingClinicIndex = (_a = patientData.clinics) == null ? void 0 : _a.findIndex(
     (c) => c.clinicId === clinicId
   );
   const updates = {
-    updatedAt: (0, import_firestore10.serverTimestamp)(),
-    clinicIds: (0, import_firestore10.arrayUnion)(clinicId)
+    updatedAt: (0, import_firestore12.serverTimestamp)(),
+    clinicIds: (0, import_firestore12.arrayUnion)(clinicId)
   };
   if (existingClinicIndex !== void 0 && existingClinicIndex > -1) {
     const updatedClinics = [...patientData.clinics];
     updatedClinics[existingClinicIndex] = {
       ...updatedClinics[existingClinicIndex],
       isActive: true,
-      assignedAt: import_firestore10.Timestamp.now(),
+      assignedAt: import_firestore12.Timestamp.now(),
       assignedBy
     };
     updates.clinics = updatedClinics;
   } else {
-    updates.clinics = (0, import_firestore10.arrayUnion)(newClinic);
+    updates.clinics = (0, import_firestore12.arrayUnion)(newClinic);
   }
-  await (0, import_firestore10.updateDoc)(getPatientDocRef(db, patientId), updates);
+  await (0, import_firestore12.updateDoc)(getPatientDocRef(db, patientId), updates);
 };
 var removeClinicUtil = async (db, patientId, clinicId) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await (0, import_firestore10.getDoc)(patientDocRef);
+  const patientDoc = await (0, import_firestore12.getDoc)(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedClinics = ((_a = patientData.clinics) == null ? void 0 : _a.filter((clinic) => clinic.clinicId !== clinicId)) || [];
-  await (0, import_firestore10.updateDoc)(patientDocRef, {
+  await (0, import_firestore12.updateDoc)(patientDocRef, {
     clinics: updatedClinics,
     // Set the filtered array
-    clinicIds: (0, import_firestore10.arrayRemove)(clinicId),
+    clinicIds: (0, import_firestore12.arrayRemove)(clinicId),
     // Remove ID from the denormalized list
-    updatedAt: (0, import_firestore10.serverTimestamp)()
+    updatedAt: (0, import_firestore12.serverTimestamp)()
   });
 };
 
 // src/services/patient/utils/clinic.utils.ts
-var import_firestore11 = require("firebase/firestore");
+var import_firestore13 = require("firebase/firestore");
 var getPatientsByClinicUtil = async (db, clinicId, options) => {
   try {
     console.log(
       `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
       options
     );
-    const patientsCollection = (0, import_firestore11.collection)(db, PATIENTS_COLLECTION);
+    const patientsCollection = (0, import_firestore13.collection)(db, PATIENTS_COLLECTION);
     const constraints = [
-      (0, import_firestore11.where)("clinicIds", "array-contains", clinicId)
+      (0, import_firestore13.where)("clinicIds", "array-contains", clinicId)
     ];
-    let q = (0, import_firestore11.query)(patientsCollection, ...constraints);
+    let q = (0, import_firestore13.query)(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = (0, import_firestore11.query)(q, (0, import_firestore11.limit)(options.limit));
+      q = (0, import_firestore13.query)(q, (0, import_firestore13.limit)(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await (0, import_firestore11.getDoc)(
-        (0, import_firestore11.doc)(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await (0, import_firestore13.getDoc)(
+        (0, import_firestore13.doc)(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = (0, import_firestore11.query)(q, (0, import_firestore11.startAfter)(startAfterDoc));
+        q = (0, import_firestore13.query)(q, (0, import_firestore13.startAfter)(startAfterDoc));
       }
     }
-    const patientsSnapshot = await (0, import_firestore11.getDocs)(q);
+    const patientsSnapshot = await (0, import_firestore13.getDocs)(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2660,6 +3020,7 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
 var PatientService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
+    this.mediaService = new MediaService(db, auth, app);
   }
   // Metode za rad sa profilom pacijenta
   async createPatientProfile(data) {
@@ -2696,7 +3057,12 @@ var PatientService = class extends BaseService {
   }
   // Metode za rad sa osetljivim informacijama
   async createSensitiveInfo(data, requesterUserId) {
-    return createSensitiveInfoUtil(this.db, data, requesterUserId);
+    return createSensitiveInfoUtil(
+      this.db,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
   async getSensitiveInfo(patientId, requesterUserId) {
     return getSensitiveInfoUtil(this.db, patientId, requesterUserId);
@@ -2707,7 +3073,13 @@ var PatientService = class extends BaseService {
     return this.getSensitiveInfo(profile.id, requesterUserId);
   }
   async updateSensitiveInfo(patientId, data, requesterUserId) {
-    return updateSensitiveInfoUtil(this.db, patientId, data, requesterUserId);
+    return updateSensitiveInfoUtil(
+      this.db,
+      patientId,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
   // Metode za rad sa medicinskim informacijama
   async createMedicalInfo(patientId, data) {
@@ -2840,8 +3212,8 @@ var PatientService = class extends BaseService {
     if (!this.auth.currentUser) {
       throw new Error("No authenticated user");
     }
-    const userDoc = await (0, import_firestore12.getDoc)(
-      (0, import_firestore12.doc)(this.db, "users", this.auth.currentUser.uid)
+    const userDoc = await (0, import_firestore14.getDoc)(
+      (0, import_firestore14.doc)(this.db, "users", this.auth.currentUser.uid)
     );
     if (!userDoc.exists()) {
       throw new Error("User not found");
@@ -2852,7 +3224,7 @@ var PatientService = class extends BaseService {
    * Briše profil pacijenta i sve povezane subkolekcije
    */
   async deletePatientProfile(patientId) {
-    const batch = (0, import_firestore12.writeBatch)(this.db);
+    const batch = (0, import_firestore14.writeBatch)(this.db);
     batch.delete(getSensitiveInfoDocRef(this.db, patientId));
     batch.delete(getLocationInfoDocRef(this.db, patientId));
     batch.delete(getMedicalInfoDocRef(this.db, patientId));
@@ -2876,14 +3248,113 @@ var PatientService = class extends BaseService {
     await removeClinicUtil(this.db, patientId, clinicId);
   }
   // Metode za rad sa profilnom slikom
+  /**
+   * Uploads a profile photo for a patient
+   * @param patientId - ID of the patient
+   * @param file - File or Blob to upload
+   * @returns URL of the uploaded photo
+   */
   async uploadProfilePhoto(patientId, file) {
-    return uploadProfilePhotoUtil(this.storage, patientId, file);
+    console.log(
+      `[PatientService] Uploading profile photo for patient ${patientId}`
+    );
+    const mediaMetadata = await this.mediaService.uploadMedia(
+      file,
+      patientId,
+      // Using patientId as ownerId
+      "private" /* PRIVATE */,
+      // Profile photos should be private
+      "patient_profile_photos",
+      file instanceof File ? file.name : `profile_photo_${patientId}`
+    );
+    await (0, import_firestore14.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
+      photoUrl: mediaMetadata.url,
+      updatedAt: (0, import_firestore14.serverTimestamp)()
+    });
+    return mediaMetadata.url;
   }
+  /**
+   * Updates a patient's profile photo (replaces existing one)
+   * @param patientId - ID of the patient
+   * @param file - New file or Blob to upload
+   * @returns URL of the new uploaded photo
+   */
   async updateProfilePhoto(patientId, file) {
-    return updateProfilePhotoUtil(this.storage, this.db, patientId, file);
+    console.log(
+      `[PatientService] Updating profile photo for patient ${patientId}`
+    );
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+    if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+    }
+    return this.uploadProfilePhoto(patientId, file);
   }
+  /**
+   * Deletes a patient's profile photo
+   * @param patientId - ID of the patient
+   */
   async deleteProfilePhoto(patientId) {
-    await deleteProfilePhotoUtil(this.storage, this.db, patientId);
+    console.log(
+      `[PatientService] Deleting profile photo for patient ${patientId}`
+    );
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+    if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+      await (0, import_firestore14.updateDoc)(getSensitiveInfoDocRef(this.db, patientId), {
+        photoUrl: null,
+        updatedAt: (0, import_firestore14.serverTimestamp)()
+      });
+    }
+  }
+  /**
+   * Handles profile photo upload for patients (supports MediaResource)
+   * @param photoUrl - MediaResource (File, Blob, or URL string) from CreatePatientSensitiveInfoData
+   * @param patientId - ID of the patient
+   * @returns URL string of the uploaded or existing photo
+   */
+  async handleProfilePhotoUpload(photoUrl, patientId) {
+    if (!photoUrl) {
+      return void 0;
+    }
+    if (typeof photoUrl === "string") {
+      return photoUrl;
+    }
+    if (photoUrl instanceof File || photoUrl instanceof Blob) {
+      return this.uploadProfilePhoto(patientId, photoUrl);
+    }
+    return void 0;
   }
   // Metode za ažuriranje profila
   async updatePatientProfile(patientId, data) {
@@ -2976,7 +3447,7 @@ var PatientService = class extends BaseService {
 };
 
 // src/services/clinic/utils/admin.utils.ts
-var import_firestore14 = require("firebase/firestore");
+var import_firestore16 = require("firebase/firestore");
 
 // src/types/clinic/preferences.types.ts
 var PracticeType = /* @__PURE__ */ ((PracticeType2) => {
@@ -3103,131 +3574,131 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 
 // src/validations/clinic.schema.ts
 var import_zod13 = require("zod");
-var import_firestore13 = require("firebase/firestore");
+var import_firestore15 = require("firebase/firestore");
 
 // src/validations/reviews.schema.ts
-var import_zod10 = require("zod");
-var baseReviewSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  patientId: import_zod10.z.string().min(1),
-  fullReviewId: import_zod10.z.string().min(1),
-  createdAt: import_zod10.z.date(),
-  updatedAt: import_zod10.z.date(),
-  comment: import_zod10.z.string().min(1).max(2e3),
-  isVerified: import_zod10.z.boolean(),
-  isPublished: import_zod10.z.boolean()
+var import_zod11 = require("zod");
+var baseReviewSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  patientId: import_zod11.z.string().min(1),
+  fullReviewId: import_zod11.z.string().min(1),
+  createdAt: import_zod11.z.date(),
+  updatedAt: import_zod11.z.date(),
+  comment: import_zod11.z.string().min(1).max(2e3),
+  isVerified: import_zod11.z.boolean(),
+  isPublished: import_zod11.z.boolean()
 });
-var baseReviewCreateSchema = import_zod10.z.object({
-  patientId: import_zod10.z.string().min(1),
-  comment: import_zod10.z.string().min(1).max(2e3),
-  isVerified: import_zod10.z.boolean().default(false),
-  isPublished: import_zod10.z.boolean().default(true)
+var baseReviewCreateSchema = import_zod11.z.object({
+  patientId: import_zod11.z.string().min(1),
+  comment: import_zod11.z.string().min(1).max(2e3),
+  isVerified: import_zod11.z.boolean().default(false),
+  isPublished: import_zod11.z.boolean().default(true)
 });
 var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: import_zod10.z.string().min(1),
-  cleanliness: import_zod10.z.number().min(1).max(5),
-  facilities: import_zod10.z.number().min(1).max(5),
-  staffFriendliness: import_zod10.z.number().min(1).max(5),
-  waitingTime: import_zod10.z.number().min(1).max(5),
-  accessibility: import_zod10.z.number().min(1).max(5),
-  overallRating: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  clinicId: import_zod11.z.string().min(1),
+  cleanliness: import_zod11.z.number().min(1).max(5),
+  facilities: import_zod11.z.number().min(1).max(5),
+  staffFriendliness: import_zod11.z.number().min(1).max(5),
+  waitingTime: import_zod11.z.number().min(1).max(5),
+  accessibility: import_zod11.z.number().min(1).max(5),
+  overallRating: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: import_zod10.z.string().min(1),
-  cleanliness: import_zod10.z.number().min(1).max(5),
-  facilities: import_zod10.z.number().min(1).max(5),
-  staffFriendliness: import_zod10.z.number().min(1).max(5),
-  waitingTime: import_zod10.z.number().min(1).max(5),
-  accessibility: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  clinicId: import_zod11.z.string().min(1),
+  cleanliness: import_zod11.z.number().min(1).max(5),
+  facilities: import_zod11.z.number().min(1).max(5),
+  staffFriendliness: import_zod11.z.number().min(1).max(5),
+  waitingTime: import_zod11.z.number().min(1).max(5),
+  accessibility: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: import_zod10.z.string().min(1),
-  knowledgeAndExpertise: import_zod10.z.number().min(1).max(5),
-  communicationSkills: import_zod10.z.number().min(1).max(5),
-  bedSideManner: import_zod10.z.number().min(1).max(5),
-  thoroughness: import_zod10.z.number().min(1).max(5),
-  trustworthiness: import_zod10.z.number().min(1).max(5),
-  overallRating: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  practitionerId: import_zod11.z.string().min(1),
+  knowledgeAndExpertise: import_zod11.z.number().min(1).max(5),
+  communicationSkills: import_zod11.z.number().min(1).max(5),
+  bedSideManner: import_zod11.z.number().min(1).max(5),
+  thoroughness: import_zod11.z.number().min(1).max(5),
+  trustworthiness: import_zod11.z.number().min(1).max(5),
+  overallRating: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: import_zod10.z.string().min(1),
-  knowledgeAndExpertise: import_zod10.z.number().min(1).max(5),
-  communicationSkills: import_zod10.z.number().min(1).max(5),
-  bedSideManner: import_zod10.z.number().min(1).max(5),
-  thoroughness: import_zod10.z.number().min(1).max(5),
-  trustworthiness: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  practitionerId: import_zod11.z.string().min(1),
+  knowledgeAndExpertise: import_zod11.z.number().min(1).max(5),
+  communicationSkills: import_zod11.z.number().min(1).max(5),
+  bedSideManner: import_zod11.z.number().min(1).max(5),
+  thoroughness: import_zod11.z.number().min(1).max(5),
+  trustworthiness: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: import_zod10.z.string().min(1),
-  effectivenessOfTreatment: import_zod10.z.number().min(1).max(5),
-  outcomeExplanation: import_zod10.z.number().min(1).max(5),
-  painManagement: import_zod10.z.number().min(1).max(5),
-  followUpCare: import_zod10.z.number().min(1).max(5),
-  valueForMoney: import_zod10.z.number().min(1).max(5),
-  overallRating: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  procedureId: import_zod11.z.string().min(1),
+  effectivenessOfTreatment: import_zod11.z.number().min(1).max(5),
+  outcomeExplanation: import_zod11.z.number().min(1).max(5),
+  painManagement: import_zod11.z.number().min(1).max(5),
+  followUpCare: import_zod11.z.number().min(1).max(5),
+  valueForMoney: import_zod11.z.number().min(1).max(5),
+  overallRating: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
 var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: import_zod10.z.string().min(1),
-  effectivenessOfTreatment: import_zod10.z.number().min(1).max(5),
-  outcomeExplanation: import_zod10.z.number().min(1).max(5),
-  painManagement: import_zod10.z.number().min(1).max(5),
-  followUpCare: import_zod10.z.number().min(1).max(5),
-  valueForMoney: import_zod10.z.number().min(1).max(5),
-  wouldRecommend: import_zod10.z.boolean()
+  procedureId: import_zod11.z.string().min(1),
+  effectivenessOfTreatment: import_zod11.z.number().min(1).max(5),
+  outcomeExplanation: import_zod11.z.number().min(1).max(5),
+  painManagement: import_zod11.z.number().min(1).max(5),
+  followUpCare: import_zod11.z.number().min(1).max(5),
+  valueForMoney: import_zod11.z.number().min(1).max(5),
+  wouldRecommend: import_zod11.z.boolean()
 });
-var clinicReviewInfoSchema = import_zod10.z.object({
-  totalReviews: import_zod10.z.number().min(0),
-  averageRating: import_zod10.z.number().min(0).max(5),
-  cleanliness: import_zod10.z.number().min(0).max(5),
-  facilities: import_zod10.z.number().min(0).max(5),
-  staffFriendliness: import_zod10.z.number().min(0).max(5),
-  waitingTime: import_zod10.z.number().min(0).max(5),
-  accessibility: import_zod10.z.number().min(0).max(5),
-  recommendationPercentage: import_zod10.z.number().min(0).max(100)
+var clinicReviewInfoSchema = import_zod11.z.object({
+  totalReviews: import_zod11.z.number().min(0),
+  averageRating: import_zod11.z.number().min(0).max(5),
+  cleanliness: import_zod11.z.number().min(0).max(5),
+  facilities: import_zod11.z.number().min(0).max(5),
+  staffFriendliness: import_zod11.z.number().min(0).max(5),
+  waitingTime: import_zod11.z.number().min(0).max(5),
+  accessibility: import_zod11.z.number().min(0).max(5),
+  recommendationPercentage: import_zod11.z.number().min(0).max(100)
 });
-var practitionerReviewInfoSchema = import_zod10.z.object({
-  totalReviews: import_zod10.z.number().min(0),
-  averageRating: import_zod10.z.number().min(0).max(5),
-  knowledgeAndExpertise: import_zod10.z.number().min(0).max(5),
-  communicationSkills: import_zod10.z.number().min(0).max(5),
-  bedSideManner: import_zod10.z.number().min(0).max(5),
-  thoroughness: import_zod10.z.number().min(0).max(5),
-  trustworthiness: import_zod10.z.number().min(0).max(5),
-  recommendationPercentage: import_zod10.z.number().min(0).max(100)
+var practitionerReviewInfoSchema = import_zod11.z.object({
+  totalReviews: import_zod11.z.number().min(0),
+  averageRating: import_zod11.z.number().min(0).max(5),
+  knowledgeAndExpertise: import_zod11.z.number().min(0).max(5),
+  communicationSkills: import_zod11.z.number().min(0).max(5),
+  bedSideManner: import_zod11.z.number().min(0).max(5),
+  thoroughness: import_zod11.z.number().min(0).max(5),
+  trustworthiness: import_zod11.z.number().min(0).max(5),
+  recommendationPercentage: import_zod11.z.number().min(0).max(100)
 });
-var procedureReviewInfoSchema = import_zod10.z.object({
-  totalReviews: import_zod10.z.number().min(0),
-  averageRating: import_zod10.z.number().min(0).max(5),
-  effectivenessOfTreatment: import_zod10.z.number().min(0).max(5),
-  outcomeExplanation: import_zod10.z.number().min(0).max(5),
-  painManagement: import_zod10.z.number().min(0).max(5),
-  followUpCare: import_zod10.z.number().min(0).max(5),
-  valueForMoney: import_zod10.z.number().min(0).max(5),
-  recommendationPercentage: import_zod10.z.number().min(0).max(100)
+var procedureReviewInfoSchema = import_zod11.z.object({
+  totalReviews: import_zod11.z.number().min(0),
+  averageRating: import_zod11.z.number().min(0).max(5),
+  effectivenessOfTreatment: import_zod11.z.number().min(0).max(5),
+  outcomeExplanation: import_zod11.z.number().min(0).max(5),
+  painManagement: import_zod11.z.number().min(0).max(5),
+  followUpCare: import_zod11.z.number().min(0).max(5),
+  valueForMoney: import_zod11.z.number().min(0).max(5),
+  recommendationPercentage: import_zod11.z.number().min(0).max(100)
 });
-var reviewSchema = import_zod10.z.object({
-  id: import_zod10.z.string().min(1),
-  appointmentId: import_zod10.z.string().min(1),
-  patientId: import_zod10.z.string().min(1),
-  createdAt: import_zod10.z.date(),
-  updatedAt: import_zod10.z.date(),
+var reviewSchema = import_zod11.z.object({
+  id: import_zod11.z.string().min(1),
+  appointmentId: import_zod11.z.string().min(1),
+  patientId: import_zod11.z.string().min(1),
+  createdAt: import_zod11.z.date(),
+  updatedAt: import_zod11.z.date(),
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
-  overallComment: import_zod10.z.string().min(1).max(2e3),
-  overallRating: import_zod10.z.number().min(1).max(5)
+  overallComment: import_zod11.z.string().min(1).max(2e3),
+  overallRating: import_zod11.z.number().min(1).max(5)
 });
-var createReviewSchema = import_zod10.z.object({
-  patientId: import_zod10.z.string().min(1),
+var createReviewSchema = import_zod11.z.object({
+  patientId: import_zod11.z.string().min(1),
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: import_zod10.z.string().min(1).max(2e3)
+  overallComment: import_zod11.z.string().min(1).max(2e3)
 }).refine(
   (data) => {
     return data.clinicReview || data.practitionerReview || data.procedureReview;
@@ -3239,7 +3710,7 @@ var createReviewSchema = import_zod10.z.object({
 );
 
 // src/validations/shared.schema.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/backoffice/types/static/procedure-family.types.ts
 var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
@@ -3268,65 +3739,57 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
 })(Currency || {});
 
 // src/validations/shared.schema.ts
-var sharedClinicContactInfoSchema = import_zod11.z.object({
-  email: import_zod11.z.string().email(),
-  phoneNumber: import_zod11.z.string(),
-  alternativePhoneNumber: import_zod11.z.string().nullable().optional(),
-  website: import_zod11.z.string().nullable().optional()
+var sharedClinicContactInfoSchema = import_zod12.z.object({
+  email: import_zod12.z.string().email(),
+  phoneNumber: import_zod12.z.string(),
+  alternativePhoneNumber: import_zod12.z.string().nullable().optional(),
+  website: import_zod12.z.string().nullable().optional()
 });
-var sharedClinicLocationSchema = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  city: import_zod11.z.string(),
-  country: import_zod11.z.string(),
-  postalCode: import_zod11.z.string(),
-  latitude: import_zod11.z.number().min(-90).max(90),
-  longitude: import_zod11.z.number().min(-180).max(180),
-  geohash: import_zod11.z.string().nullable().optional()
+var sharedClinicLocationSchema = import_zod12.z.object({
+  address: import_zod12.z.string(),
+  city: import_zod12.z.string(),
+  country: import_zod12.z.string(),
+  postalCode: import_zod12.z.string(),
+  latitude: import_zod12.z.number().min(-90).max(90),
+  longitude: import_zod12.z.number().min(-180).max(180),
+  geohash: import_zod12.z.string().nullable().optional()
 });
-var procedureSummaryInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string().min(1),
-  name: import_zod11.z.string().min(1),
-  description: import_zod11.z.string().optional(),
-  photo: import_zod11.z.string().optional(),
-  family: import_zod11.z.nativeEnum(ProcedureFamily),
-  categoryName: import_zod11.z.string(),
-  subcategoryName: import_zod11.z.string(),
-  technologyName: import_zod11.z.string(),
-  price: import_zod11.z.number().nonnegative(),
-  pricingMeasure: import_zod11.z.nativeEnum(PricingMeasure),
-  currency: import_zod11.z.nativeEnum(Currency),
-  duration: import_zod11.z.number().int().positive(),
-  clinicId: import_zod11.z.string().min(1),
-  clinicName: import_zod11.z.string().min(1),
-  practitionerId: import_zod11.z.string().min(1),
-  practitionerName: import_zod11.z.string().min(1)
+var procedureSummaryInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string().min(1),
+  name: import_zod12.z.string().min(1),
+  description: import_zod12.z.string().optional(),
+  photo: import_zod12.z.string().optional(),
+  family: import_zod12.z.nativeEnum(ProcedureFamily),
+  categoryName: import_zod12.z.string(),
+  subcategoryName: import_zod12.z.string(),
+  technologyName: import_zod12.z.string(),
+  price: import_zod12.z.number().nonnegative(),
+  pricingMeasure: import_zod12.z.nativeEnum(PricingMeasure),
+  currency: import_zod12.z.nativeEnum(Currency),
+  duration: import_zod12.z.number().int().positive(),
+  clinicId: import_zod12.z.string().min(1),
+  clinicName: import_zod12.z.string().min(1),
+  practitionerId: import_zod12.z.string().min(1),
+  practitionerName: import_zod12.z.string().min(1)
 });
-var clinicInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  featuredPhoto: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
+var clinicInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  featuredPhoto: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
   location: sharedClinicLocationSchema,
   contactInfo: sharedClinicContactInfoSchema
 });
-var doctorInfoSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string().nullable().optional(),
-  photo: import_zod11.z.string(),
-  rating: import_zod11.z.number().min(0).max(5),
-  services: import_zod11.z.array(import_zod11.z.string())
+var doctorInfoSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string().nullable().optional(),
+  photo: import_zod12.z.string(),
+  rating: import_zod12.z.number().min(0).max(5),
+  services: import_zod12.z.array(import_zod12.z.string())
   // List of procedure IDs practitioner offers
 });
 
-// src/validations/media.schema.ts
-var import_zod12 = require("zod");
-var mediaResourceSchema = import_zod12.z.union([
-  import_zod12.z.string().url(),
-  import_zod12.z.instanceof(File),
-  import_zod12.z.instanceof(Blob)
-]);
-
 // src/validations/clinic.schema.ts
 var clinicContactInfoSchema = import_zod13.z.object({
   email: import_zod13.z.string().email(),
@@ -3386,8 +3849,8 @@ var clinicAdminSchema = import_zod13.z.object({
   clinicsManagedInfo: import_zod13.z.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
   roleTitle: import_zod13.z.string(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   isActive: import_zod13.z.boolean()
 });
 var adminTokenSchema = import_zod13.z.object({
@@ -3396,9 +3859,9 @@ var adminTokenSchema = import_zod13.z.object({
   email: import_zod13.z.string().email().optional().nullable(),
   status: import_zod13.z.nativeEnum(AdminTokenStatus),
   usedByUserRef: import_zod13.z.string().optional(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
-  expiresAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp))
+  expiresAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp))
   // Timestamp
 });
 var createAdminTokenSchema = import_zod13.z.object({
@@ -3418,9 +3881,9 @@ var clinicGroupSchema = import_zod13.z.object({
   adminsInfo: import_zod13.z.array(adminInfoSchema),
   adminTokens: import_zod13.z.array(adminTokenSchema),
   ownerId: import_zod13.z.string().nullable(),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
   isActive: import_zod13.z.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
@@ -3462,9 +3925,9 @@ var clinicSchema = import_zod13.z.object({
   // Use the correct schema for aggregated procedure info
   reviewInfo: clinicReviewInfoSchema,
   admins: import_zod13.z.array(import_zod13.z.string()),
-  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  createdAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
-  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore13.Timestamp)),
+  updatedAt: import_zod13.z.instanceof(Date).or(import_zod13.z.instanceof(import_firestore15.Timestamp)),
   // Timestamp
   isActive: import_zod13.z.boolean(),
   isVerified: import_zod13.z.boolean(),
@@ -3686,7 +4149,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
   const adminData = {
-    id: (0, import_firestore14.doc)((0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
+    id: (0, import_firestore16.doc)((0, import_firestore16.collection)(db, CLINIC_ADMINS_COLLECTION)).id,
     // Generate a new ID for the admin document
     userRef: validatedData.userRef,
     clinicGroupId: clinicGroupId || "",
@@ -3699,15 +4162,15 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     contactInfo: validatedData.contactInfo,
     roleTitle: validatedData.roleTitle,
     isActive: validatedData.isActive,
-    createdAt: (0, import_firestore14.serverTimestamp)(),
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    createdAt: (0, import_firestore16.serverTimestamp)(),
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   };
   console.log("[CLINIC_ADMIN] Validating complete admin object");
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: import_firestore14.Timestamp.now(),
-      updatedAt: import_firestore14.Timestamp.now()
+      createdAt: import_firestore16.Timestamp.now(),
+      updatedAt: import_firestore16.Timestamp.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -3721,7 +4184,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     adminId: adminData.id
   });
   try {
-    await (0, import_firestore14.setDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    await (0, import_firestore16.setDoc)((0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
     console.log("[CLINIC_ADMIN] Admin saved successfully");
   } catch (firestoreError) {
     console.error(
@@ -3770,30 +4233,30 @@ async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   return !!group;
 }
 async function getClinicAdmin(db, adminId) {
-  const docRef = (0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await (0, import_firestore14.getDoc)(docRef);
+  const docRef = (0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await (0, import_firestore16.getDoc)(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicAdminByUserRef(db, userRef) {
-  const q = (0, import_firestore14.query)(
-    (0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore14.where)("userRef", "==", userRef)
+  const q = (0, import_firestore16.query)(
+    (0, import_firestore16.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore16.where)("userRef", "==", userRef)
   );
-  const querySnapshot = await (0, import_firestore14.getDocs)(q);
+  const querySnapshot = await (0, import_firestore16.getDocs)(q);
   if (querySnapshot.empty) {
     return null;
   }
   return querySnapshot.docs[0].data();
 }
 async function getClinicAdminsByGroup(db, clinicGroupId) {
-  const q = (0, import_firestore14.query)(
-    (0, import_firestore14.collection)(db, CLINIC_ADMINS_COLLECTION),
-    (0, import_firestore14.where)("clinicGroupId", "==", clinicGroupId)
+  const q = (0, import_firestore16.query)(
+    (0, import_firestore16.collection)(db, CLINIC_ADMINS_COLLECTION),
+    (0, import_firestore16.where)("clinicGroupId", "==", clinicGroupId)
   );
-  const querySnapshot = await (0, import_firestore14.getDocs)(q);
+  const querySnapshot = await (0, import_firestore16.getDocs)(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
@@ -3803,9 +4266,9 @@ async function updateClinicAdmin(db, adminId, data) {
   }
   const updatedData = {
     ...data,
-    updatedAt: (0, import_firestore14.serverTimestamp)()
+    updatedAt: (0, import_firestore16.serverTimestamp)()
   };
-  await (0, import_firestore14.updateDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+  await (0, import_firestore16.updateDoc)((0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
   const updatedAdmin = await getClinicAdmin(db, adminId);
   if (!updatedAdmin) {
     throw new Error("Failed to retrieve updated admin");
@@ -3817,7 +4280,7 @@ async function deleteClinicAdmin(db, adminId) {
   if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  await (0, import_firestore14.deleteDoc)((0, import_firestore14.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
+  await (0, import_firestore16.deleteDoc)((0, import_firestore16.doc)(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3967,399 +4430,101 @@ var ClinicAdminService = class extends BaseService {
   async syncOwnerClinics(adminId) {
     return syncOwnerClinics(
       this.db,
-      adminId,
-      this.getClinicService(),
-      this.getClinicGroupService()
-    );
-  }
-  /**
-   * Kreira novi admin profil
-   */
-  async createClinicAdmin(data) {
-    return createClinicAdmin(
-      this.db,
-      data,
-      this.getClinicGroupService()
-    );
-  }
-  /**
-   * Dohvata admin profil po ID-u
-   */
-  async getClinicAdmin(adminId) {
-    return getClinicAdmin(this.db, adminId);
-  }
-  /**
-   * Dohvata admin profil po korisničkom ID-u
-   */
-  async getClinicAdminByUserRef(userRef) {
-    return getClinicAdminByUserRef(this.db, userRef);
-  }
-  /**
-   * Dohvata sve admine u grupi
-   */
-  async getClinicAdminsByGroup(clinicGroupId) {
-    return getClinicAdminsByGroup(this.db, clinicGroupId);
-  }
-  /**
-   * Ažurira admin profil
-   */
-  async updateClinicAdmin(adminId, data) {
-    return updateClinicAdmin(this.db, adminId, data);
-  }
-  /**
-   * Briše admin profil
-   */
-  async deleteClinicAdmin(adminId) {
-    return deleteClinicAdmin(this.db, adminId);
-  }
-  /**
-   * Dodaje kliniku u listu klinika kojima admin upravlja
-   */
-  async addClinicToManaged(adminId, clinicId, requesterId) {
-    return addClinicToManaged(
-      this.db,
-      adminId,
-      clinicId,
-      requesterId,
-      this.getClinicService()
-    );
-  }
-  /**
-   * Uklanja kliniku iz liste klinika kojima admin upravlja
-   */
-  async removeClinicFromManaged(adminId, clinicId, requesterId) {
-    return removeClinicFromManaged(
-      this.db,
-      adminId,
-      clinicId,
-      requesterId
-    );
-  }
-  /**
-   * Dohvata sve klinike kojima admin upravlja
-   */
-  async getManagedClinics(adminId) {
-    return getManagedClinics(
-      this.db,
-      adminId,
-      this.getClinicService()
-    );
-  }
-  /**
-   * Dohvata sve aktivne klinike kojima admin upravlja
-   */
-  async getActiveManagedClinics(adminId) {
-    return getActiveManagedClinics(
-      this.db,
-      adminId,
-      this.getClinicService()
-    );
-  }
-  // TODO: Add more methods for clinic admins for managing permissions, editing profiles by the admin, or by the clinic group owner and so on
-  // Generally refactor admin permissions and clinic group permissions and systems for admin management
-};
-
-// src/services/practitioner/practitioner.service.ts
-var import_firestore18 = require("firebase/firestore");
-
-// src/services/media/media.service.ts
-var import_firestore15 = require("firebase/firestore");
-var import_storage4 = require("firebase/storage");
-var import_firestore16 = require("firebase/firestore");
-var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
-  MediaAccessLevel2["PUBLIC"] = "public";
-  MediaAccessLevel2["PRIVATE"] = "private";
-  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
-  return MediaAccessLevel2;
-})(MediaAccessLevel || {});
-var MEDIA_METADATA_COLLECTION = "media_metadata";
-var MediaService = class extends BaseService {
-  constructor(db, auth, app) {
-    super(db, auth, app);
-  }
-  /**
-   * Upload a media file, store its metadata, and return the metadata including the URL.
-   * @param file - The file to upload.
-   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
-   * @param accessLevel - Access level (public, private, confidential).
-   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
-   * @param originalFileName - Optional: the original name of the file, if not using file.name.
-   * @returns Promise with the media metadata.
-   */
-  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
-    const mediaId = this.generateId();
-    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
-    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
-    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
-    console.log(`[MediaService] Uploading file to: ${filePath}`);
-    const storageRef = (0, import_storage4.ref)(this.storage, filePath);
-    try {
-      const uploadResult = await (0, import_storage4.uploadBytes)(storageRef, file, {
-        contentType: file.type
-      });
-      console.log("[MediaService] File uploaded successfully", uploadResult);
-      const downloadURL = await (0, import_storage4.getDownloadURL)(uploadResult.ref);
-      console.log("[MediaService] Got download URL:", downloadURL);
-      const metadata = {
-        id: mediaId,
-        name: fileNameToUse,
-        url: downloadURL,
-        contentType: file.type,
-        size: file.size,
-        createdAt: import_firestore15.Timestamp.now(),
-        accessLevel,
-        ownerId,
-        collectionName,
-        path: filePath
-      };
-      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore16.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;
-    }
+      adminId,
+      this.getClinicService(),
+      this.getClinicGroupService()
+    );
   }
   /**
-   * 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.
+   * Kreira novi admin profil
    */
-  async getMediaMetadata(mediaId) {
-    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
-    const docRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-    const docSnap = await (0, import_firestore16.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;
+  async createClinicAdmin(data) {
+    return createClinicAdmin(
+      this.db,
+      data,
+      this.getClinicGroupService()
+    );
   }
   /**
-   * 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.
+   * Dohvata admin profil po ID-u
    */
-  async getMediaMetadataByUrl(url) {
-    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
-    const q = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      (0, import_firestore16.where)("url", "==", url),
-      (0, import_firestore16.limit)(1)
-    );
-    try {
-      const querySnapshot = await (0, import_firestore16.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;
-    }
+  async getClinicAdmin(adminId) {
+    return getClinicAdmin(this.db, adminId);
   }
   /**
-   * Delete media from storage and remove metadata from Firestore.
-   * @param mediaId - ID of the media to delete.
+   * Dohvata admin profil po korisničkom ID-u
    */
-  async deleteMedia(mediaId) {
-    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (!metadata) {
-      console.warn(
-        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
-      );
-      return;
-    }
-    const storageFileRef = (0, import_storage4.ref)(this.storage, metadata.path);
-    try {
-      await (0, import_storage4.deleteObject)(storageFileRef);
-      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
-      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await (0, import_firestore16.deleteDoc)(metadataDocRef);
-      console.log(
-        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
-      );
-    } catch (error) {
-      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
-      throw error;
-    }
+  async getClinicAdminByUserRef(userRef) {
+    return getClinicAdminByUserRef(this.db, userRef);
   }
   /**
-   * 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.
+   * Dohvata sve admine u grupi
    */
-  async updateMediaAccessLevel(mediaId, newAccessLevel) {
-    var _a;
-    console.log(
-      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+  async getClinicAdminsByGroup(clinicGroupId) {
+    return getClinicAdminsByGroup(this.db, clinicGroupId);
+  }
+  /**
+   * Ažurira admin profil
+   */
+  async updateClinicAdmin(adminId, data) {
+    return updateClinicAdmin(this.db, adminId, data);
+  }
+  /**
+   * Briše admin profil
+   */
+  async deleteClinicAdmin(adminId) {
+    return deleteClinicAdmin(this.db, adminId);
+  }
+  /**
+   * Dodaje kliniku u listu klinika kojima admin upravlja
+   */
+  async addClinicToManaged(adminId, clinicId, requesterId) {
+    return addClinicToManaged(
+      this.db,
+      adminId,
+      clinicId,
+      requesterId,
+      this.getClinicService()
     );
-    const metadata = await this.getMediaMetadata(mediaId);
-    if (!metadata) {
-      console.warn(
-        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
-      );
-      return null;
-    }
-    if (metadata.accessLevel === newAccessLevel) {
-      console.log(
-        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
-      );
-      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      try {
-        await (0, import_firestore16.updateDoc)(metadataDocRef, { updatedAt: import_firestore15.Timestamp.now() });
-        return { ...metadata, updatedAt: import_firestore15.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}`
+  }
+  /**
+   * Uklanja kliniku iz liste klinika kojima admin upravlja
+   */
+  async removeClinicFromManaged(adminId, clinicId, requesterId) {
+    return removeClinicFromManaged(
+      this.db,
+      adminId,
+      clinicId,
+      requesterId
     );
-    const oldStorageFileRef = (0, import_storage4.ref)(this.storage, oldStoragePath);
-    const newStorageFileRef = (0, import_storage4.ref)(this.storage, newStoragePath);
-    try {
-      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
-      const fileBytes = await (0, import_storage4.getBytes)(oldStorageFileRef);
-      console.log(
-        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
-      );
-      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
-      await (0, import_storage4.uploadBytes)(newStorageFileRef, fileBytes, {
-        contentType: metadata.contentType
-      });
-      console.log(
-        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
-      );
-      const newDownloadURL = await (0, import_storage4.getDownloadURL)(newStorageFileRef);
-      console.log(
-        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
-      );
-      const updateData = {
-        accessLevel: newAccessLevel,
-        path: newStoragePath,
-        url: newDownloadURL,
-        updatedAt: import_firestore15.Timestamp.now()
-      };
-      const metadataDocRef = (0, import_firestore16.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      console.log(
-        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
-        updateData
-      );
-      await (0, import_firestore16.updateDoc)(metadataDocRef, updateData);
-      console.log(
-        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
-      );
-      try {
-        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
-        await (0, import_storage4.deleteObject)(oldStorageFileRef);
-        console.log(
-          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
-        );
-      } catch (deleteError) {
-        console.error(
-          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
-          deleteError
-        );
-      }
-      return { ...metadata, ...updateData };
-    } catch (error) {
-      console.error(
-        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
-        error
-      );
-      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
-        console.warn(
-          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
-        );
-        try {
-          await (0, import_storage4.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).
+   * Dohvata sve klinike kojima admin upravlja
    */
-  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
-    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
-    let qConstraints = [(0, import_firestore16.where)("ownerId", "==", ownerId)];
-    if (collectionName) {
-      qConstraints.push((0, import_firestore16.where)("collectionName", "==", collectionName));
-    }
-    if (accessLevel) {
-      qConstraints.push((0, import_firestore16.where)("accessLevel", "==", accessLevel));
-    }
-    qConstraints.push((0, import_firestore16.orderBy)("createdAt", "desc"));
-    if (count) {
-      qConstraints.push((0, import_firestore16.limit)(count));
-    }
-    if (startAfterId) {
-      const startAfterDoc = await this.getMediaMetadata(startAfterId);
-      if (startAfterDoc) {
-      }
-    }
-    const finalQuery = (0, import_firestore16.query)(
-      (0, import_firestore16.collection)(this.db, MEDIA_METADATA_COLLECTION),
-      ...qConstraints
+  async getManagedClinics(adminId) {
+    return getManagedClinics(
+      this.db,
+      adminId,
+      this.getClinicService()
     );
-    try {
-      const querySnapshot = await (0, import_firestore16.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.
+   * Dohvata sve aktivne klinike kojima admin upravlja
    */
-  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;
+  async getActiveManagedClinics(adminId) {
+    return getActiveManagedClinics(
+      this.db,
+      adminId,
+      this.getClinicService()
+    );
   }
+  // TODO: Add more methods for clinic admins for managing permissions, editing profiles by the admin, or by the clinic group owner and so on
+  // Generally refactor admin permissions and clinic group permissions and systems for admin management
 };
 
+// src/services/practitioner/practitioner.service.ts
+var import_firestore18 = require("firebase/firestore");
+
 // src/validations/practitioner.schema.ts
 var import_zod14 = require("zod");
 var import_firestore17 = require("firebase/firestore");
@@ -5647,7 +5812,7 @@ var import_geofire_common3 = require("geofire-common");
 var import_zod17 = require("zod");
 
 // src/services/clinic/utils/photos.utils.ts
-var import_storage5 = require("firebase/storage");
+var import_storage4 = require("firebase/storage");
 async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName) {
   if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
     return photo;
@@ -5656,9 +5821,9 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
     console.log(
       `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
     );
-    const storage = (0, import_storage5.getStorage)(app);
+    const storage = (0, import_storage4.getStorage)(app);
     const storageFileName = fileName || `${photoType}-${Date.now()}`;
-    const storageRef = (0, import_storage5.ref)(
+    const storageRef = (0, import_storage4.ref)(
       storage,
       `${entityType}/${entityId}/${storageFileName}`
     );
@@ -5670,8 +5835,8 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
       byteArrays.push(byteCharacters.charCodeAt(i));
     }
     const blob = new Blob([new Uint8Array(byteArrays)], { type: contentType });
-    await (0, import_storage5.uploadBytes)(storageRef, blob, { contentType });
-    const downloadUrl = await (0, import_storage5.getDownloadURL)(storageRef);
+    await (0, import_storage4.uploadBytes)(storageRef, blob, { contentType });
+    const downloadUrl = await (0, import_storage4.getDownloadURL)(storageRef);
     console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
       downloadUrl
     });