@blackcode_sa/metaestetics-api 1.5.10 → 1.5.12

package/dist/backoffice/index.d.mts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { Auth } from 'firebase/auth';
-import { Firestore, QueryDocumentSnapshot } from 'firebase/firestore';
+import { Firestore, Timestamp, QueryDocumentSnapshot } from 'firebase/firestore';
 import { FirebaseApp } from 'firebase/app';
 import { FirebaseStorage } from 'firebase/storage';
 
@@ -500,12 +500,14 @@ interface TechnologyRequirements {
 }
 /**
  * Technology used in medical procedures
- * Technologies are the third level of hierarchy, belonging to a specific subcategory
- * and represent a specific method or approach to treatment
+ * Technologies are now a top-level collection that reference their full path in the hierarchy
+ * through family, category, and subcategory IDs
  *
  * @property id - Unique identifier of the technology
  * @property name - Name of the technology
  * @property description - Detailed description of the technology and its application
+ * @property family - The procedure family this technology belongs to (aesthetics/surgery)
+ * @property categoryId - ID of the category this technology belongs to
  * @property subcategoryId - ID of the subcategory this technology belongs to
  * @property technicalDetails - Technical specifications and details
  * @property requirements - List of pre and post procedure requirements
@@ -525,6 +527,10 @@ interface Technology {
     name: string;
     /** Detaljan opis tehnologije */
     description: string;
+    /** Familija procedura kojoj tehnologija pripada */
+    family: ProcedureFamily;
+    /** ID kategorije kojoj tehnologija pripada */
+    categoryId: string;
     /** ID potkategorije kojoj tehnologija pripada */
     subcategoryId: string;
     /** Tehnički detalji i specifikacije */
