@blackcode_sa/metaestetics-api 1.7.20 → 1.7.21

package/dist/index.mjs

@@ -987,31 +987,348 @@ import { z as z16 } from "zod";
 
 // src/services/patient/patient.service.ts
 import {
-  doc as doc6,
-  getDoc as getDoc9,
-  writeBatch
+  doc as doc7,
+  getDoc as getDoc10,
+  writeBatch,
+  updateDoc as updateDoc7,
+  serverTimestamp as serverTimestamp7
 } from "firebase/firestore";
 
+// src/services/media/media.service.ts
+import { Timestamp } from "firebase/firestore";
+import {
+  ref,
+  uploadBytes,
+  getDownloadURL,
+  deleteObject,
+  getBytes
+} from "firebase/storage";
+import {
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  collection,
+  query,
+  where,
+  limit,
+  getDocs,
+  deleteDoc,
+  orderBy
+} from "firebase/firestore";
+var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
+  MediaAccessLevel2["PUBLIC"] = "public";
+  MediaAccessLevel2["PRIVATE"] = "private";
+  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
+  return MediaAccessLevel2;
+})(MediaAccessLevel || {});
+var MEDIA_METADATA_COLLECTION = "media_metadata";
+var MediaService = class extends BaseService {
+  constructor(db, auth, app) {
+    super(db, auth, app);
+  }
+  /**
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
+   */
+  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+    const storageRef = ref(this.storage, filePath);
+    try {
+      const uploadResult = await uploadBytes(storageRef, file, {
+        contentType: file.type
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await getDownloadURL(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+      const metadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: Timestamp.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await setDoc(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+      return metadata;
+    } catch (error) {
+      console.error("[MediaService] Error during media upload:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId) {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await getDoc(docRef);
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data();
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url) {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = query(
+      collection(this.db, MEDIA_METADATA_COLLECTION),
+      where("url", "==", url),
+      limit(1)
+    );
+    try {
+      const querySnapshot = await getDocs(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data();
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
+      }
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
+    } catch (error) {
+      console.error("[MediaService] Error fetching metadata by URL:", error);
+      throw error;
+    }
+  }
+  /**
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
+   */
+  async deleteMedia(mediaId) {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
+      );
+      return;
+    }
+    const storageFileRef = ref(this.storage, metadata.path);
+    try {
+      await deleteObject(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await deleteDoc(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+      );
+    } catch (error) {
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Update media access level. This involves moving the file in Firebase Storage
+   * to a new path reflecting the new access level, and updating its metadata.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata, or null if metadata not found.
+   */
+  async updateMediaAccessLevel(mediaId, newAccessLevel) {
+    var _a;
+    console.log(
+      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+    );
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+      );
+      return null;
+    }
+    if (metadata.accessLevel === newAccessLevel) {
+      console.log(
+        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
+      );
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      try {
+        await updateDoc(metadataDocRef, { updatedAt: Timestamp.now() });
+        return { ...metadata, updatedAt: Timestamp.now() };
+      } catch (error) {
+        console.error(
+          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    const oldStoragePath = metadata.path;
+    const fileNamePart = `${metadata.id}-${metadata.name}`;
+    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+    console.log(
+      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+    );
+    const oldStorageFileRef = ref(this.storage, oldStoragePath);
+    const newStorageFileRef = ref(this.storage, newStoragePath);
+    try {
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await getBytes(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await uploadBytes(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await getDownloadURL(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
+      );
+      const updateData = {
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: Timestamp.now()
+      };
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
+      );
+      await updateDoc(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await deleteObject(oldStorageFileRef);
+        console.log(
+          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
+        );
+      } catch (deleteError) {
+        console.error(
+          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
+          deleteError
+        );
+      }
+      return { ...metadata, ...updateData };
+    } catch (error) {
+      console.error(
+        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
+        error
+      );
+      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
+        console.warn(
+          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
+        );
+        try {
+          await deleteObject(newStorageFileRef);
+          console.warn(
+            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
+          );
+        } catch (cleanupError) {
+          console.error(
+            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
+            cleanupError
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
+   */
+  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints = [where("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push(where("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push(where("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push(orderBy("createdAt", "desc"));
+    if (count) {
+      qConstraints.push(limit(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = query(
+      collection(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+    try {
+      const querySnapshot = await getDocs(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc34) => doc34.data()
+      );
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
+    } catch (error) {
+      console.error("[MediaService] Error listing media:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
+   */
+  async getMediaDownloadUrl(mediaId) {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
+    }
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
+  }
+};
+
 // src/services/patient/utils/profile.utils.ts
 import {
-  getDoc as getDoc5,
-  setDoc as setDoc4,
-  updateDoc as updateDoc3,
+  getDoc as getDoc6,
+  setDoc as setDoc5,
+  updateDoc as updateDoc4,
   arrayUnion as arrayUnion2,
   arrayRemove as arrayRemove2,
   serverTimestamp as serverTimestamp4,
   increment,
-  Timestamp as Timestamp4,
-  collection as collection3,
-  query as query3,
-  where as where3,
-  getDocs as getDocs3,
-  limit as limit2,
+  Timestamp as Timestamp5,
+  collection as collection4,
+  query as query4,
+  where as where4,
+  getDocs as getDocs4,
+  limit as limit3,
   startAfter as startAfter2,
-  doc as doc4
+  doc as doc5
 } from "firebase/firestore";
-import { ref, uploadBytes, getDownloadURL, deleteObject } from "firebase/storage";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/types/patient/medical-info.types.ts
 var PATIENT_MEDICAL_INFO_COLLECTION = "medical_info";
@@ -1040,11 +1357,19 @@ var Gender = /* @__PURE__ */ ((Gender2) => {
 })(Gender || {});
 
 // src/validations/patient.schema.ts
-import { z as z6 } from "zod";
-import { Timestamp as Timestamp2 } from "firebase/firestore";
+import { z as z7 } from "zod";
+import { Timestamp as Timestamp3 } from "firebase/firestore";
+
+// src/validations/media.schema.ts
+import { z as z4 } from "zod";
+var mediaResourceSchema = z4.union([
+  z4.string().url(),
+  z4.instanceof(File),
+  z4.instanceof(Blob)
+]);
 
 // src/validations/patient/medical-info.schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/types/patient/allergies.ts
 var AllergyType = /* @__PURE__ */ ((AllergyType2) => {
@@ -1133,80 +1458,80 @@ var Contraindication = /* @__PURE__ */ ((Contraindication2) => {
 })(Contraindication || {});
 
 // src/validations/common.schema.ts
-import { z as z4 } from "zod";
-import { Timestamp } from "firebase/firestore";
-var timestampSchema2 = z4.union([
-  z4.object({
-    seconds: z4.number(),
-    nanoseconds: z4.number()
+import { z as z5 } from "zod";
+import { Timestamp as Timestamp2 } from "firebase/firestore";
+var timestampSchema2 = z5.union([
+  z5.object({
+    seconds: z5.number(),
+    nanoseconds: z5.number()
   }),
-  z4.instanceof(Timestamp)
+  z5.instanceof(Timestamp2)
 ]).transform((data) => {
-  if (data instanceof Timestamp) {
+  if (data instanceof Timestamp2) {
     return data;
   }
-  return new Timestamp(data.seconds, data.nanoseconds);
+  return new Timestamp2(data.seconds, data.nanoseconds);
 });
 
 // src/validations/patient/medical-info.schema.ts
-var allergySubtypeSchema = z5.union([
-  z5.nativeEnum(MedicationAllergySubtype),
-  z5.nativeEnum(FoodAllergySubtype),
-  z5.nativeEnum(EnvironmentalAllergySubtype),
-  z5.nativeEnum(CosmeticAllergySubtype),
-  z5.literal("other")
+var allergySubtypeSchema = z6.union([
+  z6.nativeEnum(MedicationAllergySubtype),
+  z6.nativeEnum(FoodAllergySubtype),
+  z6.nativeEnum(EnvironmentalAllergySubtype),
+  z6.nativeEnum(CosmeticAllergySubtype),
+  z6.literal("other")
 ]);
-var allergySchema = z5.object({
-  type: z5.nativeEnum(AllergyType),
+var allergySchema = z6.object({
+  type: z6.nativeEnum(AllergyType),
   subtype: allergySubtypeSchema,
-  name: z5.string().optional().nullable(),
-  severity: z5.enum(["mild", "moderate", "severe"]).optional(),
-  reaction: z5.string().optional().nullable(),
+  name: z6.string().optional().nullable(),
+  severity: z6.enum(["mild", "moderate", "severe"]).optional(),
+  reaction: z6.string().optional().nullable(),
   diagnosed: timestampSchema2.optional().nullable(),
-  notes: z5.string().optional().nullable()
+  notes: z6.string().optional().nullable()
 });
-var vitalStatsSchema = z5.object({
-  height: z5.number().positive().optional(),
-  weight: z5.number().positive().optional(),
-  bloodType: z5.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
-  bloodPressure: z5.object({
-    systolic: z5.number().min(70).max(200),
-    diastolic: z5.number().min(40).max(130),
+var vitalStatsSchema = z6.object({
+  height: z6.number().positive().optional(),
+  weight: z6.number().positive().optional(),
+  bloodType: z6.enum(["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"]).optional(),
+  bloodPressure: z6.object({
+    systolic: z6.number().min(70).max(200),
+    diastolic: z6.number().min(40).max(130),
     lastMeasured: timestampSchema2
   }).optional()
 });
-var blockingConditionSchema = z5.object({
-  condition: z5.nativeEnum(BlockingCondition),
+var blockingConditionSchema = z6.object({
+  condition: z6.nativeEnum(BlockingCondition),
   diagnosedAt: timestampSchema2,
-  notes: z5.string().optional().nullable(),
-  isActive: z5.boolean()
+  notes: z6.string().optional().nullable(),
+  isActive: z6.boolean()
 });
-var contraindicationSchema = z5.object({
-  condition: z5.nativeEnum(Contraindication),
+var contraindicationSchema = z6.object({
+  condition: z6.nativeEnum(Contraindication),
   lastOccurrence: timestampSchema2,
-  frequency: z5.enum(["rare", "occasional", "frequent"]),
-  notes: z5.string().optional().nullable(),
-  isActive: z5.boolean()
+  frequency: z6.enum(["rare", "occasional", "frequent"]),
+  notes: z6.string().optional().nullable(),
+  isActive: z6.boolean()
 });
-var medicationSchema = z5.object({
-  name: z5.string().min(1),
-  dosage: z5.string().min(1),
-  frequency: z5.string().min(1),
+var medicationSchema = z6.object({
+  name: z6.string().min(1),
+  dosage: z6.string().min(1),
+  frequency: z6.string().min(1),
   startDate: timestampSchema2.optional().nullable(),
   endDate: timestampSchema2.optional().nullable(),
-  prescribedBy: z5.string().optional().nullable()
+  prescribedBy: z6.string().optional().nullable()
 });
-var patientMedicalInfoSchema = z5.object({
-  patientId: z5.string(),
+var patientMedicalInfoSchema = z6.object({
+  patientId: z6.string(),
   vitalStats: vitalStatsSchema,
-  blockingConditions: z5.array(blockingConditionSchema),
-  contraindications: z5.array(contraindicationSchema),
-  allergies: z5.array(allergySchema),
-  currentMedications: z5.array(medicationSchema),
-  emergencyNotes: z5.string().optional(),
+  blockingConditions: z6.array(blockingConditionSchema),
+  contraindications: z6.array(contraindicationSchema),
+  allergies: z6.array(allergySchema),
+  currentMedications: z6.array(medicationSchema),
+  emergencyNotes: z6.string().optional(),
   lastUpdated: timestampSchema2,
-  updatedBy: z5.string(),
-  verifiedBy: z5.string().optional(),
+  updatedBy: z6.string(),
+  verifiedBy: z6.string().optional(),
   verifiedAt: timestampSchema2.optional()
 });
 var createPatientMedicalInfoSchema = patientMedicalInfoSchema.omit({
@@ -1220,141 +1545,140 @@ var updatePatientMedicalInfoSchema = createPatientMedicalInfoSchema.partial();
 var updateVitalStatsSchema = vitalStatsSchema;
 var addAllergySchema = allergySchema;
 var updateAllergySchema = allergySchema.partial().extend({
-  allergyIndex: z5.number().min(0)
+  allergyIndex: z6.number().min(0)
 });
 var addBlockingConditionSchema = blockingConditionSchema;
 var updateBlockingConditionSchema = blockingConditionSchema.partial().extend({
-  conditionIndex: z5.number().min(0)
+  conditionIndex: z6.number().min(0)
 });
 var addContraindicationSchema = contraindicationSchema;
 var updateContraindicationSchema = contraindicationSchema.partial().extend({
-  contraindicationIndex: z5.number().min(0)
+  contraindicationIndex: z6.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
 var updateMedicationSchema = medicationSchema.partial().extend({
-  medicationIndex: z5.number().min(0)
+  medicationIndex: z6.number().min(0)
 });
 
 // src/validations/patient.schema.ts
-var locationDataSchema = z6.object({
-  latitude: z6.number().min(-90).max(90),
-  longitude: z6.number().min(-180).max(180),
-  geohash: z6.string().optional()
+var locationDataSchema = z7.object({
+  latitude: z7.number().min(-90).max(90),
+  longitude: z7.number().min(-180).max(180),
+  geohash: z7.string().optional()
 });
-var addressDataSchema = z6.object({
-  address: z6.string(),
-  city: z6.string(),
-  country: z6.string(),
-  postalCode: z6.string()
+var addressDataSchema = z7.object({
+  address: z7.string(),
+  city: z7.string(),
+  country: z7.string(),
+  postalCode: z7.string()
 });
-var emergencyContactSchema = z6.object({
-  name: z6.string(),
-  relationship: z6.string(),
-  phoneNumber: z6.string(),
-  isNotifiable: z6.boolean()
+var emergencyContactSchema = z7.object({
+  name: z7.string(),
+  relationship: z7.string(),
+  phoneNumber: z7.string(),
+  isNotifiable: z7.boolean()
 });
-var gamificationSchema = z6.object({
-  level: z6.number(),
-  points: z6.number()
+var gamificationSchema = z7.object({
+  level: z7.number(),
+  points: z7.number()
 });
-var patientLocationInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
+var patientLocationInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
   locationData: locationDataSchema,
-  createdAt: z6.instanceof(Timestamp2),
-  updatedAt: z6.instanceof(Timestamp2)
+  createdAt: z7.instanceof(Timestamp3),
+  updatedAt: z7.instanceof(Timestamp3)
 });
-var createPatientLocationInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
+var createPatientLocationInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
   locationData: locationDataSchema
 });
-var patientSensitiveInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
-  photoUrl: z6.string().optional(),
-  firstName: z6.string().min(2),
-  lastName: z6.string().min(2),
-  dateOfBirth: z6.instanceof(Timestamp2).nullable(),
-  gender: z6.nativeEnum(Gender),
-  email: z6.string().email().optional(),
-  phoneNumber: z6.string().optional(),
-  alternativePhoneNumber: z6.string().optional(),
+var patientSensitiveInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
+  firstName: z7.string().min(2),
+  lastName: z7.string().min(2),
+  dateOfBirth: z7.instanceof(Timestamp3).nullable(),
+  gender: z7.nativeEnum(Gender),
+  email: z7.string().email().optional(),
+  phoneNumber: z7.string().optional(),
+  alternativePhoneNumber: z7.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: z6.array(emergencyContactSchema).optional(),
-  createdAt: z6.instanceof(Timestamp2),
-  updatedAt: z6.instanceof(Timestamp2)
+  emergencyContacts: z7.array(emergencyContactSchema).optional(),
+  createdAt: z7.instanceof(Timestamp3),
+  updatedAt: z7.instanceof(Timestamp3)
 });
-var patientDoctorSchema = z6.object({
-  userRef: z6.string(),
-  assignedAt: z6.instanceof(Timestamp2),
-  assignedBy: z6.string().optional(),
-  isActive: z6.boolean(),
-  notes: z6.string().optional()
+var patientDoctorSchema = z7.object({
+  userRef: z7.string(),
+  assignedAt: z7.instanceof(Timestamp3),
+  assignedBy: z7.string().optional(),
+  isActive: z7.boolean(),
+  notes: z7.string().optional()
 });
-var patientClinicSchema = z6.object({
-  clinicId: z6.string(),
-  assignedAt: z6.instanceof(Timestamp2),
-  assignedBy: z6.string().optional(),
-  isActive: z6.boolean(),
-  notes: z6.string().optional()
+var patientClinicSchema = z7.object({
+  clinicId: z7.string(),
+  assignedAt: z7.instanceof(Timestamp3),
+  assignedBy: z7.string().optional(),
+  isActive: z7.boolean(),
+  notes: z7.string().optional()
 });
-var patientProfileSchema = z6.object({
-  id: z6.string(),
-  userRef: z6.string(),
-  displayName: z6.string(),
-  profilePhoto: z6.string().url().nullable(),
+var patientProfileSchema = z7.object({
+  id: z7.string(),
+  userRef: z7.string(),
+  displayName: z7.string(),
   gamification: gamificationSchema,
-  expoTokens: z6.array(z6.string()),
-  isActive: z6.boolean(),
-  isVerified: z6.boolean(),
-  doctors: z6.array(patientDoctorSchema),
-  clinics: z6.array(patientClinicSchema),
-  doctorIds: z6.array(z6.string()),
-  clinicIds: z6.array(z6.string()),
-  createdAt: z6.instanceof(Timestamp2),
-  updatedAt: z6.instanceof(Timestamp2)
+  expoTokens: z7.array(z7.string()),
+  isActive: z7.boolean(),
+  isVerified: z7.boolean(),
+  phoneNumber: z7.string().nullable().optional(),
+  dateOfBirth: z7.instanceof(Timestamp3).nullable().optional(),
+  doctors: z7.array(patientDoctorSchema),
+  clinics: z7.array(patientClinicSchema),
+  doctorIds: z7.array(z7.string()),
+  clinicIds: z7.array(z7.string()),
+  createdAt: z7.instanceof(Timestamp3),
+  updatedAt: z7.instanceof(Timestamp3)
 });
-var createPatientProfileSchema = z6.object({
-  userRef: z6.string(),
-  displayName: z6.string(),
-  profilePhoto: z6.string().url().nullable().optional(),
-  expoTokens: z6.array(z6.string()),
+var createPatientProfileSchema = z7.object({
+  userRef: z7.string(),
+  displayName: z7.string(),
+  expoTokens: z7.array(z7.string()),
   gamification: gamificationSchema.optional(),
-  isActive: z6.boolean(),
-  isVerified: z6.boolean(),
-  doctors: z6.array(patientDoctorSchema).optional(),
-  clinics: z6.array(patientClinicSchema).optional(),
-  doctorIds: z6.array(z6.string()).optional(),
-  clinicIds: z6.array(z6.string()).optional()
+  isActive: z7.boolean(),
+  isVerified: z7.boolean(),
+  doctors: z7.array(patientDoctorSchema).optional(),
+  clinics: z7.array(patientClinicSchema).optional(),
+  doctorIds: z7.array(z7.string()).optional(),
+  clinicIds: z7.array(z7.string()).optional()
 });
-var createPatientSensitiveInfoSchema = z6.object({
-  patientId: z6.string(),
-  userRef: z6.string(),
-  photoUrl: z6.string().optional(),
-  firstName: z6.string().min(2),
-  lastName: z6.string().min(2),
-  dateOfBirth: z6.instanceof(Timestamp2).nullable(),
-  gender: z6.nativeEnum(Gender),
-  email: z6.string().email().optional(),
-  phoneNumber: z6.string().optional(),
-  alternativePhoneNumber: z6.string().optional(),
+var createPatientSensitiveInfoSchema = z7.object({
+  patientId: z7.string(),
+  userRef: z7.string(),
+  photoUrl: mediaResourceSchema.nullable().optional(),
+  firstName: z7.string().min(2),
+  lastName: z7.string().min(2),
+  dateOfBirth: z7.instanceof(Timestamp3).nullable(),
+  gender: z7.nativeEnum(Gender),
+  email: z7.string().email().optional(),
+  phoneNumber: z7.string().optional(),
+  alternativePhoneNumber: z7.string().optional(),
   addressData: addressDataSchema.optional(),
-  emergencyContacts: z6.array(emergencyContactSchema).optional()
+  emergencyContacts: z7.array(emergencyContactSchema).optional()
 });
-var searchPatientsSchema = z6.object({
-  clinicId: z6.string().optional(),
-  practitionerId: z6.string().optional()
+var searchPatientsSchema = z7.object({
+  clinicId: z7.string().optional(),
+  practitionerId: z7.string().optional()
 }).refine((data) => data.clinicId || data.practitionerId, {
   message: "At least one of clinicId or practitionerId must be provided",
   path: []
   // Optional: specify a path like ['clinicId'] or ['practitionerId']
 });
-var requesterInfoSchema = z6.object({
-  id: z6.string(),
-  role: z6.enum(["clinic_admin", "practitioner"]),
-  associatedClinicId: z6.string().optional(),
-  associatedPractitionerId: z6.string().optional()
+var requesterInfoSchema = z7.object({
+  id: z7.string(),
+  role: z7.enum(["clinic_admin", "practitioner"]),
+  associatedClinicId: z7.string().optional(),
+  associatedPractitionerId: z7.string().optional()
 }).refine(
   (data) => {
     if (data.role === "clinic_admin") {
@@ -1372,47 +1696,79 @@ var requesterInfoSchema = z6.object({
 
 // src/services/patient/utils/docs.utils.ts
 import {
-  doc,
-  collection,
-  query,
-  where,
-  getDocs,
-  getDoc as getDoc2
+  doc as doc2,
+  collection as collection2,
+  query as query2,
+  where as where2,
+  getDocs as getDocs2,
+  getDoc as getDoc3
 } from "firebase/firestore";
 
 // src/services/patient/utils/sensitive.utils.ts
 import {
-  getDoc,
-  updateDoc,
-  setDoc,
+  getDoc as getDoc2,
+  updateDoc as updateDoc2,
+  setDoc as setDoc2,
   serverTimestamp
 } from "firebase/firestore";
-import { z as z7 } from "zod";
-var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
+import { z as z8 } from "zod";
+var handlePhotoUrlUpload = async (photoUrl, patientId, mediaService) => {
+  if (!photoUrl) {
+    return null;
+  }
+  if (typeof photoUrl === "string") {
+    return photoUrl;
+  }
+  if (photoUrl instanceof File || photoUrl instanceof Blob) {
+    const mediaMetadata = await mediaService.uploadMedia(
+      photoUrl,
+      patientId,
+      // Using patientId as ownerId
+      "private" /* PRIVATE */,
+      // Sensitive info should be private
+      "patient_sensitive_photos",
+      photoUrl instanceof File ? photoUrl.name : `sensitive_photo_${patientId}`
+    );
+    return mediaMetadata.url;
+  }
+  return null;
+};
+var createSensitiveInfoUtil = async (db, data, requesterUserId, mediaService) => {
   try {
     if (data.userRef !== requesterUserId) {
       throw new Error("Only patient can create their sensitive information");
     }
     const validatedData = createPatientSensitiveInfoSchema.parse(data);
-    const sensitiveDoc = await getDoc(
+    const sensitiveDoc = await getDoc2(
       getSensitiveInfoDocRef(db, data.patientId)
     );
     if (sensitiveDoc.exists()) {
       throw new Error("Sensitive information already exists for this patient");
     }
+    let processedPhotoUrl = null;
+    if (validatedData.photoUrl && mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        validatedData.photoUrl,
+        data.patientId,
+        mediaService
+      );
+    } else if (typeof validatedData.photoUrl === "string") {
+      processedPhotoUrl = validatedData.photoUrl;
+    }
     const sensitiveInfoData = {
       ...validatedData,
+      photoUrl: processedPhotoUrl,
       createdAt: serverTimestamp(),
       updatedAt: serverTimestamp()
     };
-    await setDoc(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
-    const createdDoc = await getDoc(getSensitiveInfoDocRef(db, data.patientId));
+    await setDoc2(getSensitiveInfoDocRef(db, data.patientId), sensitiveInfoData);
+    const createdDoc = await getDoc2(getSensitiveInfoDocRef(db, data.patientId));
     if (!createdDoc.exists()) {
       throw new Error("Failed to create sensitive information");
     }
     return createdDoc.data();
   } catch (error) {
-    if (error instanceof z7.ZodError) {
+    if (error instanceof z8.ZodError) {
       throw new Error("Invalid sensitive info data: " + error.message);
     }
     throw error;
@@ -1420,17 +1776,32 @@ var createSensitiveInfoUtil = async (db, data, requesterUserId) => {
 };
 var getSensitiveInfoUtil = async (db, patientId, requesterUserId) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
-  const sensitiveDoc = await getDoc(getSensitiveInfoDocRef(db, patientId));
+  const sensitiveDoc = await getDoc2(getSensitiveInfoDocRef(db, patientId));
   return sensitiveDoc.exists() ? sensitiveDoc.data() : null;
 };
-var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
+var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId, mediaService) => {
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
+  let processedPhotoUrl = void 0;
+  if (data.photoUrl !== void 0) {
+    if (mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        data.photoUrl,
+        patientId,
+        mediaService
+      );
+    } else if (typeof data.photoUrl === "string" || data.photoUrl === null) {
+      processedPhotoUrl = data.photoUrl;
+    } else {
+      throw new Error("MediaService required to process photo upload");
+    }
+  }
   const updateData = {
     ...data,
+    photoUrl: processedPhotoUrl,
     updatedAt: serverTimestamp()
   };
-  await updateDoc(getSensitiveInfoDocRef(db, patientId), updateData);
-  const updatedDoc = await getDoc(getSensitiveInfoDocRef(db, patientId));
+  await updateDoc2(getSensitiveInfoDocRef(db, patientId), updateData);
+  const updatedDoc = await getDoc2(getSensitiveInfoDocRef(db, patientId));
   if (!updatedDoc.exists()) {
     throw new Error("Failed to retrieve updated sensitive information");
   }
@@ -1439,21 +1810,21 @@ var updateSensitiveInfoUtil = async (db, patientId, data, requesterUserId) => {
 
 // src/services/patient/utils/docs.utils.ts
 var getPatientDocRef = (db, patientId) => {
-  return doc(db, PATIENTS_COLLECTION, patientId);
+  return doc2(db, PATIENTS_COLLECTION, patientId);
 };
 var getPatientDocRefByUserRef = async (db, userRef) => {
-  const patientsRef = collection(db, PATIENTS_COLLECTION);
-  const q = query(patientsRef, where("userRef", "==", userRef));
-  const querySnapshot = await getDocs(q);
+  const patientsRef = collection2(db, PATIENTS_COLLECTION);
+  const q = query2(patientsRef, where2("userRef", "==", userRef));
+  const querySnapshot = await getDocs2(q);
   if (querySnapshot.empty) {
     throw new Error("Patient profile not found");
   }
-  return doc(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
+  return doc2(db, PATIENTS_COLLECTION, querySnapshot.docs[0].id);
 };
 var getSensitiveInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_SENSITIVE_INFO_COLLECTION}/${patientId}`;
   console.log(`[getSensitiveInfoDocRef] Creating reference with path: ${path}`);
-  return doc(
+  return doc2(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1464,7 +1835,7 @@ var getSensitiveInfoDocRef = (db, patientId) => {
 var getLocationInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_LOCATION_INFO_COLLECTION}/${patientId}`;
   console.log(`[getLocationInfoDocRef] Creating reference with path: ${path}`);
-  return doc(
+  return doc2(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1475,7 +1846,7 @@ var getLocationInfoDocRef = (db, patientId) => {
 var getMedicalInfoDocRef = (db, patientId) => {
   const path = `${PATIENTS_COLLECTION}/${patientId}/${PATIENT_MEDICAL_INFO_COLLECTION}/${patientId}`;
   console.log(`[getMedicalInfoDocRef] Creating reference with path: ${path}`);
-  return doc(
+  return doc2(
     db,
     PATIENTS_COLLECTION,
     patientId,
@@ -1492,7 +1863,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
     console.log(
       `[initSensitiveInfoDocIfNotExists] Got document reference: ${sensitiveInfoRef.path}`
     );
-    const sensitiveDoc = await getDoc2(sensitiveInfoRef);
+    const sensitiveDoc = await getDoc3(sensitiveInfoRef);
     console.log(
       `[initSensitiveInfoDocIfNotExists] Document exists: ${sensitiveDoc.exists()}`
     );
@@ -1516,7 +1887,7 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
         )
       );
       await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef);
-      const verifyDoc = await getDoc2(sensitiveInfoRef);
+      const verifyDoc = await getDoc3(sensitiveInfoRef);
       console.log(
         `[initSensitiveInfoDocIfNotExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1534,24 +1905,24 @@ var initSensitiveInfoDocIfNotExists = async (db, patientId, userRef) => {
 
 // src/services/patient/utils/medical.utils.ts
 import {
-  getDoc as getDoc4,
-  updateDoc as updateDoc2,
-  setDoc as setDoc3,
+  getDoc as getDoc5,
+  updateDoc as updateDoc3,
+  setDoc as setDoc4,
   serverTimestamp as serverTimestamp3,
   arrayUnion,
-  Timestamp as Timestamp3
+  Timestamp as Timestamp4
 } from "firebase/firestore";
 
 // src/services/patient/utils/practitioner.utils.ts
 import {
-  collection as collection2,
-  query as query2,
-  where as where2,
-  getDocs as getDocs2,
-  limit,
+  collection as collection3,
+  query as query3,
+  where as where3,
+  getDocs as getDocs3,
+  limit as limit2,
   startAfter,
-  doc as doc2,
-  getDoc as getDoc3
+  doc as doc3,
+  getDoc as getDoc4
 } from "firebase/firestore";
 
 // src/types/practitioner/index.ts
@@ -1577,23 +1948,23 @@ var getPatientsByPractitionerUtil = async (db, practitionerId, options) => {
       `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
       options
     );
-    const patientsCollection = collection2(db, PATIENTS_COLLECTION);
+    const patientsCollection = collection3(db, PATIENTS_COLLECTION);
     const constraints = [
-      where2("doctorIds", "array-contains", practitionerId)
+      where3("doctorIds", "array-contains", practitionerId)
     ];
-    let q = query2(patientsCollection, ...constraints);
+    let q = query3(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = query2(q, limit(options.limit));
+      q = query3(q, limit2(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await getDoc3(
-        doc2(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await getDoc4(
+        doc3(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = query2(q, startAfter(startAfterDoc));
+        q = query3(q, startAfter(startAfterDoc));
       }
     }
-    const patientsSnapshot = await getDocs2(q);
+    const patientsSnapshot = await getDocs3(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -1626,7 +1997,7 @@ var getPatientsByPractitionerWithDetailsUtil = async (db, practitionerId, option
     const patientProfilesWithDetails = await Promise.all(
       patientProfiles.map(async (profile) => {
         try {
-          const sensitiveInfoDoc = await getDoc3(
+          const sensitiveInfoDoc = await getDoc4(
             getSensitiveInfoDocRef(db, profile.id)
           );
           const sensitiveInfo = sensitiveInfoDoc.exists() ? sensitiveInfoDoc.data() : void 0;
@@ -1662,13 +2033,13 @@ var getPractitionerProfileByUserRef = async (db, userRef) => {
     console.log(
       `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
     );
-    const practitionersCollection = collection2(db, PRACTITIONERS_COLLECTION);
-    const q = query2(
+    const practitionersCollection = collection3(db, PRACTITIONERS_COLLECTION);
+    const q = query3(
       practitionersCollection,
-      where2("userRef", "==", userRef),
-      limit(1)
+      where3("userRef", "==", userRef),
+      limit2(1)
     );
-    const querySnapshot = await getDocs2(q);
+    const querySnapshot = await getDocs3(q);
     if (querySnapshot.empty) {
       console.log(
         `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
@@ -1702,7 +2073,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
     console.log(
       `[ensureMedicalInfoExists] Got document reference: ${medicalInfoRef.path}`
     );
-    const medicalInfoDoc = await getDoc4(medicalInfoRef);
+    const medicalInfoDoc = await getDoc5(medicalInfoRef);
     console.log(
       `[ensureMedicalInfoExists] Document exists: ${medicalInfoDoc.exists()}`
     );
@@ -1720,9 +2091,9 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
           (key, value) => value && typeof value === "object" && value.constructor && value.constructor.name === "Object" ? "[serverTimestamp]" : value
         )
       );
-      await setDoc3(medicalInfoRef, defaultData);
+      await setDoc4(medicalInfoRef, defaultData);
       console.log(`[ensureMedicalInfoExists] Document created successfully`);
-      const verifyDoc = await getDoc4(medicalInfoRef);
+      const verifyDoc = await getDoc5(medicalInfoRef);
       console.log(
         `[ensureMedicalInfoExists] Verification - document exists: ${verifyDoc.exists()}`
       );
@@ -1738,7 +2109,7 @@ var ensureMedicalInfoExists = async (db, patientId, userRef) => {
 };
 var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
   var _a;
-  const patientDoc = await getDoc4(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) {
     throw new Error("Patient profile not found");
   }
@@ -1771,17 +2142,17 @@ var checkMedicalAccessUtil = async (db, patientId, userRef, userRoles) => {
 var createMedicalInfoUtil = async (db, patientId, data, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const validatedData = createPatientMedicalInfoSchema.parse(data);
-  await setDoc3(getMedicalInfoDocRef(db, patientId), {
+  await setDoc4(getMedicalInfoDocRef(db, patientId), {
     ...validatedData,
     patientId,
-    lastUpdated: Timestamp3.now(),
+    lastUpdated: Timestamp4.now(),
     updatedBy: userRef
   });
 };
 var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
   await checkMedicalAccessUtil(db, patientId, userRef, userRoles);
   const docRef = getMedicalInfoDocRef(db, patientId);
-  const snapshot = await getDoc4(docRef);
+  const snapshot = await getDoc5(docRef);
   if (!snapshot.exists()) {
     throw new Error("Medicinske informacije nisu prona\u0111ene");
   }
@@ -1790,7 +2161,7 @@ var getMedicalInfoUtil = async (db, patientId, userRef, userRoles) => {
 var updateVitalStatsUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = updateVitalStatsSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     vitalStats: validatedData,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1799,7 +2170,7 @@ var updateVitalStatsUtil = async (db, patientId, data, userRef) => {
 var addAllergyUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addAllergySchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     allergies: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1808,7 +2179,7 @@ var addAllergyUtil = async (db, patientId, data, userRef) => {
 var updateAllergyUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
-  const docSnapshot = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const docSnapshot = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!docSnapshot.exists()) throw new Error("Medical info not found");
   const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1819,14 +2190,14 @@ var updateAllergyUtil = async (db, patientId, data, userRef) => {
     ...updatedAllergies[allergyIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (allergyIndex >= medicalInfo.allergies.length) {
@@ -1835,7 +2206,7 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
   const updatedAllergies = medicalInfo.allergies.filter(
     (_, index) => index !== allergyIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     allergies: updatedAllergies,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1844,7 +2215,7 @@ var removeAllergyUtil = async (db, patientId, allergyIndex, userRef) => {
 var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addBlockingConditionSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1853,7 +2224,7 @@ var addBlockingConditionUtil = async (db, patientId, data, userRef) => {
 var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateBlockingConditionSchema.parse(data);
   const { conditionIndex, ...updateData } = validatedData;
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -1864,14 +2235,14 @@ var updateBlockingConditionUtil = async (db, patientId, data, userRef) => {
     ...updatedConditions[conditionIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (conditionIndex >= medicalInfo.blockingConditions.length) {
@@ -1880,7 +2251,7 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef)
   const updatedConditions = medicalInfo.blockingConditions.filter(
     (_, index) => index !== conditionIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     blockingConditions: updatedConditions,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1889,7 +2260,7 @@ var removeBlockingConditionUtil = async (db, patientId, conditionIndex, userRef)
 var addContraindicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addContraindicationSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     contraindications: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1898,7 +2269,7 @@ var addContraindicationUtil = async (db, patientId, data, userRef) => {
 var updateContraindicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateContraindicationSchema.parse(data);
   const { contraindicationIndex, ...updateData } = validatedData;
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -1909,14 +2280,14 @@ var updateContraindicationUtil = async (db, patientId, data, userRef) => {
     ...updatedContraindications[contraindicationIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeContraindicationUtil = async (db, patientId, contraindicationIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (contraindicationIndex >= medicalInfo.contraindications.length) {
@@ -1925,7 +2296,7 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, us
   const updatedContraindications = medicalInfo.contraindications.filter(
     (_, index) => index !== contraindicationIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     contraindications: updatedContraindications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1934,7 +2305,7 @@ var removeContraindicationUtil = async (db, patientId, contraindicationIndex, us
 var addMedicationUtil = async (db, patientId, data, userRef) => {
   await ensureMedicalInfoExists(db, patientId, userRef);
   const validatedData = addMedicationSchema.parse(data);
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     currentMedications: arrayUnion(validatedData),
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1943,7 +2314,7 @@ var addMedicationUtil = async (db, patientId, data, userRef) => {
 var updateMedicationUtil = async (db, patientId, data, userRef) => {
   const validatedData = updateMedicationSchema.parse(data);
   const { medicationIndex, ...updateData } = validatedData;
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -1954,14 +2325,14 @@ var updateMedicationUtil = async (db, patientId, data, userRef) => {
     ...updatedMedications[medicationIndex],
     ...updateData
   };
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
   });
 };
 var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
-  const doc34 = await getDoc4(getMedicalInfoDocRef(db, patientId));
+  const doc34 = await getDoc5(getMedicalInfoDocRef(db, patientId));
   if (!doc34.exists()) throw new Error("Medical info not found");
   const medicalInfo = doc34.data();
   if (medicationIndex >= medicalInfo.currentMedications.length) {
@@ -1970,7 +2341,7 @@ var removeMedicationUtil = async (db, patientId, medicationIndex, userRef) => {
   const updatedMedications = medicalInfo.currentMedications.filter(
     (_, index) => index !== medicationIndex
   );
-  await updateDoc2(getMedicalInfoDocRef(db, patientId), {
+  await updateDoc3(getMedicalInfoDocRef(db, patientId), {
     currentMedications: updatedMedications,
     lastUpdated: serverTimestamp3(),
     updatedBy: userRef
@@ -1989,7 +2360,6 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       id: patientId,
       userRef: validatedData.userRef,
       displayName: validatedData.displayName,
-      profilePhoto: validatedData.profilePhoto || null,
       expoTokens: validatedData.expoTokens,
       gamification: validatedData.gamification || {
         level: 1,
@@ -2006,10 +2376,10 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
     };
     patientProfileSchema.parse({
       ...patientData,
-      createdAt: Timestamp4.now(),
-      updatedAt: Timestamp4.now()
+      createdAt: Timestamp5.now(),
+      updatedAt: Timestamp5.now()
     });
-    await setDoc4(getPatientDocRef(db, patientId), patientData);
+    await setDoc5(getPatientDocRef(db, patientId), patientData);
     console.log(`[createPatientProfileUtil] Creating sensitive info document`);
     let sensitiveInfoSuccess = false;
     try {
@@ -2023,69 +2393,91 @@ var createPatientProfileUtil = async (db, data, generateId2) => {
       );
       sensitiveInfoSuccess = true;
     } catch (sensitiveError) {
-      console.error(`[createPatientProfileUtil] Error creating sensitive info:`, sensitiveError);
+      console.error(
+        `[createPatientProfileUtil] Error creating sensitive info:`,
+        sensitiveError
+      );
     }
     console.log(`[createPatientProfileUtil] Creating medical info document`);
     let medicalInfoSuccess = false;
     try {
       await ensureMedicalInfoExists(db, patientId, validatedData.userRef);
-      console.log(`[createPatientProfileUtil] Medical info document created successfully`);
+      console.log(
+        `[createPatientProfileUtil] Medical info document created successfully`
+      );
       medicalInfoSuccess = true;
     } catch (medicalError) {
-      console.error(`[createPatientProfileUtil] Error creating medical info:`, medicalError);
+      console.error(
+        `[createPatientProfileUtil] Error creating medical info:`,
+        medicalError
+      );
     }
     if (!sensitiveInfoSuccess || !medicalInfoSuccess) {
-      console.log(`[createPatientProfileUtil] Using fallback method to create documents`);
+      console.log(
+        `[createPatientProfileUtil] Using fallback method to create documents`
+      );
       try {
         await testCreateSubDocuments(db, patientId, validatedData.userRef);
-        console.log(`[createPatientProfileUtil] Fallback method completed successfully`);
+        console.log(
+          `[createPatientProfileUtil] Fallback method completed successfully`
+        );
       } catch (fallbackError) {
-        console.error(`[createPatientProfileUtil] Fallback method failed:`, fallbackError);
+        console.error(
+          `[createPatientProfileUtil] Fallback method failed:`,
+          fallbackError
+        );
       }
     }
     console.log(`[createPatientProfileUtil] Verifying patient document exists`);
-    const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
+    const patientDoc = await getDoc6(getPatientDocRef(db, patientId));
     if (!patientDoc.exists()) {
-      console.error(`[createPatientProfileUtil] Patient document not found after creation`);
+      console.error(
+        `[createPatientProfileUtil] Patient document not found after creation`
+      );
       throw new Error("Failed to create patient profile");
     }
-    console.log(`[createPatientProfileUtil] Patient profile creation completed successfully`);
+    console.log(
+      `[createPatientProfileUtil] Patient profile creation completed successfully`
+    );
     return patientDoc.data();
   } catch (error) {
-    console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
-    if (error instanceof z8.ZodError) {
+    console.error(
+      `[createPatientProfileUtil] Error in patient profile creation:`,
+      error
+    );
+    if (error instanceof z9.ZodError) {
       throw new Error("Invalid patient data: " + error.message);
     }
     throw error;
   }
 };
 var getPatientProfileUtil = async (db, patientId) => {
-  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc6(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? patientDoc.data() : null;
 };
 var getPatientProfileByUserRefUtil = async (db, userRef) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await getDoc5(docRef);
+    const patientDoc = await getDoc6(docRef);
     return patientDoc.exists() ? patientDoc.data() : null;
   } catch (error) {
     return null;
   }
 };
 var addExpoTokenUtil = async (db, patientId, token) => {
-  await updateDoc3(getPatientDocRef(db, patientId), {
+  await updateDoc4(getPatientDocRef(db, patientId), {
     expoTokens: arrayUnion2(token),
     updatedAt: serverTimestamp4()
   });
 };
 var removeExpoTokenUtil = async (db, patientId, token) => {
-  await updateDoc3(getPatientDocRef(db, patientId), {
+  await updateDoc4(getPatientDocRef(db, patientId), {
     expoTokens: arrayRemove2(token),
     updatedAt: serverTimestamp4()
   });
 };
 var addPointsUtil = async (db, patientId, points) => {
-  await updateDoc3(getPatientDocRef(db, patientId), {
+  await updateDoc4(getPatientDocRef(db, patientId), {
     "gamification.points": increment(points),
     updatedAt: serverTimestamp4()
   });
@@ -2096,8 +2488,8 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
       ...data,
       updatedAt: serverTimestamp4()
     };
-    await updateDoc3(getPatientDocRef(db, patientId), updateData);
-    const updatedDoc = await getDoc5(getPatientDocRef(db, patientId));
+    await updateDoc4(getPatientDocRef(db, patientId), updateData);
+    const updatedDoc = await getDoc6(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
       throw new Error("Patient profile not found after update");
     }
@@ -2110,7 +2502,7 @@ var updatePatientProfileUtil = async (db, patientId, data) => {
 var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
-    const patientDoc = await getDoc5(docRef);
+    const patientDoc = await getDoc6(docRef);
     if (!patientDoc.exists()) {
       throw new Error("Patient profile not found");
     }
@@ -2118,49 +2510,10 @@ var updatePatientProfileByUserRefUtil = async (db, userRef, data) => {
     return updatePatientProfileUtil(db, patientData.id, data);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to update patient profile by user ref: ${errorMessage}`);
-  }
-};
-var uploadProfilePhotoUtil = async (storage, patientId, file) => {
-  const photoRef = ref(storage, `patient-photos/${patientId}/profile-photo`);
-  await uploadBytes(photoRef, file);
-  return getDownloadURL(photoRef);
-};
-var updateProfilePhotoUtil = async (storage, db, patientId, file) => {
-  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const oldPhotoRef = ref(storage, patientData.profilePhoto);
-      await deleteObject(oldPhotoRef);
-    } catch (error) {
-      console.warn("Failed to delete old profile photo:", error);
-    }
-  }
-  const newPhotoUrl = await uploadProfilePhotoUtil(storage, patientId, file);
-  await updateDoc3(getPatientDocRef(db, patientId), {
-    profilePhoto: newPhotoUrl,
-    updatedAt: serverTimestamp4()
-  });
-  return newPhotoUrl;
-};
-var deleteProfilePhotoUtil = async (storage, db, patientId) => {
-  const patientDoc = await getDoc5(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
-  const patientData = patientDoc.data();
-  if (patientData.profilePhoto) {
-    try {
-      const photoRef = ref(storage, patientData.profilePhoto);
-      await deleteObject(photoRef);
-    } catch (error) {
-      console.warn("Failed to delete profile photo:", error);
-    }
+    throw new Error(
+      `Failed to update patient profile by user ref: ${errorMessage}`
+    );
   }
-  await updateDoc3(getPatientDocRef(db, patientId), {
-    profilePhoto: null,
-    updatedAt: serverTimestamp4()
-  });
 };
 var testCreateSubDocuments = async (db, patientId, userRef) => {
   console.log(
@@ -2169,33 +2522,41 @@ var testCreateSubDocuments = async (db, patientId, userRef) => {
   try {
     console.log(`[testCreateSubDocuments] Testing sensitive info creation`);
     const sensitiveInfoRef = getSensitiveInfoDocRef(db, patientId);
-    console.log(`[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`);
+    console.log(
+      `[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`
+    );
     const defaultSensitiveInfo = {
       patientId,
       userRef,
       photoUrl: "",
       firstName: "Name",
       lastName: "Surname",
-      dateOfBirth: Timestamp4.now(),
+      dateOfBirth: Timestamp5.now(),
       gender: "prefer_not_to_say" /* PREFER_NOT_TO_SAY */,
       email: "test@example.com",
       phoneNumber: "",
-      createdAt: Timestamp4.now(),
-      updatedAt: Timestamp4.now()
+      createdAt: Timestamp5.now(),
+      updatedAt: Timestamp5.now()
     };
-    await setDoc4(sensitiveInfoRef, defaultSensitiveInfo);
-    console.log(`[testCreateSubDocuments] Sensitive info document created directly`);
+    await setDoc5(sensitiveInfoRef, defaultSensitiveInfo);
+    console.log(
+      `[testCreateSubDocuments] Sensitive info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Testing medical info creation`);
     const medicalInfoRef = getMedicalInfoDocRef(db, patientId);
-    console.log(`[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`);
+    console.log(
+      `[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`
+    );
     const defaultMedicalInfo = {
       ...DEFAULT_MEDICAL_INFO,
       patientId,
-      lastUpdated: Timestamp4.now(),
+      lastUpdated: Timestamp5.now(),
       updatedBy: userRef
     };
-    await setDoc4(medicalInfoRef, defaultMedicalInfo);
-    console.log(`[testCreateSubDocuments] Medical info document created directly`);
+    await setDoc5(medicalInfoRef, defaultMedicalInfo);
+    console.log(
+      `[testCreateSubDocuments] Medical info document created directly`
+    );
     console.log(`[testCreateSubDocuments] Test completed successfully`);
   } catch (error) {
     console.error(`[testCreateSubDocuments] Error:`, error);
@@ -2206,10 +2567,12 @@ var searchPatientsUtil = async (db, params, requester) => {
   searchPatientsSchema.parse(params);
   requesterInfoSchema.parse(requester);
   const constraints = [];
-  const patientsCollectionRef = collection3(db, PATIENTS_COLLECTION);
+  const patientsCollectionRef = collection4(db, PATIENTS_COLLECTION);
   if (requester.role === "clinic_admin") {
     if (!requester.associatedClinicId) {
-      throw new Error("Associated clinic ID is required for clinic admin search.");
+      throw new Error(
+        "Associated clinic ID is required for clinic admin search."
+      );
     }
     if (params.clinicId && params.clinicId !== requester.associatedClinicId) {
       console.warn(
@@ -2217,13 +2580,19 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push(where3("clinicIds", "array-contains", requester.associatedClinicId));
+    constraints.push(
+      where4("clinicIds", "array-contains", requester.associatedClinicId)
+    );
     if (params.practitionerId) {
-      constraints.push(where3("doctorIds", "array-contains", params.practitionerId));
+      constraints.push(
+        where4("doctorIds", "array-contains", params.practitionerId)
+      );
     }
   } else if (requester.role === "practitioner") {
     if (!requester.associatedPractitionerId) {
-      throw new Error("Associated practitioner ID is required for practitioner search.");
+      throw new Error(
+        "Associated practitioner ID is required for practitioner search."
+      );
     }
     if (params.practitionerId && params.practitionerId !== requester.associatedPractitionerId) {
       console.warn(
@@ -2231,18 +2600,24 @@ var searchPatientsUtil = async (db, params, requester) => {
       );
       return [];
     }
-    constraints.push(where3("doctorIds", "array-contains", requester.associatedPractitionerId));
+    constraints.push(
+      where4("doctorIds", "array-contains", requester.associatedPractitionerId)
+    );
     if (params.clinicId) {
-      constraints.push(where3("clinicIds", "array-contains", params.clinicId));
+      constraints.push(where4("clinicIds", "array-contains", params.clinicId));
     }
   } else {
     throw new Error("Invalid requester role.");
   }
   try {
-    const finalQuery = query3(patientsCollectionRef, ...constraints);
-    const querySnapshot = await getDocs3(finalQuery);
-    const patients = querySnapshot.docs.map((doc34) => doc34.data());
-    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
+    const finalQuery = query4(patientsCollectionRef, ...constraints);
+    const querySnapshot = await getDocs4(finalQuery);
+    const patients = querySnapshot.docs.map(
+      (doc34) => doc34.data()
+    );
+    console.log(
+      `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
+    );
     return patients;
   } catch (error) {
     console.error("[searchPatientsUtil] Error searching patients:", error);
@@ -2251,19 +2626,24 @@ var searchPatientsUtil = async (db, params, requester) => {
 };
 var getAllPatientsUtil = async (db, options) => {
   try {
-    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
-    const patientsCollection = collection3(db, PATIENTS_COLLECTION);
-    let q = query3(patientsCollection);
+    console.log(
+      `[getAllPatientsUtil] Fetching patients with options:`,
+      options
+    );
+    const patientsCollection = collection4(db, PATIENTS_COLLECTION);
+    let q = query4(patientsCollection);
     if (options == null ? void 0 : options.limit) {
-      q = query3(q, limit2(options.limit));
+      q = query4(q, limit3(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await getDoc5(doc4(db, PATIENTS_COLLECTION, options.startAfter));
+      const startAfterDoc = await getDoc6(
+        doc5(db, PATIENTS_COLLECTION, options.startAfter)
+      );
       if (startAfterDoc.exists()) {
-        q = query3(q, startAfter2(startAfterDoc));
+        q = query4(q, startAfter2(startAfterDoc));
       }
     }
-    const patientsSnapshot = await getDocs3(q);
+    const patientsSnapshot = await getDocs4(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2280,12 +2660,12 @@ var getAllPatientsUtil = async (db, options) => {
 
 // src/services/patient/utils/location.utils.ts
 import {
-  getDoc as getDoc6,
-  updateDoc as updateDoc4,
-  setDoc as setDoc5,
+  getDoc as getDoc7,
+  updateDoc as updateDoc5,
+  setDoc as setDoc6,
   serverTimestamp as serverTimestamp5
 } from "firebase/firestore";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 import { geohashForLocation } from "geofire-common";
 var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
   const locationData = {
@@ -2297,7 +2677,7 @@ var updatePatientLocationUtil = async (db, patientId, latitude, longitude) => {
     locationData,
     updatedAt: serverTimestamp5()
   };
-  await updateDoc4(getLocationInfoDocRef(db, patientId), updateData);
+  await updateDoc5(getLocationInfoDocRef(db, patientId), updateData);
 };
 var createLocationInfoUtil = async (db, data, requesterId) => {
   try {
@@ -2317,14 +2697,14 @@ var createLocationInfoUtil = async (db, data, requesterId) => {
       createdAt: serverTimestamp5(),
       updatedAt: serverTimestamp5()
     };
-    await setDoc5(getLocationInfoDocRef(db, data.patientId), locationData);
-    const locationDoc = await getDoc6(getLocationInfoDocRef(db, data.patientId));
+    await setDoc6(getLocationInfoDocRef(db, data.patientId), locationData);
+    const locationDoc = await getDoc7(getLocationInfoDocRef(db, data.patientId));
     if (!locationDoc.exists()) {
       throw new Error("Failed to create location information");
     }
     return locationDoc.data();
   } catch (error) {
-    if (error instanceof z9.ZodError) {
+    if (error instanceof z10.ZodError) {
       throw new Error("Invalid location data: " + error.message);
     }
     throw error;
@@ -2334,7 +2714,7 @@ var getLocationInfoUtil = async (db, patientId, requesterId) => {
   if (patientId !== requesterId) {
     throw new Error("Unauthorized access to location information");
   }
-  const locationDoc = await getDoc6(getLocationInfoDocRef(db, patientId));
+  const locationDoc = await getDoc7(getLocationInfoDocRef(db, patientId));
   return locationDoc.exists() ? locationDoc.data() : null;
 };
 var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
@@ -2352,7 +2732,7 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
     };
   }
   updateData.updatedAt = serverTimestamp5();
-  await updateDoc4(getLocationInfoDocRef(db, patientId), updateData);
+  await updateDoc5(getLocationInfoDocRef(db, patientId), updateData);
   const updatedInfo = await getLocationInfoUtil(db, patientId, requesterId);
   if (!updatedInfo) {
     throw new Error("Failed to retrieve updated location information");
@@ -2362,22 +2742,22 @@ var updateLocationInfoUtil = async (db, patientId, data, requesterId) => {
 
 // src/services/patient/utils/medical-stuff.utils.ts
 import {
-  getDoc as getDoc7,
-  updateDoc as updateDoc5,
+  getDoc as getDoc8,
+  updateDoc as updateDoc6,
   arrayUnion as arrayUnion3,
   arrayRemove as arrayRemove3,
   serverTimestamp as serverTimestamp6,
-  Timestamp as Timestamp5
+  Timestamp as Timestamp6
 } from "firebase/firestore";
 var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
   var _a;
   const newDoctor = {
     userRef: doctorRef,
-    assignedAt: Timestamp5.now(),
+    assignedAt: Timestamp6.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await getDoc7(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc8(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingDoctorIndex = (_a = patientData.doctors) == null ? void 0 : _a.findIndex(
@@ -2392,23 +2772,23 @@ var addDoctorUtil = async (db, patientId, doctorRef, assignedBy) => {
     updatedDoctors[existingDoctorIndex] = {
       ...updatedDoctors[existingDoctorIndex],
       isActive: true,
-      assignedAt: Timestamp5.now(),
+      assignedAt: Timestamp6.now(),
       assignedBy
     };
     updates.doctors = updatedDoctors;
   } else {
     updates.doctors = arrayUnion3(newDoctor);
   }
-  await updateDoc5(getPatientDocRef(db, patientId), updates);
+  await updateDoc6(getPatientDocRef(db, patientId), updates);
 };
 var removeDoctorUtil = async (db, patientId, doctorRef) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await getDoc7(patientDocRef);
+  const patientDoc = await getDoc8(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedDoctors = ((_a = patientData.doctors) == null ? void 0 : _a.filter((doctor) => doctor.userRef !== doctorRef)) || [];
-  await updateDoc5(patientDocRef, {
+  await updateDoc6(patientDocRef, {
     doctors: updatedDoctors,
     // Set the filtered array
     doctorIds: arrayRemove3(doctorRef),
@@ -2420,11 +2800,11 @@ var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
   var _a;
   const newClinic = {
     clinicId,
-    assignedAt: Timestamp5.now(),
+    assignedAt: Timestamp6.now(),
     assignedBy,
     isActive: true
   };
-  const patientDoc = await getDoc7(getPatientDocRef(db, patientId));
+  const patientDoc = await getDoc8(getPatientDocRef(db, patientId));
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const existingClinicIndex = (_a = patientData.clinics) == null ? void 0 : _a.findIndex(
@@ -2439,23 +2819,23 @@ var addClinicUtil = async (db, patientId, clinicId, assignedBy) => {
     updatedClinics[existingClinicIndex] = {
       ...updatedClinics[existingClinicIndex],
       isActive: true,
-      assignedAt: Timestamp5.now(),
+      assignedAt: Timestamp6.now(),
       assignedBy
     };
     updates.clinics = updatedClinics;
   } else {
     updates.clinics = arrayUnion3(newClinic);
   }
-  await updateDoc5(getPatientDocRef(db, patientId), updates);
+  await updateDoc6(getPatientDocRef(db, patientId), updates);
 };
 var removeClinicUtil = async (db, patientId, clinicId) => {
   var _a;
   const patientDocRef = getPatientDocRef(db, patientId);
-  const patientDoc = await getDoc7(patientDocRef);
+  const patientDoc = await getDoc8(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
   const patientData = patientDoc.data();
   const updatedClinics = ((_a = patientData.clinics) == null ? void 0 : _a.filter((clinic) => clinic.clinicId !== clinicId)) || [];
-  await updateDoc5(patientDocRef, {
+  await updateDoc6(patientDocRef, {
     clinics: updatedClinics,
     // Set the filtered array
     clinicIds: arrayRemove3(clinicId),
@@ -2466,14 +2846,14 @@ var removeClinicUtil = async (db, patientId, clinicId) => {
 
 // src/services/patient/utils/clinic.utils.ts
 import {
-  collection as collection4,
-  query as query4,
-  where as where4,
-  getDocs as getDocs4,
-  limit as limit3,
+  collection as collection5,
+  query as query5,
+  where as where5,
+  getDocs as getDocs5,
+  limit as limit4,
   startAfter as startAfter3,
-  doc as doc5,
-  getDoc as getDoc8
+  doc as doc6,
+  getDoc as getDoc9
 } from "firebase/firestore";
 var getPatientsByClinicUtil = async (db, clinicId, options) => {
   try {
@@ -2481,23 +2861,23 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
       `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
       options
     );
-    const patientsCollection = collection4(db, PATIENTS_COLLECTION);
+    const patientsCollection = collection5(db, PATIENTS_COLLECTION);
     const constraints = [
-      where4("clinicIds", "array-contains", clinicId)
+      where5("clinicIds", "array-contains", clinicId)
     ];
-    let q = query4(patientsCollection, ...constraints);
+    let q = query5(patientsCollection, ...constraints);
     if (options == null ? void 0 : options.limit) {
-      q = query4(q, limit3(options.limit));
+      q = query5(q, limit4(options.limit));
     }
     if (options == null ? void 0 : options.startAfter) {
-      const startAfterDoc = await getDoc8(
-        doc5(db, PATIENTS_COLLECTION, options.startAfter)
+      const startAfterDoc = await getDoc9(
+        doc6(db, PATIENTS_COLLECTION, options.startAfter)
       );
       if (startAfterDoc.exists()) {
-        q = query4(q, startAfter3(startAfterDoc));
+        q = query5(q, startAfter3(startAfterDoc));
       }
     }
-    const patientsSnapshot = await getDocs4(q);
+    const patientsSnapshot = await getDocs5(q);
     const patients = [];
     patientsSnapshot.forEach((doc34) => {
       patients.push(doc34.data());
@@ -2521,6 +2901,7 @@ var getPatientsByClinicUtil = async (db, clinicId, options) => {
 var PatientService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
+    this.mediaService = new MediaService(db, auth, app);
   }
   // Metode za rad sa profilom pacijenta
   async createPatientProfile(data) {
@@ -2557,7 +2938,12 @@ var PatientService = class extends BaseService {
   }
   // Metode za rad sa osetljivim informacijama
   async createSensitiveInfo(data, requesterUserId) {
-    return createSensitiveInfoUtil(this.db, data, requesterUserId);
+    return createSensitiveInfoUtil(
+      this.db,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
   async getSensitiveInfo(patientId, requesterUserId) {
     return getSensitiveInfoUtil(this.db, patientId, requesterUserId);
@@ -2568,7 +2954,13 @@ var PatientService = class extends BaseService {
     return this.getSensitiveInfo(profile.id, requesterUserId);
   }
   async updateSensitiveInfo(patientId, data, requesterUserId) {
-    return updateSensitiveInfoUtil(this.db, patientId, data, requesterUserId);
+    return updateSensitiveInfoUtil(
+      this.db,
+      patientId,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
   // Metode za rad sa medicinskim informacijama
   async createMedicalInfo(patientId, data) {
@@ -2701,8 +3093,8 @@ var PatientService = class extends BaseService {
     if (!this.auth.currentUser) {
       throw new Error("No authenticated user");
     }
-    const userDoc = await getDoc9(
-      doc6(this.db, "users", this.auth.currentUser.uid)
+    const userDoc = await getDoc10(
+      doc7(this.db, "users", this.auth.currentUser.uid)
     );
     if (!userDoc.exists()) {
       throw new Error("User not found");
@@ -2737,14 +3129,113 @@ var PatientService = class extends BaseService {
     await removeClinicUtil(this.db, patientId, clinicId);
   }
   // Metode za rad sa profilnom slikom
+  /**
+   * Uploads a profile photo for a patient
+   * @param patientId - ID of the patient
+   * @param file - File or Blob to upload
+   * @returns URL of the uploaded photo
+   */
   async uploadProfilePhoto(patientId, file) {
-    return uploadProfilePhotoUtil(this.storage, patientId, file);
+    console.log(
+      `[PatientService] Uploading profile photo for patient ${patientId}`
+    );
+    const mediaMetadata = await this.mediaService.uploadMedia(
+      file,
+      patientId,
+      // Using patientId as ownerId
+      "private" /* PRIVATE */,
+      // Profile photos should be private
+      "patient_profile_photos",
+      file instanceof File ? file.name : `profile_photo_${patientId}`
+    );
+    await updateDoc7(getSensitiveInfoDocRef(this.db, patientId), {
+      photoUrl: mediaMetadata.url,
+      updatedAt: serverTimestamp7()
+    });
+    return mediaMetadata.url;
   }
+  /**
+   * Updates a patient's profile photo (replaces existing one)
+   * @param patientId - ID of the patient
+   * @param file - New file or Blob to upload
+   * @returns URL of the new uploaded photo
+   */
   async updateProfilePhoto(patientId, file) {
-    return updateProfilePhotoUtil(this.storage, this.db, patientId, file);
+    console.log(
+      `[PatientService] Updating profile photo for patient ${patientId}`
+    );
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+    if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+    }
+    return this.uploadProfilePhoto(patientId, file);
   }
+  /**
+   * Deletes a patient's profile photo
+   * @param patientId - ID of the patient
+   */
   async deleteProfilePhoto(patientId) {
-    await deleteProfilePhotoUtil(this.storage, this.db, patientId);
+    console.log(
+      `[PatientService] Deleting profile photo for patient ${patientId}`
+    );
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+    if ((currentSensitiveInfo == null ? void 0 : currentSensitiveInfo.photoUrl) && typeof currentSensitiveInfo.photoUrl === "string") {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+      await updateDoc7(getSensitiveInfoDocRef(this.db, patientId), {
+        photoUrl: null,
+        updatedAt: serverTimestamp7()
+      });
+    }
+  }
+  /**
+   * Handles profile photo upload for patients (supports MediaResource)
+   * @param photoUrl - MediaResource (File, Blob, or URL string) from CreatePatientSensitiveInfoData
+   * @param patientId - ID of the patient
+   * @returns URL string of the uploaded or existing photo
+   */
+  async handleProfilePhotoUpload(photoUrl, patientId) {
+    if (!photoUrl) {
+      return void 0;
+    }
+    if (typeof photoUrl === "string") {
+      return photoUrl;
+    }
+    if (photoUrl instanceof File || photoUrl instanceof Blob) {
+      return this.uploadProfilePhoto(patientId, photoUrl);
+    }
+    return void 0;
   }
   // Metode za ažuriranje profila
   async updatePatientProfile(patientId, data) {
@@ -2838,16 +3329,16 @@ var PatientService = class extends BaseService {
 
 // src/services/clinic/utils/admin.utils.ts
 import {
-  collection as collection5,
-  doc as doc7,
-  getDoc as getDoc10,
-  getDocs as getDocs5,
-  query as query5,
-  where as where5,
-  updateDoc as updateDoc7,
-  setDoc as setDoc6,
-  deleteDoc,
-  Timestamp as Timestamp7,
+  collection as collection6,
+  doc as doc8,
+  getDoc as getDoc11,
+  getDocs as getDocs6,
+  query as query6,
+  where as where6,
+  updateDoc as updateDoc8,
+  setDoc as setDoc7,
+  deleteDoc as deleteDoc2,
+  Timestamp as Timestamp8,
   serverTimestamp as serverTimestamp8
 } from "firebase/firestore";
 
@@ -2976,131 +3467,131 @@ var SubscriptionModel = /* @__PURE__ */ ((SubscriptionModel2) => {
 
 // src/validations/clinic.schema.ts
 import { z as z13 } from "zod";
-import { Timestamp as Timestamp6 } from "firebase/firestore";
+import { Timestamp as Timestamp7 } from "firebase/firestore";
 
 // src/validations/reviews.schema.ts
-import { z as z10 } from "zod";
-var baseReviewSchema = z10.object({
-  id: z10.string().min(1),
-  patientId: z10.string().min(1),
-  fullReviewId: z10.string().min(1),
-  createdAt: z10.date(),
-  updatedAt: z10.date(),
-  comment: z10.string().min(1).max(2e3),
-  isVerified: z10.boolean(),
-  isPublished: z10.boolean()
+import { z as z11 } from "zod";
+var baseReviewSchema = z11.object({
+  id: z11.string().min(1),
+  patientId: z11.string().min(1),
+  fullReviewId: z11.string().min(1),
+  createdAt: z11.date(),
+  updatedAt: z11.date(),
+  comment: z11.string().min(1).max(2e3),
+  isVerified: z11.boolean(),
+  isPublished: z11.boolean()
 });
-var baseReviewCreateSchema = z10.object({
-  patientId: z10.string().min(1),
-  comment: z10.string().min(1).max(2e3),
-  isVerified: z10.boolean().default(false),
-  isPublished: z10.boolean().default(true)
+var baseReviewCreateSchema = z11.object({
+  patientId: z11.string().min(1),
+  comment: z11.string().min(1).max(2e3),
+  isVerified: z11.boolean().default(false),
+  isPublished: z11.boolean().default(true)
 });
 var clinicReviewSchema = baseReviewSchema.extend({
-  clinicId: z10.string().min(1),
-  cleanliness: z10.number().min(1).max(5),
-  facilities: z10.number().min(1).max(5),
-  staffFriendliness: z10.number().min(1).max(5),
-  waitingTime: z10.number().min(1).max(5),
-  accessibility: z10.number().min(1).max(5),
-  overallRating: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  clinicId: z11.string().min(1),
+  cleanliness: z11.number().min(1).max(5),
+  facilities: z11.number().min(1).max(5),
+  staffFriendliness: z11.number().min(1).max(5),
+  waitingTime: z11.number().min(1).max(5),
+  accessibility: z11.number().min(1).max(5),
+  overallRating: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var createClinicReviewSchema = baseReviewCreateSchema.extend({
-  clinicId: z10.string().min(1),
-  cleanliness: z10.number().min(1).max(5),
-  facilities: z10.number().min(1).max(5),
-  staffFriendliness: z10.number().min(1).max(5),
-  waitingTime: z10.number().min(1).max(5),
-  accessibility: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  clinicId: z11.string().min(1),
+  cleanliness: z11.number().min(1).max(5),
+  facilities: z11.number().min(1).max(5),
+  staffFriendliness: z11.number().min(1).max(5),
+  waitingTime: z11.number().min(1).max(5),
+  accessibility: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var practitionerReviewSchema = baseReviewSchema.extend({
-  practitionerId: z10.string().min(1),
-  knowledgeAndExpertise: z10.number().min(1).max(5),
-  communicationSkills: z10.number().min(1).max(5),
-  bedSideManner: z10.number().min(1).max(5),
-  thoroughness: z10.number().min(1).max(5),
-  trustworthiness: z10.number().min(1).max(5),
-  overallRating: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  practitionerId: z11.string().min(1),
+  knowledgeAndExpertise: z11.number().min(1).max(5),
+  communicationSkills: z11.number().min(1).max(5),
+  bedSideManner: z11.number().min(1).max(5),
+  thoroughness: z11.number().min(1).max(5),
+  trustworthiness: z11.number().min(1).max(5),
+  overallRating: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var createPractitionerReviewSchema = baseReviewCreateSchema.extend({
-  practitionerId: z10.string().min(1),
-  knowledgeAndExpertise: z10.number().min(1).max(5),
-  communicationSkills: z10.number().min(1).max(5),
-  bedSideManner: z10.number().min(1).max(5),
-  thoroughness: z10.number().min(1).max(5),
-  trustworthiness: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  practitionerId: z11.string().min(1),
+  knowledgeAndExpertise: z11.number().min(1).max(5),
+  communicationSkills: z11.number().min(1).max(5),
+  bedSideManner: z11.number().min(1).max(5),
+  thoroughness: z11.number().min(1).max(5),
+  trustworthiness: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var procedureReviewSchema = baseReviewSchema.extend({
-  procedureId: z10.string().min(1),
-  effectivenessOfTreatment: z10.number().min(1).max(5),
-  outcomeExplanation: z10.number().min(1).max(5),
-  painManagement: z10.number().min(1).max(5),
-  followUpCare: z10.number().min(1).max(5),
-  valueForMoney: z10.number().min(1).max(5),
-  overallRating: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  procedureId: z11.string().min(1),
+  effectivenessOfTreatment: z11.number().min(1).max(5),
+  outcomeExplanation: z11.number().min(1).max(5),
+  painManagement: z11.number().min(1).max(5),
+  followUpCare: z11.number().min(1).max(5),
+  valueForMoney: z11.number().min(1).max(5),
+  overallRating: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
 var createProcedureReviewSchema = baseReviewCreateSchema.extend({
-  procedureId: z10.string().min(1),
-  effectivenessOfTreatment: z10.number().min(1).max(5),
-  outcomeExplanation: z10.number().min(1).max(5),
-  painManagement: z10.number().min(1).max(5),
-  followUpCare: z10.number().min(1).max(5),
-  valueForMoney: z10.number().min(1).max(5),
-  wouldRecommend: z10.boolean()
+  procedureId: z11.string().min(1),
+  effectivenessOfTreatment: z11.number().min(1).max(5),
+  outcomeExplanation: z11.number().min(1).max(5),
+  painManagement: z11.number().min(1).max(5),
+  followUpCare: z11.number().min(1).max(5),
+  valueForMoney: z11.number().min(1).max(5),
+  wouldRecommend: z11.boolean()
 });
-var clinicReviewInfoSchema = z10.object({
-  totalReviews: z10.number().min(0),
-  averageRating: z10.number().min(0).max(5),
-  cleanliness: z10.number().min(0).max(5),
-  facilities: z10.number().min(0).max(5),
-  staffFriendliness: z10.number().min(0).max(5),
-  waitingTime: z10.number().min(0).max(5),
-  accessibility: z10.number().min(0).max(5),
-  recommendationPercentage: z10.number().min(0).max(100)
+var clinicReviewInfoSchema = z11.object({
+  totalReviews: z11.number().min(0),
+  averageRating: z11.number().min(0).max(5),
+  cleanliness: z11.number().min(0).max(5),
+  facilities: z11.number().min(0).max(5),
+  staffFriendliness: z11.number().min(0).max(5),
+  waitingTime: z11.number().min(0).max(5),
+  accessibility: z11.number().min(0).max(5),
+  recommendationPercentage: z11.number().min(0).max(100)
 });
-var practitionerReviewInfoSchema = z10.object({
-  totalReviews: z10.number().min(0),
-  averageRating: z10.number().min(0).max(5),
-  knowledgeAndExpertise: z10.number().min(0).max(5),
-  communicationSkills: z10.number().min(0).max(5),
-  bedSideManner: z10.number().min(0).max(5),
-  thoroughness: z10.number().min(0).max(5),
-  trustworthiness: z10.number().min(0).max(5),
-  recommendationPercentage: z10.number().min(0).max(100)
+var practitionerReviewInfoSchema = z11.object({
+  totalReviews: z11.number().min(0),
+  averageRating: z11.number().min(0).max(5),
+  knowledgeAndExpertise: z11.number().min(0).max(5),
+  communicationSkills: z11.number().min(0).max(5),
+  bedSideManner: z11.number().min(0).max(5),
+  thoroughness: z11.number().min(0).max(5),
+  trustworthiness: z11.number().min(0).max(5),
+  recommendationPercentage: z11.number().min(0).max(100)
 });
-var procedureReviewInfoSchema = z10.object({
-  totalReviews: z10.number().min(0),
-  averageRating: z10.number().min(0).max(5),
-  effectivenessOfTreatment: z10.number().min(0).max(5),
-  outcomeExplanation: z10.number().min(0).max(5),
-  painManagement: z10.number().min(0).max(5),
-  followUpCare: z10.number().min(0).max(5),
-  valueForMoney: z10.number().min(0).max(5),
-  recommendationPercentage: z10.number().min(0).max(100)
+var procedureReviewInfoSchema = z11.object({
+  totalReviews: z11.number().min(0),
+  averageRating: z11.number().min(0).max(5),
+  effectivenessOfTreatment: z11.number().min(0).max(5),
+  outcomeExplanation: z11.number().min(0).max(5),
+  painManagement: z11.number().min(0).max(5),
+  followUpCare: z11.number().min(0).max(5),
+  valueForMoney: z11.number().min(0).max(5),
+  recommendationPercentage: z11.number().min(0).max(100)
 });
-var reviewSchema = z10.object({
-  id: z10.string().min(1),
-  appointmentId: z10.string().min(1),
-  patientId: z10.string().min(1),
-  createdAt: z10.date(),
-  updatedAt: z10.date(),
+var reviewSchema = z11.object({
+  id: z11.string().min(1),
+  appointmentId: z11.string().min(1),
+  patientId: z11.string().min(1),
+  createdAt: z11.date(),
+  updatedAt: z11.date(),
   clinicReview: clinicReviewSchema.optional(),
   practitionerReview: practitionerReviewSchema.optional(),
   procedureReview: procedureReviewSchema.optional(),
-  overallComment: z10.string().min(1).max(2e3),
-  overallRating: z10.number().min(1).max(5)
+  overallComment: z11.string().min(1).max(2e3),
+  overallRating: z11.number().min(1).max(5)
 });
-var createReviewSchema = z10.object({
-  patientId: z10.string().min(1),
+var createReviewSchema = z11.object({
+  patientId: z11.string().min(1),
   clinicReview: createClinicReviewSchema.optional(),
   practitionerReview: createPractitionerReviewSchema.optional(),
   procedureReview: createProcedureReviewSchema.optional(),
-  overallComment: z10.string().min(1).max(2e3)
+  overallComment: z11.string().min(1).max(2e3)
 }).refine(
   (data) => {
     return data.clinicReview || data.practitionerReview || data.procedureReview;
@@ -3112,7 +3603,7 @@ var createReviewSchema = z10.object({
 );
 
 // src/validations/shared.schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/backoffice/types/static/procedure-family.types.ts
 var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
@@ -3141,65 +3632,57 @@ var Currency = /* @__PURE__ */ ((Currency2) => {
 })(Currency || {});
 
 // src/validations/shared.schema.ts
-var sharedClinicContactInfoSchema = z11.object({
-  email: z11.string().email(),
-  phoneNumber: z11.string(),
-  alternativePhoneNumber: z11.string().nullable().optional(),
-  website: z11.string().nullable().optional()
+var sharedClinicContactInfoSchema = z12.object({
+  email: z12.string().email(),
+  phoneNumber: z12.string(),
+  alternativePhoneNumber: z12.string().nullable().optional(),
+  website: z12.string().nullable().optional()
 });
-var sharedClinicLocationSchema = z11.object({
-  address: z11.string(),
-  city: z11.string(),
-  country: z11.string(),
-  postalCode: z11.string(),
-  latitude: z11.number().min(-90).max(90),
-  longitude: z11.number().min(-180).max(180),
-  geohash: z11.string().nullable().optional()
+var sharedClinicLocationSchema = z12.object({
+  address: z12.string(),
+  city: z12.string(),
+  country: z12.string(),
+  postalCode: z12.string(),
+  latitude: z12.number().min(-90).max(90),
+  longitude: z12.number().min(-180).max(180),
+  geohash: z12.string().nullable().optional()
 });
-var procedureSummaryInfoSchema = z11.object({
-  id: z11.string().min(1),
-  name: z11.string().min(1),
-  description: z11.string().optional(),
-  photo: z11.string().optional(),
-  family: z11.nativeEnum(ProcedureFamily),
-  categoryName: z11.string(),
-  subcategoryName: z11.string(),
-  technologyName: z11.string(),
-  price: z11.number().nonnegative(),
-  pricingMeasure: z11.nativeEnum(PricingMeasure),
-  currency: z11.nativeEnum(Currency),
-  duration: z11.number().int().positive(),
-  clinicId: z11.string().min(1),
-  clinicName: z11.string().min(1),
-  practitionerId: z11.string().min(1),
-  practitionerName: z11.string().min(1)
+var procedureSummaryInfoSchema = z12.object({
+  id: z12.string().min(1),
+  name: z12.string().min(1),
+  description: z12.string().optional(),
+  photo: z12.string().optional(),
+  family: z12.nativeEnum(ProcedureFamily),
+  categoryName: z12.string(),
+  subcategoryName: z12.string(),
+  technologyName: z12.string(),
+  price: z12.number().nonnegative(),
+  pricingMeasure: z12.nativeEnum(PricingMeasure),
+  currency: z12.nativeEnum(Currency),
+  duration: z12.number().int().positive(),
+  clinicId: z12.string().min(1),
+  clinicName: z12.string().min(1),
+  practitionerId: z12.string().min(1),
+  practitionerName: z12.string().min(1)
 });
-var clinicInfoSchema = z11.object({
-  id: z11.string(),
-  featuredPhoto: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
+var clinicInfoSchema = z12.object({
+  id: z12.string(),
+  featuredPhoto: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
   location: sharedClinicLocationSchema,
   contactInfo: sharedClinicContactInfoSchema
 });
-var doctorInfoSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string().nullable().optional(),
-  photo: z11.string(),
-  rating: z11.number().min(0).max(5),
-  services: z11.array(z11.string())
+var doctorInfoSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable().optional(),
+  photo: z12.string(),
+  rating: z12.number().min(0).max(5),
+  services: z12.array(z12.string())
   // List of procedure IDs practitioner offers
 });
 
-// src/validations/media.schema.ts
-import { z as z12 } from "zod";
-var mediaResourceSchema = z12.union([
-  z12.string().url(),
-  z12.instanceof(File),
-  z12.instanceof(Blob)
-]);
-
 // src/validations/clinic.schema.ts
 var clinicContactInfoSchema = z13.object({
   email: z13.string().email(),
@@ -3259,8 +3742,8 @@ var clinicAdminSchema = z13.object({
   clinicsManagedInfo: z13.array(clinicInfoSchema),
   contactInfo: contactPersonSchema,
   roleTitle: z13.string(),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
-  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
+  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   isActive: z13.boolean()
 });
 var adminTokenSchema = z13.object({
@@ -3269,9 +3752,9 @@ var adminTokenSchema = z13.object({
   email: z13.string().email().optional().nullable(),
   status: z13.nativeEnum(AdminTokenStatus),
   usedByUserRef: z13.string().optional(),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
-  expiresAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6))
+  expiresAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7))
   // Timestamp
 });
 var createAdminTokenSchema = z13.object({
@@ -3291,9 +3774,9 @@ var clinicGroupSchema = z13.object({
   adminsInfo: z13.array(adminInfoSchema),
   adminTokens: z13.array(adminTokenSchema),
   ownerId: z13.string().nullable(),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
-  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
   isActive: z13.boolean(),
   logo: mediaResourceSchema.optional().nullable(),
@@ -3335,9 +3818,9 @@ var clinicSchema = z13.object({
   // Use the correct schema for aggregated procedure info
   reviewInfo: clinicReviewInfoSchema,
   admins: z13.array(z13.string()),
-  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  createdAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
-  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp6)),
+  updatedAt: z13.instanceof(Date).or(z13.instanceof(Timestamp7)),
   // Timestamp
   isActive: z13.boolean(),
   isVerified: z13.boolean(),
@@ -3559,7 +4042,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
   const adminData = {
-    id: doc7(collection5(db, CLINIC_ADMINS_COLLECTION)).id,
+    id: doc8(collection6(db, CLINIC_ADMINS_COLLECTION)).id,
     // Generate a new ID for the admin document
     userRef: validatedData.userRef,
     clinicGroupId: clinicGroupId || "",
@@ -3579,8 +4062,8 @@ async function createClinicAdmin(db, data, clinicGroupService) {
   try {
     clinicAdminSchema.parse({
       ...adminData,
-      createdAt: Timestamp7.now(),
-      updatedAt: Timestamp7.now()
+      createdAt: Timestamp8.now(),
+      updatedAt: Timestamp8.now()
     });
     console.log("[CLINIC_ADMIN] Admin object validation passed");
   } catch (schemaError) {
@@ -3594,7 +4077,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     adminId: adminData.id
   });
   try {
-    await setDoc6(doc7(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    await setDoc7(doc8(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
     console.log("[CLINIC_ADMIN] Admin saved successfully");
   } catch (firestoreError) {
     console.error(
@@ -3643,30 +4126,30 @@ async function checkClinicGroupExists(db, groupId, clinicGroupService) {
   return !!group;
 }
 async function getClinicAdmin(db, adminId) {
-  const docRef = doc7(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await getDoc10(docRef);
+  const docRef = doc8(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await getDoc11(docRef);
   if (docSnap.exists()) {
     return docSnap.data();
   }
   return null;
 }
 async function getClinicAdminByUserRef(db, userRef) {
-  const q = query5(
-    collection5(db, CLINIC_ADMINS_COLLECTION),
-    where5("userRef", "==", userRef)
+  const q = query6(
+    collection6(db, CLINIC_ADMINS_COLLECTION),
+    where6("userRef", "==", userRef)
   );
-  const querySnapshot = await getDocs5(q);
+  const querySnapshot = await getDocs6(q);
   if (querySnapshot.empty) {
     return null;
   }
   return querySnapshot.docs[0].data();
 }
 async function getClinicAdminsByGroup(db, clinicGroupId) {
-  const q = query5(
-    collection5(db, CLINIC_ADMINS_COLLECTION),
-    where5("clinicGroupId", "==", clinicGroupId)
+  const q = query6(
+    collection6(db, CLINIC_ADMINS_COLLECTION),
+    where6("clinicGroupId", "==", clinicGroupId)
   );
-  const querySnapshot = await getDocs5(q);
+  const querySnapshot = await getDocs6(q);
   return querySnapshot.docs.map((doc34) => doc34.data());
 }
 async function updateClinicAdmin(db, adminId, data) {
@@ -3678,7 +4161,7 @@ async function updateClinicAdmin(db, adminId, data) {
     ...data,
     updatedAt: serverTimestamp8()
   };
-  await updateDoc7(doc7(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+  await updateDoc8(doc8(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
   const updatedAdmin = await getClinicAdmin(db, adminId);
   if (!updatedAdmin) {
     throw new Error("Failed to retrieve updated admin");
@@ -3690,7 +4173,7 @@ async function deleteClinicAdmin(db, adminId) {
   if (!admin) {
     throw new Error("Clinic admin not found");
   }
-  await deleteDoc(doc7(db, CLINIC_ADMINS_COLLECTION, adminId));
+  await deleteDoc2(doc8(db, CLINIC_ADMINS_COLLECTION, adminId));
 }
 async function addClinicToManaged(db, adminId, clinicId, requesterId, clinicService) {
   const admin = await getClinicAdmin(db, adminId);
@@ -3861,413 +4344,97 @@ var ClinicAdminService = class extends BaseService {
   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
-import {
-  collection as collection7,
-  doc as doc9,
-  getDoc as getDoc12,
-  getDocs as getDocs7,
-  query as query7,
-  where as where7,
-  updateDoc as updateDoc9,
-  setDoc as setDoc8,
-  deleteDoc as deleteDoc3,
-  Timestamp as Timestamp10,
-  serverTimestamp as serverTimestamp9,
-  limit as limit5,
-  startAfter as startAfter4,
-  orderBy as orderBy2,
-  arrayUnion as arrayUnion5,
-  arrayRemove as arrayRemove4
-} from "firebase/firestore";
-
-// src/services/media/media.service.ts
-import { Timestamp as Timestamp8 } from "firebase/firestore";
-import {
-  ref as ref2,
-  uploadBytes as uploadBytes2,
-  getDownloadURL as getDownloadURL2,
-  deleteObject as deleteObject2,
-  getBytes
-} from "firebase/storage";
-import {
-  doc as doc8,
-  getDoc as getDoc11,
-  setDoc as setDoc7,
-  updateDoc as updateDoc8,
-  collection as collection6,
-  query as query6,
-  where as where6,
-  limit as limit4,
-  getDocs as getDocs6,
-  deleteDoc as deleteDoc2,
-  orderBy
-} from "firebase/firestore";
-var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
-  MediaAccessLevel2["PUBLIC"] = "public";
-  MediaAccessLevel2["PRIVATE"] = "private";
-  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
-  return MediaAccessLevel2;
-})(MediaAccessLevel || {});
-var MEDIA_METADATA_COLLECTION = "media_metadata";
-var MediaService = class extends BaseService {
-  constructor(db, auth, app) {
-    super(db, auth, app);
-  }
-  /**
-   * Upload a media file, store its metadata, and return the metadata including the URL.
-   * @param file - The file to upload.
-   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
-   * @param accessLevel - Access level (public, private, confidential).
-   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
-   * @param originalFileName - Optional: the original name of the file, if not using file.name.
-   * @returns Promise with the media metadata.
-   */
-  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
-    const mediaId = this.generateId();
-    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
-    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
-    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
-    console.log(`[MediaService] Uploading file to: ${filePath}`);
-    const storageRef = ref2(this.storage, filePath);
-    try {
-      const uploadResult = await uploadBytes2(storageRef, file, {
-        contentType: file.type
-      });
-      console.log("[MediaService] File uploaded successfully", uploadResult);
-      const downloadURL = await getDownloadURL2(uploadResult.ref);
-      console.log("[MediaService] Got download URL:", downloadURL);
-      const metadata = {
-        id: mediaId,
-        name: fileNameToUse,
-        url: downloadURL,
-        contentType: file.type,
-        size: file.size,
-        createdAt: Timestamp8.now(),
-        accessLevel,
-        ownerId,
-        collectionName,
-        path: filePath
-      };
-      const metadataDocRef = doc8(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await setDoc7(metadataDocRef, metadata);
-      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
-      return metadata;
-    } catch (error) {
-      console.error("[MediaService] Error during media upload:", error);
-      throw error;
-    }
+  /**
+   * Dohvata admin profil po korisničkom ID-u
+   */
+  async getClinicAdminByUserRef(userRef) {
+    return getClinicAdminByUserRef(this.db, userRef);
   }
   /**
-   * 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.
+   * Dohvata sve admine u grupi
    */
-  async getMediaMetadata(mediaId) {
-    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
-    const docRef = doc8(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-    const docSnap = await getDoc11(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 getClinicAdminsByGroup(clinicGroupId) {
+    return getClinicAdminsByGroup(this.db, clinicGroupId);
   }
   /**
-   * 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.
+   * Ažurira admin profil
    */
-  async getMediaMetadataByUrl(url) {
-    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
-    const q = query6(
-      collection6(this.db, MEDIA_METADATA_COLLECTION),
-      where6("url", "==", url),
-      limit4(1)
-    );
-    try {
-      const querySnapshot = await getDocs6(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 updateClinicAdmin(adminId, data) {
+    return updateClinicAdmin(this.db, adminId, data);
   }
   /**
-   * Delete media from storage and remove metadata from Firestore.
-   * @param mediaId - ID of the media to delete.
+   * Briše admin profil
    */
-  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 = ref2(this.storage, metadata.path);
-    try {
-      await deleteObject2(storageFileRef);
-      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
-      const metadataDocRef = doc8(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      await deleteDoc2(metadataDocRef);
-      console.log(
-        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
-      );
-    } catch (error) {
-      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
-      throw error;
-    }
+  async deleteClinicAdmin(adminId) {
+    return deleteClinicAdmin(this.db, adminId);
   }
   /**
-   * 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.
+   * Dodaje kliniku u listu klinika kojima admin upravlja
    */
-  async updateMediaAccessLevel(mediaId, newAccessLevel) {
-    var _a;
-    console.log(
-      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+  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 = doc8(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      try {
-        await updateDoc8(metadataDocRef, { updatedAt: Timestamp8.now() });
-        return { ...metadata, updatedAt: Timestamp8.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 = ref2(this.storage, oldStoragePath);
-    const newStorageFileRef = ref2(this.storage, newStoragePath);
-    try {
-      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
-      const fileBytes = await getBytes(oldStorageFileRef);
-      console.log(
-        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
-      );
-      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
-      await uploadBytes2(newStorageFileRef, fileBytes, {
-        contentType: metadata.contentType
-      });
-      console.log(
-        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
-      );
-      const newDownloadURL = await getDownloadURL2(newStorageFileRef);
-      console.log(
-        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
-      );
-      const updateData = {
-        accessLevel: newAccessLevel,
-        path: newStoragePath,
-        url: newDownloadURL,
-        updatedAt: Timestamp8.now()
-      };
-      const metadataDocRef = doc8(this.db, MEDIA_METADATA_COLLECTION, mediaId);
-      console.log(
-        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
-        updateData
-      );
-      await updateDoc8(metadataDocRef, updateData);
-      console.log(
-        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
-      );
-      try {
-        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
-        await deleteObject2(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 deleteObject2(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 = [where6("ownerId", "==", ownerId)];
-    if (collectionName) {
-      qConstraints.push(where6("collectionName", "==", collectionName));
-    }
-    if (accessLevel) {
-      qConstraints.push(where6("accessLevel", "==", accessLevel));
-    }
-    qConstraints.push(orderBy("createdAt", "desc"));
-    if (count) {
-      qConstraints.push(limit4(count));
-    }
-    if (startAfterId) {
-      const startAfterDoc = await this.getMediaMetadata(startAfterId);
-      if (startAfterDoc) {
-      }
-    }
-    const finalQuery = query6(
-      collection6(this.db, MEDIA_METADATA_COLLECTION),
-      ...qConstraints
+  async getManagedClinics(adminId) {
+    return getManagedClinics(
+      this.db,
+      adminId,
+      this.getClinicService()
     );
-    try {
-      const querySnapshot = await getDocs6(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
+import {
+  collection as collection7,
+  doc as doc9,
+  getDoc as getDoc12,
+  getDocs as getDocs7,
+  query as query7,
+  where as where7,
+  updateDoc as updateDoc9,
+  setDoc as setDoc8,
+  deleteDoc as deleteDoc3,
+  Timestamp as Timestamp10,
+  serverTimestamp as serverTimestamp9,
+  limit as limit5,
+  startAfter as startAfter4,
+  orderBy as orderBy2,
+  arrayUnion as arrayUnion5,
+  arrayRemove as arrayRemove4
+} from "firebase/firestore";
+
 // src/validations/practitioner.schema.ts
 import { z as z14 } from "zod";
 import { Timestamp as Timestamp9 } from "firebase/firestore";
@@ -5567,10 +5734,10 @@ import { z as z17 } from "zod";
 // src/services/clinic/utils/photos.utils.ts
 import {
   getStorage as getStorage3,
-  ref as ref3,
-  uploadBytes as uploadBytes3,
-  getDownloadURL as getDownloadURL3,
-  deleteObject as deleteObject3
+  ref as ref2,
+  uploadBytes as uploadBytes2,
+  getDownloadURL as getDownloadURL2,
+  deleteObject as deleteObject2
 } from "firebase/storage";
 async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName) {
   if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
@@ -5582,7 +5749,7 @@ async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName
     );
     const storage = getStorage3(app);
     const storageFileName = fileName || `${photoType}-${Date.now()}`;
-    const storageRef = ref3(
+    const storageRef = ref2(
       storage,
       `${entityType}/${entityId}/${storageFileName}`
     );
@@ -5594,8 +5761,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 uploadBytes3(storageRef, blob, { contentType });
-    const downloadUrl = await getDownloadURL3(storageRef);
+    await uploadBytes2(storageRef, blob, { contentType });
+    const downloadUrl = await getDownloadURL2(storageRef);
     console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
       downloadUrl
     });