@blackcode_sa/metaestetics-api 1.14.79 → 1.15.3

package/src/services/patient/utils/hair-scalp-assessment.utils.ts

@@ -0,0 +1,158 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  HairScalpAssessment,
+  CreateHairScalpAssessmentData,
+  UpdateHairScalpAssessmentData,
+  HAIR_SCALP_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  HairScalpAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createHairScalpAssessmentSchema,
+  updateHairScalpAssessmentSchema,
+  hairScalpAssessmentSchema,
+} from '../../../validations/patient/hair-scalp-assessment.schema';
+import { getPatientDocRef } from './docs.utils';
+import { AuthError } from '../../../errors/auth.errors';
+import { getPractitionerProfileByUserRef } from './practitioner.utils';
+import { getClinicAdminByUserRef } from '../../clinic/utils/admin.utils';
+
+export const getHairScalpAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, HAIR_SCALP_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkHairScalpAssessmentAccessUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<void> => {
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) {
+    throw new Error('Patient profile not found');
+  }
+  const patientData = patientDoc.data() as any;
+
+  if (patientData.userRef && patientData.userRef === requesterId) {
+    return;
+  }
+
+  if (requesterRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
+    if (practitionerProfile && patientData.doctorIds?.includes(practitionerProfile.id)) {
+      return;
+    }
+  }
+
+  if (requesterRoles.includes(UserRole.CLINIC_ADMIN)) {
+    const adminProfile = await getClinicAdminByUserRef(db, requesterId);
+    if (adminProfile && adminProfile.clinicsManaged) {
+      const hasAccess = adminProfile.clinicsManaged.some((managedClinicId) =>
+        patientData.clinicIds?.includes(managedClinicId)
+      );
+      if (hasAccess) {
+        return;
+      }
+    }
+  }
+
+  throw new AuthError(
+    'Unauthorized access to hair & scalp assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculateHairScalpCompletionPercentage = (data: Partial<HairScalpAssessment>): number => {
+  let completed = 0;
+  const total = 4;
+
+  if (data.hairLossPattern && data.hairLossPattern.type) completed++;
+  if (data.hairCharacteristics && data.hairCharacteristics.type) completed++;
+  if (data.scalpCondition) completed++;
+  if (data.zoneAssessments && data.zoneAssessments.length > 0) completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determineHairScalpStatus = (completionPercentage: number): HairScalpAssessmentStatus => {
+  if (completionPercentage < 50) return 'incomplete';
+  if (completionPercentage >= 50) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getHairScalpAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<HairScalpAssessment | null> => {
+  await checkHairScalpAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getHairScalpAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return hairScalpAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdateHairScalpAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreateHairScalpAssessmentData | UpdateHairScalpAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkHairScalpAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updateHairScalpAssessmentSchema.parse(data)
+    : createHairScalpAssessmentSchema.parse(data);
+
+  const docRef = getHairScalpAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  const requesterRole = requesterRoles.includes(UserRole.PRACTITIONER) ? 'PRACTITIONER' : 'PATIENT';
+
+  const existingData = snapshot.exists() ? snapshot.data() : null;
+  const mergedData: any = {
+    ...(existingData || {}),
+    ...validatedData,
+  };
+
+  const completionPercentage = calculateHairScalpCompletionPercentage(mergedData);
+  const status = determineHairScalpStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      zoneAssessments: [],
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+  } else {
+    await updateDoc(docRef, {
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      updatedAt: serverTimestamp(),
+    });
+  }
+};

package/src/services/patient/utils/pre-surgical-assessment.utils.ts

@@ -0,0 +1,161 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  PreSurgicalAssessment,
+  CreatePreSurgicalAssessmentData,
+  UpdatePreSurgicalAssessmentData,
+  PRE_SURGICAL_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  PreSurgicalAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createPreSurgicalAssessmentSchema,
+  updatePreSurgicalAssessmentSchema,
+  preSurgicalAssessmentSchema,
+} from '../../../validations/patient/pre-surgical-assessment.schema';
+import { getPatientDocRef } from './docs.utils';
+import { AuthError } from '../../../errors/auth.errors';
+import { getPractitionerProfileByUserRef } from './practitioner.utils';
+import { getClinicAdminByUserRef } from '../../clinic/utils/admin.utils';
+
+export const getPreSurgicalAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, PRE_SURGICAL_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkPreSurgicalAssessmentAccessUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<void> => {
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) {
+    throw new Error('Patient profile not found');
+  }
+  const patientData = patientDoc.data() as any;
+
+  if (patientData.userRef && patientData.userRef === requesterId) {
+    return;
+  }
+
+  if (requesterRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
+    if (practitionerProfile && patientData.doctorIds?.includes(practitionerProfile.id)) {
+      return;
+    }
+  }
+
+  if (requesterRoles.includes(UserRole.CLINIC_ADMIN)) {
+    const adminProfile = await getClinicAdminByUserRef(db, requesterId);
+    if (adminProfile && adminProfile.clinicsManaged) {
+      const hasAccess = adminProfile.clinicsManaged.some((managedClinicId) =>
+        patientData.clinicIds?.includes(managedClinicId)
+      );
+      if (hasAccess) {
+        return;
+      }
+    }
+  }
+
+  throw new AuthError(
+    'Unauthorized access to pre-surgical assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculatePreSurgicalCompletionPercentage = (data: Partial<PreSurgicalAssessment>): number => {
+  let completed = 0;
+  const total = 5;
+
+  if (data.asaClassification) completed++;
+  if (data.anesthesiaHistory) completed++;
+  if (data.bleedingRisk) completed++;
+  if (data.surgicalSiteAssessments && data.surgicalSiteAssessments.length > 0) completed++;
+  if ((data.labResults && data.labResults.length > 0) || data.clearance === 'obtained') completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determinePreSurgicalStatus = (completionPercentage: number): PreSurgicalAssessmentStatus => {
+  if (completionPercentage < 40) return 'incomplete';
+  if (completionPercentage >= 40) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getPreSurgicalAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<PreSurgicalAssessment | null> => {
+  await checkPreSurgicalAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getPreSurgicalAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return preSurgicalAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdatePreSurgicalAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreatePreSurgicalAssessmentData | UpdatePreSurgicalAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkPreSurgicalAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updatePreSurgicalAssessmentSchema.parse(data)
+    : createPreSurgicalAssessmentSchema.parse(data);
+
+  const docRef = getPreSurgicalAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  const requesterRole = requesterRoles.includes(UserRole.PRACTITIONER) ? 'PRACTITIONER' : 'PATIENT';
+
+  const existingData = snapshot.exists() ? snapshot.data() : null;
+  const mergedData: any = {
+    ...(existingData || {}),
+    ...validatedData,
+  };
+
+  const completionPercentage = calculatePreSurgicalCompletionPercentage(mergedData);
+  const status = determinePreSurgicalStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      surgicalSiteAssessments: [],
+      labResults: [],
+      clearance: 'not_required',
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+  } else {
+    await updateDoc(docRef, {
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      updatedAt: serverTimestamp(),
+    });
+  }
+};

package/src/services/patient/utils/skin-quality-assessment.utils.ts

@@ -0,0 +1,160 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  SkinQualityAssessment,
+  CreateSkinQualityAssessmentData,
+  UpdateSkinQualityAssessmentData,
+  SKIN_QUALITY_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  SkinQualityAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createSkinQualityAssessmentSchema,
+  updateSkinQualityAssessmentSchema,
+  skinQualityAssessmentSchema,
+} from '../../../validations/patient/skin-quality-assessment.schema';
+import { getPatientDocRef } from './docs.utils';
+import { AuthError } from '../../../errors/auth.errors';
+import { getPractitionerProfileByUserRef } from './practitioner.utils';
+import { getClinicAdminByUserRef } from '../../clinic/utils/admin.utils';
+
+export const getSkinQualityAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, SKIN_QUALITY_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkSkinQualityAssessmentAccessUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<void> => {
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) {
+    throw new Error('Patient profile not found');
+  }
+  const patientData = patientDoc.data() as any;
+
+  if (patientData.userRef && patientData.userRef === requesterId) {
+    return;
+  }
+
+  if (requesterRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
+    if (practitionerProfile && patientData.doctorIds?.includes(practitionerProfile.id)) {
+      return;
+    }
+  }
+
+  if (requesterRoles.includes(UserRole.CLINIC_ADMIN)) {
+    const adminProfile = await getClinicAdminByUserRef(db, requesterId);
+    if (adminProfile && adminProfile.clinicsManaged) {
+      const hasAccess = adminProfile.clinicsManaged.some((managedClinicId) =>
+        patientData.clinicIds?.includes(managedClinicId)
+      );
+      if (hasAccess) {
+        return;
+      }
+    }
+  }
+
+  throw new AuthError(
+    'Unauthorized access to skin quality assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculateSkinQualityCompletionPercentage = (data: Partial<SkinQualityAssessment>): number => {
+  let completed = 0;
+  const total = 4;
+
+  if (data.characteristics) completed++;
+  if (data.conditions && data.conditions.length > 0) completed++;
+  if (data.zoneAssessments && data.zoneAssessments.length > 0) completed++;
+  if (data.scales && (data.scales.fitzpatrick || data.scales.glogau || data.scales.elastosis)) completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determineSkinQualityStatus = (completionPercentage: number): SkinQualityAssessmentStatus => {
+  if (completionPercentage < 50) return 'incomplete';
+  if (completionPercentage >= 50) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getSkinQualityAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<SkinQualityAssessment | null> => {
+  await checkSkinQualityAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getSkinQualityAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return skinQualityAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdateSkinQualityAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreateSkinQualityAssessmentData | UpdateSkinQualityAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkSkinQualityAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updateSkinQualityAssessmentSchema.parse(data)
+    : createSkinQualityAssessmentSchema.parse(data);
+
+  const docRef = getSkinQualityAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  const requesterRole = requesterRoles.includes(UserRole.PRACTITIONER) ? 'PRACTITIONER' : 'PATIENT';
+
+  const existingData = snapshot.exists() ? snapshot.data() : null;
+  const mergedData: any = {
+    ...(existingData || {}),
+    ...validatedData,
+  };
+
+  const completionPercentage = calculateSkinQualityCompletionPercentage(mergedData);
+  const status = determineSkinQualityStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      conditions: [],
+      zoneAssessments: [],
+      scales: {},
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+  } else {
+    await updateDoc(docRef, {
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      updatedAt: serverTimestamp(),
+    });
+  }
+};

package/src/types/appointment/index.ts

@@ -196,6 +196,14 @@ export interface BillingPerZone {
 export interface FinalBilling {
   /** Total of all subtotals from all zones */
   subtotalAll: number;
+  /** Overall discount applied to the subtotal */
+  discount?: {
+    type: 'percentage' | 'fixed';
+    value: number;    // e.g., 10 for 10% or 50 for CHF 50
+    amount: number;   // calculated discount in currency
+  };
+  /** Subtotal after discount (subtotalAll - discount.amount) */
+  discountedSubtotal?: number;
   /** Tax rate as percentage (e.g., 0.20 for 20%) */
   taxRate: number;
   /** Calculated tax amount */

package/src/types/patient/body-assessment.types.ts

@@ -0,0 +1,93 @@
+import { Timestamp } from 'firebase/firestore';
+
+export const BODY_ASSESSMENT_COLLECTION = 'body-assessment';
+
+export type BodyAssessmentStatus = 'incomplete' | 'ready_for_planning' | 'treatment_planned';
+
+export type BodyZone =
+  | 'abdomen'
+  | 'flanks'
+  | 'back'
+  | 'upper_arms'
+  | 'thighs_inner'
+  | 'thighs_outer'
+  | 'buttocks'
+  | 'chest'
+  | 'knees'
+  | 'submental';
+
+export type SeverityLevel = 'none' | 'mild' | 'moderate' | 'severe';
+export type MuscleDefinitionLevel = 'well_defined' | 'moderate' | 'poor' | 'none';
+
+export interface BodyZoneAssessment {
+  zone: BodyZone;
+  fatDeposit: SeverityLevel;
+  skinLaxity: SeverityLevel;
+  stretchMarks: SeverityLevel;
+  cellulite: SeverityLevel;
+  muscleDefinition: MuscleDefinitionLevel;
+  notes?: string;
+}
+
+export interface BodyCompositionData {
+  bmi?: number;
+  bodyFatPercentage?: number;
+  waistHipRatio?: number;
+  weight?: number;
+  height?: number;
+}
+
+export interface BodyMeasurementsData {
+  waist?: number;
+  hips?: number;
+  chest?: number;
+  upperArm?: number;
+  thigh?: number;
+  units: 'cm' | 'inches';
+}
+
+export interface BodySymmetryData {
+  overallSymmetry: 'symmetric' | 'mild_asymmetry' | 'moderate_asymmetry' | 'significant_asymmetry';
+  notes?: string;
+  affectedAreas?: string[];
+}
+
+export interface BodyAssessment {
+  id: string;
+  patientId: string;
+  appointmentId?: string;
+
+  selectedZones: BodyZone[];
+  zoneAssessments: BodyZoneAssessment[];
+  composition?: BodyCompositionData;
+  measurements?: BodyMeasurementsData;
+  symmetry?: BodySymmetryData;
+
+  completionPercentage: number;
+  status: BodyAssessmentStatus;
+
+  lastUpdatedBy: string;
+  lastUpdatedByRole: 'PATIENT' | 'PRACTITIONER';
+
+  createdAt?: Timestamp | any;
+  updatedAt?: Timestamp | any;
+}
+
+export interface CreateBodyAssessmentData {
+  patientId: string;
+  appointmentId?: string;
+  selectedZones?: BodyZone[];
+  zoneAssessments?: BodyZoneAssessment[];
+  composition?: BodyCompositionData;
+  measurements?: BodyMeasurementsData;
+  symmetry?: BodySymmetryData;
+}
+
+export interface UpdateBodyAssessmentData {
+  appointmentId?: string;
+  selectedZones?: BodyZone[];
+  zoneAssessments?: BodyZoneAssessment[];
+  composition?: BodyCompositionData;
+  measurements?: BodyMeasurementsData;
+  symmetry?: BodySymmetryData;
+}

package/src/types/patient/hair-scalp-assessment.types.ts

@@ -0,0 +1,98 @@
+import { Timestamp } from 'firebase/firestore';
+
+export const HAIR_SCALP_ASSESSMENT_COLLECTION = 'hair-scalp-assessment';
+
+export type HairScalpAssessmentStatus = 'incomplete' | 'ready_for_planning' | 'treatment_planned';
+
+export type NorwoodStage = 'I' | 'II' | 'IIa' | 'III' | 'IIIa' | 'III_vertex' | 'IV' | 'IVa' | 'V' | 'Va' | 'VI' | 'VII';
+export type LudwigStage = 'I' | 'II' | 'III';
+export type HairLossType = 'androgenetic' | 'diffuse' | 'areata' | 'traction' | 'scarring' | 'telogen_effluvium';
+
+export interface HairLossPattern {
+  type: HairLossType;
+  norwoodStage?: NorwoodStage;
+  ludwigStage?: LudwigStage;
+  onsetDuration?: string;
+  familyHistory?: boolean;
+  notes?: string;
+}
+
+export type HairType = 'straight' | 'wavy' | 'curly' | 'coily';
+export type HairDensity = 'high' | 'medium' | 'low' | 'very_low';
+export type HairColor = 'black' | 'dark_brown' | 'brown' | 'light_brown' | 'blonde' | 'red' | 'grey' | 'white';
+export type HairTextureGrade = 'fine' | 'medium' | 'coarse';
+
+export interface HairCharacteristics {
+  type: HairType;
+  density: HairDensity;
+  color: HairColor;
+  texture: HairTextureGrade;
+  diameter?: 'thin' | 'medium' | 'thick';
+}
+
+export type ScalpScalinessLevel = 'none' | 'mild' | 'moderate' | 'severe';
+export type ScalpRednessLevel = 'none' | 'mild' | 'moderate' | 'severe';
+export type ScalpSebumLevel = 'dry' | 'normal' | 'oily' | 'very_oily';
+
+export interface ScalpCondition {
+  scaliness: ScalpScalinessLevel;
+  redness: ScalpRednessLevel;
+  sebum: ScalpSebumLevel;
+  folliculitis: boolean;
+  scarring: boolean;
+  notes?: string;
+}
+
+export type HairLossZone =
+  | 'frontal'
+  | 'temporal_left'
+  | 'temporal_right'
+  | 'mid_scalp'
+  | 'vertex'
+  | 'occipital'
+  | 'parietal_left'
+  | 'parietal_right';
+
+export interface HairLossZoneAssessment {
+  zone: HairLossZone;
+  miniaturization: 'none' | 'mild' | 'moderate' | 'severe';
+  density: HairDensity;
+  notes?: string;
+}
+
+export interface HairScalpAssessment {
+  id: string;
+  patientId: string;
+  appointmentId?: string;
+
+  hairLossPattern?: HairLossPattern;
+  hairCharacteristics?: HairCharacteristics;
+  scalpCondition?: ScalpCondition;
+  zoneAssessments: HairLossZoneAssessment[];
+
+  completionPercentage: number;
+  status: HairScalpAssessmentStatus;
+
+  lastUpdatedBy: string;
+  lastUpdatedByRole: 'PATIENT' | 'PRACTITIONER';
+
+  createdAt?: Timestamp | any;
+  updatedAt?: Timestamp | any;
+}
+
+export interface CreateHairScalpAssessmentData {
+  patientId: string;
+  appointmentId?: string;
+  hairLossPattern?: HairLossPattern;
+  hairCharacteristics?: HairCharacteristics;
+  scalpCondition?: ScalpCondition;
+  zoneAssessments?: HairLossZoneAssessment[];
+}
+
+export interface UpdateHairScalpAssessmentData {
+  appointmentId?: string;
+  hairLossPattern?: HairLossPattern;
+  hairCharacteristics?: HairCharacteristics;
+  scalpCondition?: ScalpCondition;
+  zoneAssessments?: HairLossZoneAssessment[];
+}

package/src/types/patient/index.ts

@@ -259,6 +259,10 @@ export interface RequesterInfo {
 
 export * from "./medical-info.types";
 export * from "./aesthetic-analysis.types";
+export * from "./skin-quality-assessment.types";
+export * from "./body-assessment.types";
+export * from "./hair-scalp-assessment.types";
+export * from "./pre-surgical-assessment.types";
 
 // This is a type that combines all the patient data - used only in UI Frontend App
 export interface PatientProfileComplete {