@@ -2566,6 +2572,8 @@ declare const technologySchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     technicalDetails: z.ZodOptional<z.ZodString>;
+    family: z.ZodNativeEnum<typeof ProcedureFamily>;
+    categoryId: z.ZodString;
     subcategoryId: z.ZodString;
     requirements: z.ZodDefault<z.ZodObject<{
         pre: z.ZodArray<z.ZodObject<{
@@ -3163,6 +3171,8 @@ declare const technologySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     isActive: boolean;
     name: string;
+    family: ProcedureFamily;
+    categoryId: string;
     subcategoryId: string;
     requirements: {
         pre: {
@@ -3290,6 +3300,8 @@ declare const technologySchema: z.ZodObject<{
     technicalDetails?: string | undefined;
 }, {
     name: string;
+    family: ProcedureFamily;
+    categoryId: string;
     subcategoryId: string;
     blockingConditions: BlockingCondition[];
     contraindications: Contraindication[];
@@ -3494,6 +3506,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
     technicalDetails: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    family: z.ZodOptional<z.ZodNativeEnum<typeof ProcedureFamily>>;
+    categoryId: z.ZodOptional<z.ZodString>;
     subcategoryId: z.ZodOptional<z.ZodString>;
     requirements: z.ZodOptional<z.ZodDefault<z.ZodObject<{
         pre: z.ZodArray<z.ZodObject<{
@@ -4093,6 +4107,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
     isActive?: boolean | undefined;
     name?: string | undefined;
     technicalDetails?: string | undefined;
+    family?: ProcedureFamily | undefined;
+    categoryId?: string | undefined;
     subcategoryId?: string | undefined;
     requirements?: {
         pre: {
@@ -4221,6 +4237,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
     isActive?: boolean | undefined;
     name?: string | undefined;
     technicalDetails?: string | undefined;
+    family?: ProcedureFamily | undefined;
+    categoryId?: string | undefined;
     subcategoryId?: string | undefined;
     requirements?: {
         pre: {
@@ -4528,22 +4546,115 @@ declare class SubcategoryService extends BaseService {
     getById(categoryId: string, subcategoryId: string): Promise<Subcategory | null>;
 }
 
+/**
+ * Osnovne informacije o zdravstvenom radniku
+ */
+interface PractitionerBasicInfo {
+    firstName: string;
+    lastName: string;
+    title: string;
+    email: string;
+    phoneNumber: string;
+    dateOfBirth: Timestamp;
+    gender: "male" | "female" | "other";
+    profileImageUrl?: string;
+    bio?: string;
+    languages: string[];
+}
+/**
+ * Sertifikacija zdravstvenog radnika
+ */
+interface PractitionerCertification {
+    level: CertificationLevel;
+    specialties: CertificationSpecialty[];
+    licenseNumber: string;
+    issuingAuthority: string;
+    issueDate: Timestamp;
+    expiryDate?: Timestamp;
+    verificationStatus: "pending" | "verified" | "rejected";
+}
+/**
+ * Interfejs za radno vreme zdravstvenog radnika u klinici
+ */
+interface PractitionerClinicWorkingHours {
+    clinicId: string;
+    workingHours: {
+        monday: {
+            start: string;
+            end: string;
+        } | null;
+        tuesday: {
+            start: string;
+            end: string;
+        } | null;
+        wednesday: {
+            start: string;
+            end: string;
+        } | null;
+        thursday: {
+            start: string;
+            end: string;
+        } | null;
+        friday: {
+            start: string;
+            end: string;
+        } | null;
+        saturday: {
+            start: string;
+            end: string;
+        } | null;
+        sunday: {
+            start: string;
+            end: string;
+        } | null;
+    };
+    isActive: boolean;
+    createdAt: Timestamp;
+    updatedAt: Timestamp;
+}
+/**
+ * Status of practitioner profile
+ */
+declare enum PractitionerStatus {
+    DRAFT = "draft",
+    ACTIVE = "active"
+}
+/**
+ * Interfejs za zdravstvenog radnika
+ */
+interface Practitioner {
+    id: string;
+    userRef: string;
+    basicInfo: PractitionerBasicInfo;
+    certification: PractitionerCertification;
+    clinics: string[];
+    clinicWorkingHours: PractitionerClinicWorkingHours[];
+    isActive: boolean;
+    isVerified: boolean;
+    status: PractitionerStatus;
+    createdAt: Timestamp;
+    updatedAt: Timestamp;
+}
+
 /**
  * Servis za upravljanje tehnologijama i njihovim zahtevima.
- * Tehnologije su treći nivo organizacije i pripadaju određenoj podkategoriji.
- * Svaka tehnologija može imati svoje specifične zahteve pre i posle procedure.
+ * Tehnologije su sada top-level kolekcija koja referencira svoju putanju u hijerarhiji
+ * kroz family, categoryId i subcategoryId.
  *
  * @example
  * const technologyService = new TechnologyService();
  *
  * // Kreiranje nove tehnologije
- * const technology = await technologyService.create(categoryId, subcategoryId, {
+ * const technology = await technologyService.create({
  *   name: "Botulinum Toxin",
- *   description: "Neurotoxin injections for wrinkle reduction"
+ *   description: "Neurotoxin injections for wrinkle reduction",
+ *   family: ProcedureFamily.AESTHETICS,
+ *   categoryId: "category123",
+ *   subcategoryId: "subcategory456"
  * });
  *
  * // Dodavanje zahteva
- * await technologyService.addRequirement(categoryId, subcategoryId, technology.id, {
+ * await technologyService.addRequirement(technology.id, {
  *   type: "pre",
  *   name: "Stay Hydrated",
  *   description: "Drink plenty of water"
@@ -4551,25 +4662,23 @@ declare class SubcategoryService extends BaseService {
  */
 declare class TechnologyService extends BaseService {
     /**
-     * Vraća referencu na Firestore kolekciju tehnologija za određenu podkategoriju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
+     * Vraća referencu na Firestore kolekciju tehnologija
      */
     private getTechnologiesRef;
     /**
-     * Kreira novu tehnologiju u okviru podkategorije
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
+     * Kreira novu tehnologiju
      * @param technology - Podaci za novu tehnologiju
      * @returns Kreirana tehnologija sa generisanim ID-em
      */
-    create(categoryId: string, subcategoryId: string, technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
+    create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
         description: string;
         isActive: boolean;
         createdAt: Date;
         updatedAt: Date;
         name: string;
         technicalDetails?: string | undefined;
+        family: ProcedureFamily;
+        categoryId: string;
         subcategoryId: string;
         requirements: {
             pre: Requirement[];
@@ -4583,168 +4692,197 @@ declare class TechnologyService extends BaseService {
         id: string;
     }>;
     /**
-     * Vraća sve aktivne tehnologije za određenu podkategoriju
+     * Vraća sve aktivne tehnologije
+     * @returns Lista aktivnih tehnologija
+     */
+    getAll(): Promise<Technology[]>;
+    /**
+     * Vraća sve aktivne tehnologije za određenu familiju
+     * @param family - Familija procedura
+     * @returns Lista aktivnih tehnologija
+     */
+    getAllByFamily(family: ProcedureFamily): Promise<Technology[]>;
+    /**
+     * Vraća sve aktivne tehnologije za određenu kategoriju
      * @param categoryId - ID kategorije
+     * @returns Lista aktivnih tehnologija
+     */
+    getAllByCategoryId(categoryId: string): Promise<Technology[]>;
+    /**
+     * Vraća sve aktivne tehnologije za određenu podkategoriju
      * @param subcategoryId - ID podkategorije
      * @returns Lista aktivnih tehnologija
      */
-    getAllBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
+    getAllBySubcategoryId(subcategoryId: string): Promise<Technology[]>;
     /**
      * Ažurira postojeću tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param technology - Novi podaci za tehnologiju
      * @returns Ažurirana tehnologija
      */
-    update(categoryId: string, subcategoryId: string, technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "subcategoryId">>): Promise<Technology | null>;
+    update(technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "family" | "categoryId" | "subcategoryId">>): Promise<Technology | null>;
     /**
      * Soft delete tehnologije (postavlja isActive na false)
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije koja se briše
      */
-    delete(categoryId: string, subcategoryId: string, technologyId: string): Promise<void>;
+    delete(technologyId: string): Promise<void>;
     /**
      * Vraća tehnologiju po ID-u
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tražene tehnologije
      * @returns Tehnologija ili null ako ne postoji
      */
-    getById(categoryId: string, subcategoryId: string, technologyId: string): Promise<Technology | null>;
+    getById(technologyId: string): Promise<Technology | null>;
     /**
      * Dodaje novi zahtev tehnologiji
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param requirement - Zahtev koji se dodaje
      * @returns Ažurirana tehnologija sa novim zahtevom
      */
-    addRequirement(categoryId: string, subcategoryId: string, technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    addRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
     /**
      * Uklanja zahtev iz tehnologije
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param requirement - Zahtev koji se uklanja
      * @returns Ažurirana tehnologija bez uklonjenog zahteva
      */
-    removeRequirement(categoryId: string, subcategoryId: string, technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    removeRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
     /**
      * Vraća sve zahteve za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param type - Opcioni filter za tip zahteva (pre/post)
      * @returns Lista zahteva
      */
-    getRequirements(categoryId: string, subcategoryId: string, technologyId: string, type?: RequirementType): Promise<Requirement[]>;
+    getRequirements(technologyId: string, type?: RequirementType): Promise<Requirement[]>;
     /**
      * Ažurira postojeći zahtev
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param oldRequirement - Stari zahtev koji se menja
      * @param newRequirement - Novi zahtev koji zamenjuje stari
      * @returns Ažurirana tehnologija
      */
-    updateRequirement(categoryId: string, subcategoryId: string, technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
+    updateRequirement(technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
     /**
      * Dodaje blokirajući uslov tehnologiji
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param condition - Blokirajući uslov koji se dodaje
      * @returns Ažurirana tehnologija
      */
-    addBlockingCondition(categoryId: string, subcategoryId: string, technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    addBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
     /**
      * Uklanja blokirajući uslov iz tehnologije
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param condition - Blokirajući uslov koji se uklanja
      * @returns Ažurirana tehnologija
      */
-    removeBlockingCondition(categoryId: string, subcategoryId: string, technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    removeBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
     /**
      * Dodaje kontraindikaciju tehnologiji
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param contraindication - Kontraindikacija koja se dodaje
      * @returns Ažurirana tehnologija
      */
-    addContraindication(categoryId: string, subcategoryId: string, technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    addContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
     /**
      * Uklanja kontraindikaciju iz tehnologije
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param contraindication - Kontraindikacija koja se uklanja
      * @returns Ažurirana tehnologija
      */
-    removeContraindication(categoryId: string, subcategoryId: string, technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    removeContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
     /**
      * Dodaje benefit tehnologiji
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param benefit - Benefit koji se dodaje
      * @returns Ažurirana tehnologija
      */
-    addBenefit(categoryId: string, subcategoryId: string, technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    addBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
     /**
      * Uklanja benefit iz tehnologije
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param benefit - Benefit koji se uklanja
      * @returns Ažurirana tehnologija
      */
-    removeBenefit(categoryId: string, subcategoryId: string, technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    removeBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
     /**
      * Vraća sve blokirajuće uslove za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @returns Lista blokirajućih uslova
      */
-    getBlockingConditions(categoryId: string, subcategoryId: string, technologyId: string): Promise<BlockingCondition[]>;
+    getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
     /**
      * Vraća sve kontraindikacije za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @returns Lista kontraindikacija
      */
-    getContraindications(categoryId: string, subcategoryId: string, technologyId: string): Promise<Contraindication[]>;
+    getContraindications(technologyId: string): Promise<Contraindication[]>;
     /**
      * Vraća sve benefite za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @returns Lista benefita
      */
-    getBenefits(categoryId: string, subcategoryId: string, technologyId: string): Promise<TreatmentBenefit[]>;
+    getBenefits(technologyId: string): Promise<TreatmentBenefit[]>;
     /**
      * Ažurira zahteve sertifikacije za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @param certificationRequirement - Novi zahtevi sertifikacije
      * @returns Ažurirana tehnologija
      */
-    updateCertificationRequirement(categoryId: string, subcategoryId: string, technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
+    updateCertificationRequirement(technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
     /**
      * Vraća zahteve sertifikacije za tehnologiju
-     * @param categoryId - ID kategorije
-     * @param subcategoryId - ID podkategorije
      * @param technologyId - ID tehnologije
      * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
      */
-    getCertificationRequirement(categoryId: string, subcategoryId: string, technologyId: string): Promise<CertificationRequirement | null>;
+    getCertificationRequirement(technologyId: string): Promise<CertificationRequirement | null>;
+    /**
+     * Proverava da li doktor ima odgovarajuću sertifikaciju za izvođenje tehnologije
+     *
+     * @param requiredCertification - Zahtevana sertifikacija za tehnologiju
+     * @param practitionerCertification - Sertifikacija zdravstvenog radnika
+     * @returns true ako zdravstveni radnik ima odgovarajuću sertifikaciju, false ako nema
+     *
+     * @example
+     * const isValid = technologyService.validateCertification(
+     *   {
+     *     minimumLevel: CertificationLevel.DOCTOR,
+     *     requiredSpecialties: [CertificationSpecialty.INJECTABLES]
+     *   },
+     *   {
+     *     level: CertificationLevel.SPECIALIST,
+     *     specialties: [CertificationSpecialty.INJECTABLES, CertificationSpecialty.LASER]
+     *   }
+     * );
+     */
+    validateCertification(requiredCertification: CertificationRequirement, practitionerCertification: PractitionerCertification): boolean;
+    /**
+     * Vraća sve tehnologije koje je zdravstveni radnik sertifikovan da izvodi
+     * zajedno sa listama dozvoljenih familija, kategorija i podkategorija
+     *
+     * @param practitioner - Profil zdravstvenog radnika
+     * @returns Objekat koji sadrži:
+     * - technologies: Lista tehnologija koje zdravstveni radnik može da izvodi
+     * - families: Lista familija procedura koje zdravstveni radnik može da izvodi
+     * - categories: Lista ID-eva kategorija koje zdravstveni radnik može da izvodi
+     * - subcategories: Lista ID-eva podkategorija koje zdravstveni radnik može da izvodi
+     *
+     * @example
+     * const practitioner = {
+     *   certification: {
+     *     level: CertificationLevel.DOCTOR,
+     *     specialties: [CertificationSpecialty.INJECTABLES]
+     *   }
+     * };
+     * const allowedTechnologies = await technologyService.getAllowedTechnologies(practitioner);
+     * console.log(allowedTechnologies.families); // [ProcedureFamily.AESTHETICS]
+     * console.log(allowedTechnologies.categories); // ["category1", "category2"]
+     * console.log(allowedTechnologies.subcategories); // ["subcategory1", "subcategory2"]
+     */
+    getAllowedTechnologies(practitioner: Practitioner): Promise<{
+        technologies: Technology[];
+        families: ProcedureFamily[];
+        categories: string[];
+        subcategories: string[];
+    }>;
 }
 
 /**