@blackcode_sa/metaestetics-api 1.7.47 → 1.8.1

package/dist/backoffice/index.d.mts

@@ -1,8 +1,8 @@
-import { z } from 'zod';
 import { Auth } from 'firebase/auth';
-import { Firestore, Timestamp, QueryDocumentSnapshot } from 'firebase/firestore';
+import { Firestore, QueryDocumentSnapshot, Timestamp } from 'firebase/firestore';
 import { FirebaseApp } from 'firebase/app';
 import { FirebaseStorage } from 'firebase/storage';
+import { z } from 'zod';
 
 /**
  * Brend proizvoda ili opreme
@@ -28,6 +28,56 @@ interface Brand {
     description?: string;
 }
 
+declare class BaseService {
+    protected db: Firestore;
+    protected auth: Auth;
+    protected app: FirebaseApp;
+    protected storage: FirebaseStorage;
+    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
+    /**
+     * Generiše jedinstveni ID za dokumente
+     * Format: xxxxxxxxxxxx-timestamp
+     * Gde je x random karakter (broj ili slovo)
+     */
+    protected generateId(): string;
+}
+
+declare class BrandService extends BaseService {
+    /**
+     * Gets reference to brands collection
+     */
+    private getBrandsRef;
+    /**
+     * Creates a new brand
+     */
+    create(brand: Omit<Brand, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        manufacturer: string;
+        isActive: boolean;
+        website?: string | undefined;
+        description?: string | undefined;
+        id: string;
+    }>;
+    /**
+     * Gets all active brands
+     */
+    getAll(): Promise<Brand[]>;
+    /**
+     * Updates a brand
+     */
+    update(brandId: string, brand: Partial<Omit<Brand, "id" | "createdAt">>): Promise<Brand | null>;
+    /**
+     * Soft deletes a brand
+     */
+    delete(brandId: string): Promise<void>;
+    /**
+     * Gets a brand by ID
+     */
+    getById(brandId: string): Promise<Brand | null>;
+}
+
 /**
  * Familije procedura u sistemu
  * Predstavlja najviši nivo hijerarhije i deli procedure na estetske i hirurške
@@ -74,393 +124,127 @@ interface Category {
 }
 
 /**
- * Product used in procedures
- * Can be consumables, equipment, or any other product needed for performing procedures
+ * Servis za upravljanje kategorijama procedura.
+ * Kategorije su prvi nivo organizacije nakon procedure family (aesthetics/surgery).
  *
- * @property id - Unique identifier of the product
- * @property name - Name of the product
- * @property description - Detailed description of the product and its purpose
- * @property brandId - ID of the brand that manufactures this product
- * @property technologyId - ID of the technology this product is used with
- * @property technicalDetails - Technical details and specifications
- * @property warnings - List of warnings related to product use
- * @property dosage - Dosage information (if applicable)
- * @property composition - Product composition
- * @property indications - List of indications for use
- * @property contraindications - List of contraindications
- * @property isActive - Whether the product is active in the system
- * @property createdAt - Creation date
- * @property updatedAt - Last update date
- */
-interface Product {
-    id?: string;
-    name: string;
-    brandId: string;
-    brandName: string;
-    technologyId: string;
-    technologyName: string;
-    createdAt: Date;
-    updatedAt: Date;
-    isActive: boolean;
-    description?: string;
-    technicalDetails?: string;
-    warnings?: string[];
-    dosage?: string;
-    composition?: string;
-    indications?: string[];
-    contraindications?: string[];
-}
-/**
- * Interface for the ProductService class
+ * @example
+ * const categoryService = new CategoryService();
+ *
+ * // Kreiranje nove kategorije
+ * const category = await categoryService.create({
+ *   name: "Injectables",
+ *   family: ProcedureFamily.AESTHETICS
+ * });
  */
-interface IProductService {
+declare class CategoryService extends BaseService {
     /**
-     * Creates a new product
-     * @param technologyId - ID of the technology this product is used with
-     * @param brandId - ID of the brand that manufactures this product
-     * @param product - Product data
+     * Referenca na Firestore kolekciju kategorija
      */
-    create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
+    private get categoriesRef();
     /**
-     * Gets all products for a technology
-     * @param technologyId - ID of the technology
+     * Kreira novu kategoriju u sistemu
+     * @param category - Podaci za novu kategoriju
+     * @returns Kreirana kategorija sa generisanim ID-em
      */
-    getAllByTechnology(technologyId: string): Promise<Product[]>;
+    create(category: Omit<Category, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        isActive: boolean;
+        description: string;
+        family: ProcedureFamily;
+        id: string;
+    }>;
     /**
-     * Gets all products for a brand
-     * @param brandId - ID of the brand
+     * Vraća sve aktivne kategorije
+     * @returns Lista aktivnih kategorija
      */
-    getAllByBrand(brandId: string): Promise<Product[]>;
+    getAll(): Promise<Category[]>;
     /**
-     * Updates a product
-     * @param technologyId - ID of the technology
-     * @param productId - ID of the product to update
-     * @param product - Updated product data
+     * Vraća sve aktivne kategorije za određenu familiju procedura
+     * @param family - Familija procedura (aesthetics/surgery)
+     * @returns Lista kategorija koje pripadaju traženoj familiji
      */
-    update(technologyId: string, productId: string, product: Partial<Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">>): Promise<Product | null>;
+    getAllByFamily(family: ProcedureFamily): Promise<Category[]>;
     /**
-     * Deletes a product (soft delete)
-     * @param technologyId - ID of the technology
-     * @param productId - ID of the product to delete
+     * Ažurira postojeću kategoriju
+     * @param id - ID kategorije koja se ažurira
+     * @param category - Novi podaci za kategoriju
+     * @returns Ažurirana kategorija
      */
-    delete(technologyId: string, productId: string): Promise<void>;
+    update(id: string, category: Partial<Omit<Category, "id" | "createdAt">>): Promise<Category | null>;
     /**
-     * Gets a product by ID
-     * @param technologyId - ID of the technology
-     * @param productId - ID of the product
+     * Soft delete kategorije (postavlja isActive na false)
+     * @param id - ID kategorije koja se briše
      */
-    getById(technologyId: string, productId: string): Promise<Product | null>;
+    delete(id: string): Promise<void>;
+    /**
+     * Vraća kategoriju po ID-u
+     * @param id - ID tražene kategorije
+     * @returns Kategorija ili null ako ne postoji
+     */
+    getById(id: string): Promise<Category | null>;
 }
 
 /**
- * Jedinica mere za vremenski period
+ * Enum for element types in documentation templates
  */
-declare enum TimeUnit {
-    HOURS = "hours",
-    DAYS = "days"
+declare enum DocumentElementType {
+    HEADING = "heading",
+    PARAGRAPH = "paragraph",
+    LIST = "list",
+    DYNAMIC_TEXT = "dynamic_text",
+    BINARY_CHOICE = "binary_choice",
+    MULTIPLE_CHOICE = "multiple_choice",
+    SINGLE_CHOICE = "single_choice",
+    RATING_SCALE = "rating_scale",
+    TEXT_INPUT = "text_input",
+    DATE_PICKER = "date_picker",
+    SIGNATURE = "signature",
+    DITIGAL_SIGNATURE = "digital_signature",
+    FILE_UPLOAD = "file_upload"
 }
 /**
- * Tip zahteva - da li se odnosi na period pre ili posle procedure
+ * Enum for list types
  */
-declare enum RequirementType {
-    PRE = "pre",
-    POST = "post"
+declare enum ListType {
+    ORDERED = "ordered",
+    UNORDERED = "unordered"
 }
 /**
- * Nivo važnosti zahteva
+ * Enum for heading levels
  */
-type RequirementImportance = "low" | "medium" | "high";
+declare enum HeadingLevel {
+    H1 = "h1",
+    H2 = "h2",
+    H3 = "h3",
+    H4 = "h4",
+    H5 = "h5",
+    H6 = "h6"
+}
 /**
- * Vremenski okvir za zahtev
- * @property duration - Trajanje u odabranoj jedinici vremena
- * @property unit - Jedinica vremena (sati ili dani)
- * @property notifyAt - Lista trenutaka kada treba poslati obaveštenje (u istoj jedinici)
+ * Enum for dynamic variable placeholders
  */
-interface TimeFrame {
-    duration: number;
-    unit: TimeUnit;
-    notifyAt: number[];
+declare enum DynamicVariable {
+    PATIENT_NAME = "$[PATIENT_NAME]",
+    DOCTOR_NAME = "$[DOCTOR_NAME]",
+    CLINIC_NAME = "$[CLINIC_NAME]",
+    PATIENT_BIRTHDAY = "$[PATIENT_BIRTHDAY]",
+    APPOINTMENT_DATE = "$[APPOINTMENT_DATE]",
+    CURRENT_DATE = "$[CURRENT_DATE]",
+    PROCEDURE_NAME = "$[PROCEDURE_NAME]",
+    PROCEDURE_DESCRIPTION = "$[PROCEDURE_DESCRIPTION]",
+    PROCEDURE_COST = "$[PROCEDURE_COST]",
+    PROCEDURE_DURATION = "$[PROCEDURE_DURATION]",
+    PROCEDURE_RISK = "$[PROCEDURE_RISK]"
 }
 /**
- * Zahtev koji se može povezati sa tehnologijom
- * Može biti zahtev pre procedure (pre) ili posle procedure (post)
- *
- * @property id - Jedinstveni identifikator zahteva
- * @property type - Tip zahteva (pre/post)
- * @property name - Naziv zahteva
- * @property description - Detaljan opis zahteva
- * @property timeframe - Vremenski okvir za zahtev
- * @property importance - Nivo važnosti zahteva
- * @property isActive - Da li je zahtev aktivan u sistemu
- * @property createdAt - Datum kreiranja
- * @property updatedAt - Datum poslednjeg ažuriranja
+ * Base interface for all document elements
  */
-interface Requirement {
+interface BaseDocumentElement {
     id: string;
-    type: RequirementType;
-    name: string;
-    description: string;
-    timeframe: TimeFrame;
-    importance: RequirementImportance;
-    isActive: boolean;
-    createdAt: Date;
-    updatedAt: Date;
-}
-
-/**
- * Podkategorija procedura
- * Podkategorije su drugi nivo hijerarhije i pripadaju određenoj kategoriji
- * One grupišu slične tehnologije u okviru kategorije
- *
- * @property id - Jedinstveni identifikator podkategorije
- * @property name - Naziv podkategorije
- * @property description - Detaljan opis podkategorije i njene namene
- * @property categoryId - ID kategorije kojoj podkategorija pripada
- * @property isActive - Da li je podkategorija aktivna u sistemu
- * @property createdAt - Datum kreiranja
- * @property updatedAt - Datum poslednjeg ažuriranja
- */
-interface Subcategory {
-    /** Jedinstveni identifikator podkategorije (automatski generisan od strane Firestore) */
-    id?: string;
-    /** Naziv podkategorije */
-    name: string;
-    /** Detaljniji opis podkategorije */
-    description?: string;
-    /** ID kategorije kojoj podkategorija pripada */
-    categoryId: string;
-    /** Flag koji označava da li je podkategorija aktivna */
-    isActive: boolean;
-    /** Datum kreiranja podkategorije */
-    createdAt: Date;
-    /** Datum poslednjeg ažuriranja podkategorije */
-    updatedAt: Date;
-}
-
-/**
- * Blokirajući uslovi koji mogu sprečiti proceduru
- * Ovi uslovi predstavljaju apsolutne kontraindikacije koje onemogućavaju izvođenje procedure
- */
-declare enum BlockingCondition {
-    PREGNANCY = "pregnancy",
-    BREASTFEEDING = "breastfeeding",
-    ACTIVE_INFECTION = "active_infection",
-    SKIN_CONDITION = "skin_condition",
-    AUTOIMMUNE_DISEASE = "autoimmune_disease",
-    BLOOD_THINNERS = "blood_thinners",
-    RECENT_SURGERY = "recent_surgery",
-    DIABETES = "diabetes",
-    HEART_CONDITION = "heart_condition",
-    HIGH_BLOOD_PRESSURE = "high_blood_pressure",
-    KELOID_SCARRING = "keloid_scarring",
-    METAL_IMPLANTS = "metal_implants",
-    PACEMAKER = "pacemaker",
-    CANCER = "cancer",
-    EPILEPSY = "epilepsy"
-}
-
-/**
- * Kontraindikacije koje mogu uticati na proceduru
- * Ovi uslovi predstavljaju relativne kontraindikacije koje zahtevaju posebnu pažnju
- */
-declare enum Contraindication {
-    SENSITIVE_SKIN = "sensitive_skin",
-    RECENT_TANNING = "recent_tanning",
-    RECENT_BOTOX = "recent_botox",
-    RECENT_FILLERS = "recent_fillers",
-    SKIN_ALLERGIES = "skin_allergies",
-    MEDICATIONS = "medications",
-    RECENT_CHEMICAL_PEEL = "recent_chemical_peel",
-    RECENT_LASER = "recent_laser",
-    SKIN_INFLAMMATION = "skin_inflammation",
-    OPEN_WOUNDS = "open_wounds",
-    HERPES_SIMPLEX = "herpes_simplex",
-    COLD_SORES = "cold_sores"
-}
-
-/**
- * Benefiti koji se mogu očekivati od procedure
- * Lista mogućih pozitivnih efekata i rezultata tretmana
- */
-declare enum TreatmentBenefit {
-    WRINKLE_REDUCTION = "wrinkle_reduction",
-    SKIN_TIGHTENING = "skin_tightening",
-    COLLAGEN_PRODUCTION = "collagen_production",
-    ACNE_REDUCTION = "acne_reduction",
-    SCAR_REDUCTION = "scar_reduction",
-    PIGMENTATION_IMPROVEMENT = "pigmentation_improvement",
-    HAIR_REMOVAL = "hair_removal",
-    MUSCLE_TONING = "muscle_toning",
-    FAT_REDUCTION = "fat_reduction",
-    CELLULITE_REDUCTION = "cellulite_reduction",
-    SKIN_REJUVENATION = "skin_rejuvenation",
-    PORE_REDUCTION = "pore_reduction",
-    TEXTURE_IMPROVEMENT = "texture_improvement",
-    HYDRATION_BOOST = "hydration_boost",
-    CIRCULATION_IMPROVEMENT = "circulation_improvement"
-}
-
-/**
- * Nivoi sertifikacije medicinskog osoblja, poređani od najnižeg do najvišeg
- */
-declare enum CertificationLevel {
-    AESTHETICIAN = "aesthetician",// Osnovni estetičar
-    NURSE_ASSISTANT = "nurse_assistant",// Medicinski tehničar
-    NURSE = "nurse",// Medicinska sestra
-    NURSE_PRACTITIONER = "nurse_practitioner",// Viša medicinska sestra
-    PHYSICIAN_ASSISTANT = "physician_assistant",// Lekar asistent
-    DOCTOR = "doctor",// Doktor medicine
-    SPECIALIST = "specialist",// Specijalista
-    PLASTIC_SURGEON = "plastic_surgeon"
-}
-/**
- * Dodatne specijalizacije potrebne za određene procedure
- */
-declare enum CertificationSpecialty {
-    LASER = "laser",// Sertifikat za laserske tretmane
-    INJECTABLES = "injectables",// Sertifikat za injekcione tretmane
-    CHEMICAL_PEELS = "chemical_peels",// Sertifikat za hemijske pilinge
-    MICRODERMABRASION = "microdermabrasion",// Sertifikat za mikrodermoabraziju
-    BODY_CONTOURING = "body_contouring",// Sertifikat za konturiranje tela
-    SKIN_CARE = "skin_care",// Sertifikat za negu kože
-    WOUND_CARE = "wound_care",// Sertifikat za tretman rana
-    ANESTHESIA = "anesthesia"
-}
-/**
- * Zahtevi sertifikacije za izvođenje procedura
- */
-interface CertificationRequirement {
-    /** Minimalni nivo sertifikacije potreban za proceduru */
-    minimumLevel: CertificationLevel;
-    /** Dodatne specijalizacije potrebne za proceduru */
-    requiredSpecialties?: CertificationSpecialty[];
-}
-
-/**
- * Reference to a documentation template with metadata
- * @property templateId - ID of the documentation template
- * @property isUserForm - Whether this template is filled by users
- * @property isRequired - Whether this template is required
- * @property sortingOrder - The display order of this template
- */
-interface TechnologyDocumentationTemplate {
-    templateId: string;
-    isUserForm: boolean;
-    isRequired: boolean;
-    sortingOrder: number;
-}
-/**
- * Zahtevi koji su povezani sa tehnologijom
- * @property pre - Lista zahteva koji se moraju ispuniti pre procedure
- * @property post - Lista zahteva koji se moraju ispuniti posle procedure
- */
-interface TechnologyRequirements {
-    pre: Requirement[];
-    post: Requirement[];
-}
-/**
- * Technology used in medical procedures
- * 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
- * @property blockingConditions - List of conditions that prevent the procedure
- * @property contraindications - List of conditions requiring special attention
- * @property benefits - List of expected benefits from the procedure
- * @property certificationRequirement - Required certification level and specialties
- * @property documentationTemplates - List of documentation template references
- * @property isActive - Whether the technology is active in the system
- * @property createdAt - Creation date
- * @property updatedAt - Last update date
- */
-interface Technology {
-    id?: string;
-    name: string;
-    description: string;
-    family: ProcedureFamily;
-    categoryId: string;
-    subcategoryId: string;
-    technicalDetails?: string;
-    requirements: {
-        pre: Requirement[];
-        post: Requirement[];
-    };
-    blockingConditions: BlockingCondition[];
-    contraindications: Contraindication[];
-    benefits: TreatmentBenefit[];
-    certificationRequirement: CertificationRequirement;
-    documentationTemplates?: TechnologyDocumentationTemplate[];
-    isActive: boolean;
-    createdAt: Date;
-    updatedAt: Date;
-}
-
-/**
- * Enum for element types in documentation templates
- */
-declare enum DocumentElementType {
-    HEADING = "heading",
-    PARAGRAPH = "paragraph",
-    LIST = "list",
-    DYNAMIC_TEXT = "dynamic_text",
-    BINARY_CHOICE = "binary_choice",
-    MULTIPLE_CHOICE = "multiple_choice",
-    SINGLE_CHOICE = "single_choice",
-    RATING_SCALE = "rating_scale",
-    TEXT_INPUT = "text_input",
-    DATE_PICKER = "date_picker",
-    SIGNATURE = "signature",
-    DITIGAL_SIGNATURE = "digital_signature",
-    FILE_UPLOAD = "file_upload"
-}
-/**
- * Enum for list types
- */
-declare enum ListType {
-    ORDERED = "ordered",
-    UNORDERED = "unordered"
-}
-/**
- * Enum for heading levels
- */
-declare enum HeadingLevel {
-    H1 = "h1",
-    H2 = "h2",
-    H3 = "h3",
-    H4 = "h4",
-    H5 = "h5",
-    H6 = "h6"
-}
-/**
- * Enum for dynamic variable placeholders
- */
-declare enum DynamicVariable {
-    PATIENT_NAME = "$[PATIENT_NAME]",
-    DOCTOR_NAME = "$[DOCTOR_NAME]",
-    CLINIC_NAME = "$[CLINIC_NAME]",
-    PATIENT_BIRTHDAY = "$[PATIENT_BIRTHDAY]",
-    APPOINTMENT_DATE = "$[APPOINTMENT_DATE]",
-    CURRENT_DATE = "$[CURRENT_DATE]",
-    PROCEDURE_NAME = "$[PROCEDURE_NAME]",
-    PROCEDURE_DESCRIPTION = "$[PROCEDURE_DESCRIPTION]",
-    PROCEDURE_COST = "$[PROCEDURE_COST]",
-    PROCEDURE_DURATION = "$[PROCEDURE_DURATION]",
-    PROCEDURE_RISK = "$[PROCEDURE_RISK]"
-}
-/**
- * Base interface for all document elements
- */
-interface BaseDocumentElement {
-    id: string;
-    type: DocumentElementType;
-    required?: boolean;
+    type: DocumentElementType;
+    required?: boolean;
 }
 /**
  * Interface for heading element
@@ -614,118 +398,1046 @@ interface UpdateDocumentTemplateData {
 }
 
 /**
- * Default vrednosti za sertifikaciju
- * Svaka nova tehnologija će imati ove vrednosti ako se ne specificira drugačije
- */
-declare const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement;
-
-/**
- * Bazna klasa za greške u backoffice sistemu
+ * Service for managing documentation templates in the backoffice
  */
-declare class BackofficeError extends Error {
-    constructor(message: string);
-}
-/**
- * Errors related to Category operations
- */
-declare class CategoryError extends BackofficeError {
-    constructor(message: string);
-}
-declare class CategoryNotFoundError extends CategoryError {
-    constructor(id: string);
-}
-declare class InvalidCategoryDataError extends CategoryError {
-    constructor(message: string);
+declare class DocumentationTemplateService {
+    private apiService;
+    /**
+     * Constructor for DocumentationTemplateService
+     * @param db - Firestore instance
+     * @param auth - Firebase Auth instance
+     * @param app - Firebase App instance
+     */
+    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
+    /**
+     * Create a new document template
+     * @param data - Template data
+     * @param userId - ID of the user creating the template
+     * @returns The created template
+     */
+    createTemplate(data: CreateDocumentTemplateData, userId: string): Promise<DocumentTemplate>;
+    /**
+     * Get a document template by ID
+     * @param templateId - ID of the template to retrieve
+     * @param version - Optional version number to retrieve (defaults to latest version)
+     * @returns The template or null if not found
+     */
+    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
+    /**
+     * Update an existing document template
+     * @param templateId - ID of the template to update
+     * @param data - Updated template data
+     * @returns The updated template
+     */
+    updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<DocumentTemplate>;
+    /**
+     * Delete a document template
+     * @param templateId - ID of the template to delete
+     */
+    deleteTemplate(templateId: string): Promise<void>;
+    /**
+     * Get all active templates
+     * @param pageSize - Number of templates to retrieve
+     * @param lastDoc - Last document from previous page for pagination
+     * @returns Array of templates and the last document for pagination
+     */
+    getActiveTemplates(pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get templates by tags
+     * @param tags - Tags to filter by
+     * @param pageSize - Number of templates to retrieve
+     * @param lastDoc - Last document from previous page for pagination
+     * @returns Array of templates and the last document for pagination
+     */
+    getTemplatesByTags(tags: string[], pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get templates created by a specific user
+     * @param userId - ID of the user who created the templates
+     * @param pageSize - Number of templates to retrieve
+     * @param lastDoc - Last document from previous page for pagination
+     * @returns Array of templates and the last document for pagination
+     */
+    getTemplatesByCreator(userId: string, pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
+        templates: DocumentTemplate[];
+        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+    }>;
+    /**
+     * Get a specific version of a template
+     * @param templateId - ID of the template
+     * @param versionNumber - Version number to retrieve
+     * @returns The template version or null if not found
+     */
+    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
+    /**
+     * Get all versions of a template
+     * @param templateId - ID of the template
+     * @returns Array of template versions
+     */
+    getTemplateVersions(templateId: string): Promise<DocumentTemplate[]>;
 }
+
 /**
- * Errors related to Subcategory operations
+ * Product used in procedures
+ * Can be consumables, equipment, or any other product needed for performing procedures
+ *
+ * @property id - Unique identifier of the product
+ * @property name - Name of the product
+ * @property description - Detailed description of the product and its purpose
+ * @property brandId - ID of the brand that manufactures this product
+ * @property technologyId - ID of the technology this product is used with
+ * @property technicalDetails - Technical details and specifications
+ * @property warnings - List of warnings related to product use
+ * @property dosage - Dosage information (if applicable)
+ * @property composition - Product composition
+ * @property indications - List of indications for use
+ * @property contraindications - List of contraindications
+ * @property isActive - Whether the product is active in the system
+ * @property createdAt - Creation date
+ * @property updatedAt - Last update date
  */
-declare class SubcategoryError extends BackofficeError {
-    constructor(message: string);
-}
-declare class SubcategoryNotFoundError extends SubcategoryError {
-    constructor(id: string);
-}
-declare class InvalidSubcategoryDataError extends SubcategoryError {
-    constructor(message: string);
+interface Product {
+    id?: string;
+    name: string;
+    brandId: string;
+    brandName: string;
+    technologyId: string;
+    technologyName: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isActive: boolean;
+    description?: string;
+    technicalDetails?: string;
+    warnings?: string[];
+    dosage?: string;
+    composition?: string;
+    indications?: string[];
+    contraindications?: string[];
 }
 /**
- * Errors related to Technology operations
+ * Interface for the ProductService class
  */
-declare class TechnologyError extends BackofficeError {
-    constructor(message: string);
-}
-declare class TechnologyNotFoundError extends TechnologyError {
-    constructor(id: string);
+interface IProductService {
+    /**
+     * Creates a new product
+     * @param technologyId - ID of the technology this product is used with
+     * @param brandId - ID of the brand that manufactures this product
+     * @param product - Product data
+     */
+    create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
+    /**
+     * Gets all products for a technology
+     * @param technologyId - ID of the technology
+     */
+    getAllByTechnology(technologyId: string): Promise<Product[]>;
+    /**
+     * Gets all products for a brand
+     * @param brandId - ID of the brand
+     */
+    getAllByBrand(brandId: string): Promise<Product[]>;
+    /**
+     * Updates a product
+     * @param technologyId - ID of the technology
+     * @param productId - ID of the product to update
+     * @param product - Updated product data
+     */
+    update(technologyId: string, productId: string, product: Partial<Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">>): Promise<Product | null>;
+    /**
+     * Deletes a product (soft delete)
+     * @param technologyId - ID of the technology
+     * @param productId - ID of the product to delete
+     */
+    delete(technologyId: string, productId: string): Promise<void>;
+    /**
+     * Gets a product by ID
+     * @param technologyId - ID of the technology
+     * @param productId - ID of the product
+     */
+    getById(technologyId: string, productId: string): Promise<Product | null>;
 }
-declare class InvalidTechnologyDataError extends TechnologyError {
-    constructor(message: string);
+
+declare class ProductService extends BaseService implements IProductService {
+    /**
+     * Gets reference to products collection under a technology
+     * @param technologyId - ID of the technology
+     * @returns Firestore collection reference
+     */
+    private getProductsRef;
+    /**
+     * Creates a new product under technology
+     */
+    create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
+    /**
+     * Gets all products for a technology
+     */
+    getAllByTechnology(technologyId: string): Promise<Product[]>;
+    /**
+     * Gets all products for a brand by filtering through all technologies
+     */
+    getAllByBrand(brandId: string): Promise<Product[]>;
+    /**
+     * Updates a product
+     */
+    update(technologyId: string, productId: string, product: Partial<Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">>): Promise<Product | null>;
+    /**
+     * Soft deletes a product
+     */
+    delete(technologyId: string, productId: string): Promise<void>;
+    /**
+     * Gets a product by ID
+     */
+    getById(technologyId: string, productId: string): Promise<Product | null>;
 }
+
 /**
- * Errors related to Requirement operations
+ * Jedinica mere za vremenski period
  */
-declare class RequirementError extends BackofficeError {
-    constructor(message: string);
-}
-declare class RequirementNotFoundError extends RequirementError {
-    constructor(id: string);
-}
-declare class InvalidRequirementDataError extends RequirementError {
-    constructor(message: string);
-}
-declare class InvalidTimeframeError extends RequirementError {
-    constructor(message: string);
+declare enum TimeUnit {
+    HOURS = "hours",
+    DAYS = "days"
 }
 /**
- * Errors related to relationships between entities
+ * Tip zahteva - da li se odnosi na period pre ili posle procedure
  */
-declare class RelationshipError extends BackofficeError {
-    constructor(message: string);
-}
-declare class InvalidHierarchyError extends RelationshipError {
-    constructor(message: string);
+declare enum RequirementType {
+    PRE = "pre",
+    POST = "post"
 }
-declare class CircularReferenceError extends RelationshipError {
-    constructor(message: string);
+/**
+ * Nivo važnosti zahteva
+ */
+type RequirementImportance = "low" | "medium" | "high";
+/**
+ * Vremenski okvir za zahtev
+ * @property duration - Trajanje u odabranoj jedinici vremena
+ * @property unit - Jedinica vremena (sati ili dani)
+ * @property notifyAt - Lista trenutaka kada treba poslati obaveštenje (u istoj jedinici)
+ */
+interface TimeFrame {
+    duration: number;
+    unit: TimeUnit;
+    notifyAt: number[];
 }
-declare class BlockingConditionError extends BackofficeError {
-    constructor(message: string);
+/**
+ * Zahtev koji se može povezati sa tehnologijom
+ * Može biti zahtev pre procedure (pre) ili posle procedure (post)
+ *
+ * @property id - Jedinstveni identifikator zahteva
+ * @property type - Tip zahteva (pre/post)
+ * @property name - Naziv zahteva
+ * @property description - Detaljan opis zahteva
+ * @property timeframe - Vremenski okvir za zahtev
+ * @property importance - Nivo važnosti zahteva
+ * @property isActive - Da li je zahtev aktivan u sistemu
+ * @property createdAt - Datum kreiranja
+ * @property updatedAt - Datum poslednjeg ažuriranja
+ */
+interface Requirement {
+    id: string;
+    type: RequirementType;
+    name: string;
+    description: string;
+    timeframe: TimeFrame;
+    importance: RequirementImportance;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
 }
-declare class InvalidBlockingConditionError extends BlockingConditionError {
-    constructor(condition: string);
+
+/**
+ * Servis za upravljanje globalnim zahtevima.
+ * Zahtevi se mogu kreirati globalno i zatim povezati sa različitim tehnologijama.
+ * Ovo omogućava ponovno korišćenje istih zahteva za različite tehnologije.
+ *
+ * @example
+ * const requirementService = new RequirementService();
+ *
+ * // Kreiranje globalnog zahteva
+ * const requirement = await requirementService.create({
+ *   type: "pre",
+ *   name: "Stay Hydrated",
+ *   description: "Drink plenty of water",
+ *   timeframe: {
+ *     duration: 2,
+ *     unit: "hours",
+ *     notifyAt: [2, 1]
+ *   },
+ *   importance: "high"
+ * });
+ */
+declare class RequirementService extends BaseService {
+    /**
+     * Referenca na Firestore kolekciju zahteva
+     */
+    private get requirementsRef();
+    /**
+     * Kreira novi globalni zahtev
+     * @param requirement - Podaci za novi zahtev
+     * @returns Kreirani zahtev sa generisanim ID-em
+     */
+    create(requirement: Omit<Requirement, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        isActive: boolean;
+        description: string;
+        type: RequirementType;
+        timeframe: TimeFrame;
+        importance: RequirementImportance;
+        id: string;
+    }>;
+    /**
+     * Vraća sve aktivne zahteve
+     * @returns Lista aktivnih zahteva
+     */
+    getAll(): Promise<Requirement[]>;
+    /**
+     * Vraća sve aktivne zahteve određenog tipa
+     * @param type - Tip zahteva (pre/post)
+     * @returns Lista zahteva određenog tipa
+     */
+    getAllByType(type: RequirementType): Promise<Requirement[]>;
+    /**
+     * Ažurira postojeći zahtev
+     * @param id - ID zahteva koji se ažurira
+     * @param requirement - Novi podaci za zahtev
+     * @returns Ažurirani zahtev
+     */
+    update(id: string, requirement: Partial<Omit<Requirement, "id" | "createdAt">>): Promise<Requirement | null>;
+    /**
+     * Soft delete zahteva (postavlja isActive na false)
+     * @param id - ID zahteva koji se briše
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Vraća zahtev po ID-u
+     * @param id - ID traženog zahteva
+     * @returns Zahtev ili null ako ne postoji
+     */
+    getById(id: string): Promise<Requirement | null>;
 }
-declare class ContraindicationError extends BackofficeError {
-    constructor(message: string);
+
+/**
+ * Podkategorija procedura
+ * Podkategorije su drugi nivo hijerarhije i pripadaju određenoj kategoriji
+ * One grupišu slične tehnologije u okviru kategorije
+ *
+ * @property id - Jedinstveni identifikator podkategorije
+ * @property name - Naziv podkategorije
+ * @property description - Detaljan opis podkategorije i njene namene
+ * @property categoryId - ID kategorije kojoj podkategorija pripada
+ * @property isActive - Da li je podkategorija aktivna u sistemu
+ * @property createdAt - Datum kreiranja
+ * @property updatedAt - Datum poslednjeg ažuriranja
+ */
+interface Subcategory {
+    /** Jedinstveni identifikator podkategorije (automatski generisan od strane Firestore) */
+    id?: string;
+    /** Naziv podkategorije */
+    name: string;
+    /** Detaljniji opis podkategorije */
+    description?: string;
+    /** ID kategorije kojoj podkategorija pripada */
+    categoryId: string;
+    /** Flag koji označava da li je podkategorija aktivna */
+    isActive: boolean;
+    /** Datum kreiranja podkategorije */
+    createdAt: Date;
+    /** Datum poslednjeg ažuriranja podkategorije */
+    updatedAt: Date;
 }
-declare class InvalidContraindicationError extends ContraindicationError {
-    constructor(contraindication: string);
+
+/**
+ * Servis za upravljanje podkategorijama procedura.
+ * Podkategorije su drugi nivo organizacije i pripadaju određenoj kategoriji.
+ *
+ * @example
+ * const subcategoryService = new SubcategoryService();
+ *
+ * // Kreiranje nove podkategorije
+ * const subcategory = await subcategoryService.create(categoryId, {
+ *   name: "Anti-Wrinkle",
+ *   description: "Treatments targeting facial wrinkles"
+ * });
+ */
+declare class SubcategoryService extends BaseService {
+    /**
+     * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
+     * @param categoryId - ID roditeljske kategorije
+     */
+    private getSubcategoriesRef;
+    /**
+     * Kreira novu podkategoriju u okviru kategorije
+     * @param categoryId - ID kategorije kojoj će pripadati nova podkategorija
+     * @param subcategory - Podaci za novu podkategoriju
+     * @returns Kreirana podkategorija sa generisanim ID-em
+     */
+    create(categoryId: string, subcategory: Omit<Subcategory, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        isActive: boolean;
+        description?: string | undefined;
+        categoryId: string;
+        id: string;
+    }>;
+    /**
+     * Vraća sve aktivne podkategorije za određenu kategoriju
+     * @param categoryId - ID kategorije čije podkategorije tražimo
+     * @returns Lista aktivnih podkategorija
+     */
+    getAllByCategoryId(categoryId: string): Promise<Subcategory[]>;
+    /**
+     * Ažurira postojeću podkategoriju
+     * @param categoryId - ID kategorije kojoj pripada podkategorija
+     * @param subcategoryId - ID podkategorije koja se ažurira
+     * @param subcategory - Novi podaci za podkategoriju
+     * @returns Ažurirana podkategorija
+     */
+    update(categoryId: string, subcategoryId: string, subcategory: Partial<Omit<Subcategory, "id" | "createdAt" | "categoryId">>): Promise<Subcategory | null>;
+    /**
+     * Soft delete podkategorije (postavlja isActive na false)
+     * @param categoryId - ID kategorije kojoj pripada podkategorija
+     * @param subcategoryId - ID podkategorije koja se briše
+     */
+    delete(categoryId: string, subcategoryId: string): Promise<void>;
+    /**
+     * Vraća podkategoriju po ID-u
+     * @param categoryId - ID kategorije kojoj pripada podkategorija
+     * @param subcategoryId - ID tražene podkategorije
+     * @returns Podkategorija ili null ako ne postoji
+     */
+    getById(categoryId: string, subcategoryId: string): Promise<Subcategory | null>;
 }
-declare class TreatmentBenefitError extends BackofficeError {
-    constructor(message: string);
+
+/**
+ * Blokirajući uslovi koji mogu sprečiti proceduru
+ * Ovi uslovi predstavljaju apsolutne kontraindikacije koje onemogućavaju izvođenje procedure
+ */
+declare enum BlockingCondition {
+    PREGNANCY = "pregnancy",
+    BREASTFEEDING = "breastfeeding",
+    ACTIVE_INFECTION = "active_infection",
+    SKIN_CONDITION = "skin_condition",
+    AUTOIMMUNE_DISEASE = "autoimmune_disease",
+    BLOOD_THINNERS = "blood_thinners",
+    RECENT_SURGERY = "recent_surgery",
+    DIABETES = "diabetes",
+    HEART_CONDITION = "heart_condition",
+    HIGH_BLOOD_PRESSURE = "high_blood_pressure",
+    KELOID_SCARRING = "keloid_scarring",
+    METAL_IMPLANTS = "metal_implants",
+    PACEMAKER = "pacemaker",
+    CANCER = "cancer",
+    EPILEPSY = "epilepsy"
 }
-declare class InvalidTreatmentBenefitError extends TreatmentBenefitError {
-    constructor(benefit: string);
+
+/**
+ * Kontraindikacije koje mogu uticati na proceduru
+ * Ovi uslovi predstavljaju relativne kontraindikacije koje zahtevaju posebnu pažnju
+ */
+declare enum Contraindication {
+    SENSITIVE_SKIN = "sensitive_skin",
+    RECENT_TANNING = "recent_tanning",
+    RECENT_BOTOX = "recent_botox",
+    RECENT_FILLERS = "recent_fillers",
+    SKIN_ALLERGIES = "skin_allergies",
+    MEDICATIONS = "medications",
+    RECENT_CHEMICAL_PEEL = "recent_chemical_peel",
+    RECENT_LASER = "recent_laser",
+    SKIN_INFLAMMATION = "skin_inflammation",
+    OPEN_WOUNDS = "open_wounds",
+    HERPES_SIMPLEX = "herpes_simplex",
+    COLD_SORES = "cold_sores"
 }
 
-declare const documentElementSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
-    id: z.ZodOptional<z.ZodString>;
-    type: z.ZodNativeEnum<typeof DocumentElementType>;
-    required: z.ZodOptional<z.ZodBoolean>;
-}, {
-    type: z.ZodLiteral<DocumentElementType.HEADING>;
-    text: z.ZodString;
-    level: z.ZodNativeEnum<typeof HeadingLevel>;
-}>, "strip", z.ZodTypeAny, {
-    type: DocumentElementType.HEADING;
-    text: string;
-    level: HeadingLevel;
-    id?: string | undefined;
-    required?: boolean | undefined;
-}, {
-    type: DocumentElementType.HEADING;
-    text: string;
-    level: HeadingLevel;
-    id?: string | undefined;
+/**
+ * Benefiti koji se mogu očekivati od procedure
+ * Lista mogućih pozitivnih efekata i rezultata tretmana
+ */
+declare enum TreatmentBenefit {
+    WRINKLE_REDUCTION = "wrinkle_reduction",
+    SKIN_TIGHTENING = "skin_tightening",
+    COLLAGEN_PRODUCTION = "collagen_production",
+    ACNE_REDUCTION = "acne_reduction",
+    SCAR_REDUCTION = "scar_reduction",
+    PIGMENTATION_IMPROVEMENT = "pigmentation_improvement",
+    HAIR_REMOVAL = "hair_removal",
+    MUSCLE_TONING = "muscle_toning",
+    FAT_REDUCTION = "fat_reduction",
+    CELLULITE_REDUCTION = "cellulite_reduction",
+    SKIN_REJUVENATION = "skin_rejuvenation",
+    PORE_REDUCTION = "pore_reduction",
+    TEXTURE_IMPROVEMENT = "texture_improvement",
+    HYDRATION_BOOST = "hydration_boost",
+    CIRCULATION_IMPROVEMENT = "circulation_improvement"
+}
+
+/**
+ * Nivoi sertifikacije medicinskog osoblja, poređani od najnižeg do najvišeg
+ */
+declare enum CertificationLevel {
+    AESTHETICIAN = "aesthetician",// Osnovni estetičar
+    NURSE_ASSISTANT = "nurse_assistant",// Medicinski tehničar
+    NURSE = "nurse",// Medicinska sestra
+    NURSE_PRACTITIONER = "nurse_practitioner",// Viša medicinska sestra
+    PHYSICIAN_ASSISTANT = "physician_assistant",// Lekar asistent
+    DOCTOR = "doctor",// Doktor medicine
+    SPECIALIST = "specialist",// Specijalista
+    PLASTIC_SURGEON = "plastic_surgeon"
+}
+/**
+ * Dodatne specijalizacije potrebne za određene procedure
+ */
+declare enum CertificationSpecialty {
+    LASER = "laser",// Sertifikat za laserske tretmane
+    INJECTABLES = "injectables",// Sertifikat za injekcione tretmane
+    CHEMICAL_PEELS = "chemical_peels",// Sertifikat za hemijske pilinge
+    MICRODERMABRASION = "microdermabrasion",// Sertifikat za mikrodermoabraziju
+    BODY_CONTOURING = "body_contouring",// Sertifikat za konturiranje tela
+    SKIN_CARE = "skin_care",// Sertifikat za negu kože
+    WOUND_CARE = "wound_care",// Sertifikat za tretman rana
+    ANESTHESIA = "anesthesia"
+}
+/**
+ * Zahtevi sertifikacije za izvođenje procedura
+ */
+interface CertificationRequirement {
+    /** Minimalni nivo sertifikacije potreban za proceduru */
+    minimumLevel: CertificationLevel;
+    /** Dodatne specijalizacije potrebne za proceduru */
+    requiredSpecialties?: CertificationSpecialty[];
+}
+
+/**
+ * Reference to a documentation template with metadata
+ * @property templateId - ID of the documentation template
+ * @property isUserForm - Whether this template is filled by users
+ * @property isRequired - Whether this template is required
+ * @property sortingOrder - The display order of this template
+ */
+interface TechnologyDocumentationTemplate {
+    templateId: string;
+    isUserForm: boolean;
+    isRequired: boolean;
+    sortingOrder: number;
+}
+/**
+ * Zahtevi koji su povezani sa tehnologijom
+ * @property pre - Lista zahteva koji se moraju ispuniti pre procedure
+ * @property post - Lista zahteva koji se moraju ispuniti posle procedure
+ */
+interface TechnologyRequirements {
+    pre: Requirement[];
+    post: Requirement[];
+}
+/**
+ * Technology used in medical procedures
+ * 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
+ * @property blockingConditions - List of conditions that prevent the procedure
+ * @property contraindications - List of conditions requiring special attention
+ * @property benefits - List of expected benefits from the procedure
+ * @property certificationRequirement - Required certification level and specialties
+ * @property documentationTemplates - List of documentation template references
+ * @property isActive - Whether the technology is active in the system
+ * @property createdAt - Creation date
+ * @property updatedAt - Last update date
+ */
+interface Technology {
+    id?: string;
+    name: string;
+    description: string;
+    family: ProcedureFamily;
+    categoryId: string;
+    subcategoryId: string;
+    technicalDetails?: string;
+    requirements: {
+        pre: Requirement[];
+        post: Requirement[];
+    };
+    blockingConditions: BlockingCondition[];
+    contraindications: Contraindication[];
+    benefits: TreatmentBenefit[];
+    certificationRequirement: CertificationRequirement;
+    documentationTemplates?: TechnologyDocumentationTemplate[];
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+/**
+ * Condensed practitioner review information
+ * @description Used for aggregated data attached to practitioner documents
+ */
+interface PractitionerReviewInfo {
+    totalReviews: number;
+    averageRating: number;
+    knowledgeAndExpertise: number;
+    communicationSkills: number;
+    bedSideManner: number;
+    thoroughness: number;
+    trustworthiness: number;
+    recommendationPercentage: number;
+}
+
+declare enum PricingMeasure {
+    PER_ML = "per_ml",
+    PER_ZONE = "per_zone",
+    PER_AREA = "per_area",
+    PER_SESSION = "per_session",
+    PER_TREATMENT = "per_treatment",
+    PER_PACKAGE = "per_package"
+}
+declare enum Currency {
+    EUR = "EUR",
+    USD = "USD",
+    GBP = "GBP",
+    CHF = "CHF",
+    AUD = "AUD"
+}
+
+/**
+ * Type that allows a field to be either a URL string or a File object
+ */
+type MediaResource = string | File | Blob;
+
+/**
+ * Aggregated summary information for a procedure.
+ * Used in arrays within Clinic and Practitioner documents for quick display.
+ */
+interface ProcedureSummaryInfo {
+    id: string;
+    name: string;
+    description?: string;
+    photo?: string;
+    family: ProcedureFamily;
+    categoryName: string;
+    subcategoryName: string;
+    technologyName: string;
+    brandName?: string;
+    productName?: string;
+    price: number;
+    pricingMeasure: PricingMeasure;
+    currency: Currency;
+    duration: number;
+    clinicId: string;
+    clinicName: string;
+    practitionerId: string;
+    practitionerName: string;
+}
+
+/**
+ * Interface for clinic contact information
+ */
+interface ClinicContactInfo {
+    email: string;
+    phoneNumber: string;
+    alternativePhoneNumber?: string | null;
+    website?: string | null;
+}
+/**
+ * Interface for clinic location
+ */
+interface ClinicLocation {
+    address: string;
+    city: string;
+    country: string;
+    postalCode: string;
+    latitude: number;
+    longitude: number;
+    geohash?: string | null;
+}
+
+/**
+ * Interface for clinic profile information
+ */
+interface ClinicInfo {
+    id: string;
+    featuredPhoto: string;
+    name: string;
+    description?: string | null;
+    location: ClinicLocation;
+    contactInfo: ClinicContactInfo;
+}
+
+/**
+ * Osnovne informacije o zdravstvenom radniku
+ */
+interface PractitionerBasicInfo {
+    firstName: string;
+    lastName: string;
+    title: string;
+    email: string;
+    phoneNumber: string | null;
+    dateOfBirth: Timestamp | Date | null;
+    gender: "male" | "female" | "other";
+    profileImageUrl?: MediaResource | null;
+    bio?: string;
+    languages: string[];
+}
+/**
+ * Sertifikacija zdravstvenog radnika
+ */
+interface PractitionerCertification {
+    level: CertificationLevel;
+    specialties: CertificationSpecialty[];
+    licenseNumber: string;
+    issuingAuthority: string;
+    issueDate: Timestamp | Date;
+    expiryDate?: Timestamp | Date | null;
+    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 | Date;
+    updatedAt: Timestamp | Date;
+}
+/**
+ * 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[];
+    clinicsInfo: ClinicInfo[];
+    procedures: string[];
+    freeConsultations?: Record<string, string> | null;
+    proceduresInfo: ProcedureSummaryInfo[];
+    reviewInfo: PractitionerReviewInfo;
+    isActive: boolean;
+    isVerified: boolean;
+    status: PractitionerStatus;
+    createdAt: Timestamp;
+    updatedAt: Timestamp;
+}
+
+/**
+ * Servis za upravljanje tehnologijama i njihovim zahtevima.
+ * 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({
+ *   name: "Botulinum Toxin",
+ *   description: "Neurotoxin injections for wrinkle reduction",
+ *   family: ProcedureFamily.AESTHETICS,
+ *   categoryId: "category123",
+ *   subcategoryId: "subcategory456"
+ * });
+ *
+ * // Dodavanje zahteva
+ * await technologyService.addRequirement(technology.id, {
+ *   type: "pre",
+ *   name: "Stay Hydrated",
+ *   description: "Drink plenty of water"
+ * });
+ */
+declare class TechnologyService extends BaseService {
+    /**
+     * Vraća referencu na Firestore kolekciju tehnologija
+     */
+    private getTechnologiesRef;
+    /**
+     * Kreira novu tehnologiju
+     * @param technology - Podaci za novu tehnologiju
+     * @returns Kreirana tehnologija sa generisanim ID-em
+     */
+    create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        isActive: boolean;
+        description: string;
+        family: ProcedureFamily;
+        technicalDetails?: string | undefined;
+        contraindications: Contraindication[];
+        blockingConditions: BlockingCondition[];
+        categoryId: string;
+        subcategoryId: string;
+        requirements: {
+            pre: Requirement[];
+            post: Requirement[];
+        };
+        benefits: TreatmentBenefit[];
+        certificationRequirement: CertificationRequirement;
+        documentationTemplates?: TechnologyDocumentationTemplate[] | undefined;
+        id: string;
+    }>;
+    /**
+     * 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(subcategoryId: string): Promise<Technology[]>;
+    /**
+     * Ažurira postojeću tehnologiju
+     * @param technologyId - ID tehnologije
+     * @param technology - Novi podaci za tehnologiju
+     * @returns Ažurirana tehnologija
+     */
+    update(technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "family" | "categoryId" | "subcategoryId">>): Promise<Technology | null>;
+    /**
+     * Soft delete tehnologije (postavlja isActive na false)
+     * @param technologyId - ID tehnologije koja se briše
+     */
+    delete(technologyId: string): Promise<void>;
+    /**
+     * Vraća tehnologiju po ID-u
+     * @param technologyId - ID tražene tehnologije
+     * @returns Tehnologija ili null ako ne postoji
+     */
+    getById(technologyId: string): Promise<Technology | null>;
+    /**
+     * Dodaje novi zahtev tehnologiji
+     * @param technologyId - ID tehnologije
+     * @param requirement - Zahtev koji se dodaje
+     * @returns Ažurirana tehnologija sa novim zahtevom
+     */
+    addRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    /**
+     * Uklanja zahtev iz tehnologije
+     * @param technologyId - ID tehnologije
+     * @param requirement - Zahtev koji se uklanja
+     * @returns Ažurirana tehnologija bez uklonjenog zahteva
+     */
+    removeRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
+    /**
+     * Vraća sve zahteve za tehnologiju
+     * @param technologyId - ID tehnologije
+     * @param type - Opcioni filter za tip zahteva (pre/post)
+     * @returns Lista zahteva
+     */
+    getRequirements(technologyId: string, type?: RequirementType): Promise<Requirement[]>;
+    /**
+     * Ažurira postojeći zahtev
+     * @param technologyId - ID tehnologije
+     * @param oldRequirement - Stari zahtev koji se menja
+     * @param newRequirement - Novi zahtev koji zamenjuje stari
+     * @returns Ažurirana tehnologija
+     */
+    updateRequirement(technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
+    /**
+     * Dodaje blokirajući uslov tehnologiji
+     * @param technologyId - ID tehnologije
+     * @param condition - Blokirajući uslov koji se dodaje
+     * @returns Ažurirana tehnologija
+     */
+    addBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    /**
+     * Uklanja blokirajući uslov iz tehnologije
+     * @param technologyId - ID tehnologije
+     * @param condition - Blokirajući uslov koji se uklanja
+     * @returns Ažurirana tehnologija
+     */
+    removeBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
+    /**
+     * Dodaje kontraindikaciju tehnologiji
+     * @param technologyId - ID tehnologije
+     * @param contraindication - Kontraindikacija koja se dodaje
+     * @returns Ažurirana tehnologija
+     */
+    addContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    /**
+     * Uklanja kontraindikaciju iz tehnologije
+     * @param technologyId - ID tehnologije
+     * @param contraindication - Kontraindikacija koja se uklanja
+     * @returns Ažurirana tehnologija
+     */
+    removeContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
+    /**
+     * Dodaje benefit tehnologiji
+     * @param technologyId - ID tehnologije
+     * @param benefit - Benefit koji se dodaje
+     * @returns Ažurirana tehnologija
+     */
+    addBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    /**
+     * Uklanja benefit iz tehnologije
+     * @param technologyId - ID tehnologije
+     * @param benefit - Benefit koji se uklanja
+     * @returns Ažurirana tehnologija
+     */
+    removeBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
+    /**
+     * Vraća sve blokirajuće uslove za tehnologiju
+     * @param technologyId - ID tehnologije
+     * @returns Lista blokirajućih uslova
+     */
+    getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
+    /**
+     * Vraća sve kontraindikacije za tehnologiju
+     * @param technologyId - ID tehnologije
+     * @returns Lista kontraindikacija
+     */
+    getContraindications(technologyId: string): Promise<Contraindication[]>;
+    /**
+     * Vraća sve benefite za tehnologiju
+     * @param technologyId - ID tehnologije
+     * @returns Lista benefita
+     */
+    getBenefits(technologyId: string): Promise<TreatmentBenefit[]>;
+    /**
+     * Ažurira zahteve sertifikacije za tehnologiju
+     * @param technologyId - ID tehnologije
+     * @param certificationRequirement - Novi zahtevi sertifikacije
+     * @returns Ažurirana tehnologija
+     */
+    updateCertificationRequirement(technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
+    /**
+     * Vraća zahteve sertifikacije za tehnologiju
+     * @param technologyId - ID tehnologije
+     * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
+     */
+    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[];
+    }>;
+}
+
+declare const documentElementSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodNativeEnum<typeof DocumentElementType>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, {
+    type: z.ZodLiteral<DocumentElementType.HEADING>;
+    text: z.ZodString;
+    level: z.ZodNativeEnum<typeof HeadingLevel>;
+}>, "strip", z.ZodTypeAny, {
+    type: DocumentElementType.HEADING;
+    text: string;
+    level: HeadingLevel;
+    id?: string | undefined;
+    required?: boolean | undefined;
+}, {
+    type: DocumentElementType.HEADING;
+    text: string;
+    level: HeadingLevel;
+    id?: string | undefined;
     required?: boolean | undefined;
 }>, z.ZodObject<z.objectUtil.extendShape<{
     id: z.ZodOptional<z.ZodString>;
@@ -1894,6 +2606,7 @@ declare const updateDocumentTemplateSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     isActive?: boolean | undefined;
     description?: string | undefined;
+    tags?: string[] | undefined;
     title?: string | undefined;
     elements?: ({
         type: DocumentElementType.HEADING;
@@ -1965,13 +2678,13 @@ declare const updateDocumentTemplateSchema: z.ZodObject<{
         allowedFileTypes?: string[] | undefined;
         maxFileSizeMB?: number | undefined;
     })[] | undefined;
-    tags?: string[] | undefined;
     isUserForm?: boolean | undefined;
     isRequired?: boolean | undefined;
     sortingOrder?: number | undefined;
 }, {
     isActive?: boolean | undefined;
     description?: string | undefined;
+    tags?: string[] | undefined;
     title?: string | undefined;
     elements?: ({
         type: DocumentElementType.HEADING;
@@ -2043,7 +2756,6 @@ declare const updateDocumentTemplateSchema: z.ZodObject<{
         allowedFileTypes?: string[] | undefined;
         maxFileSizeMB?: number | undefined;
     })[] | undefined;
-    tags?: string[] | undefined;
     isUserForm?: boolean | undefined;
     isRequired?: boolean | undefined;
     sortingOrder?: number | undefined;
@@ -2560,12 +3272,12 @@ declare const timeframeSchema: z.ZodObject<{
     unit: z.ZodNativeEnum<typeof TimeUnit>;
     notifyAt: z.ZodArray<z.ZodNumber, "many">;
 }, "strip", z.ZodTypeAny, {
-    duration: number;
     unit: TimeUnit;
+    duration: number;
     notifyAt: number[];
 }, {
-    duration: number;
     unit: TimeUnit;
+    duration: number;
     notifyAt: number[];
 }>;
 /**
@@ -2580,12 +3292,12 @@ declare const requirementSchema: z.ZodObject<{
         unit: z.ZodNativeEnum<typeof TimeUnit>;
         notifyAt: z.ZodArray<z.ZodNumber, "many">;
     }, "strip", z.ZodTypeAny, {
-        duration: number;
         unit: TimeUnit;
+        duration: number;
         notifyAt: number[];
     }, {
-        duration: number;
         unit: TimeUnit;
+        duration: number;
         notifyAt: number[];
     }>;
     importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -2596,8 +3308,8 @@ declare const requirementSchema: z.ZodObject<{
     description: string;
     type: RequirementType;
     timeframe: {
-        duration: number;
         unit: TimeUnit;
+        duration: number;
         notifyAt: number[];
     };
     importance: "low" | "medium" | "high";
@@ -2606,8 +3318,8 @@ declare const requirementSchema: z.ZodObject<{
     description: string;
     type: RequirementType;
     timeframe: {
-        duration: number;
         unit: TimeUnit;
+        duration: number;
         notifyAt: number[];
     };
     importance: "low" | "medium" | "high";
@@ -2626,12 +3338,12 @@ declare const technologyRequirementsSchema: z.ZodObject<{
             unit: z.ZodNativeEnum<typeof TimeUnit>;
             notifyAt: z.ZodArray<z.ZodNumber, "many">;
         }, "strip", z.ZodTypeAny, {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         }, {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         }>;
         importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -2642,8 +3354,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2652,8 +3364,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2668,12 +3380,12 @@ declare const technologyRequirementsSchema: z.ZodObject<{
             unit: z.ZodNativeEnum<typeof TimeUnit>;
             notifyAt: z.ZodArray<z.ZodNumber, "many">;
         }, "strip", z.ZodTypeAny, {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         }, {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         }>;
         importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -2684,8 +3396,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2694,8 +3406,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2708,8 +3420,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2720,8 +3432,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2732,8 +3444,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2744,8 +3456,8 @@ declare const technologyRequirementsSchema: z.ZodObject<{
         description: string;
         type: RequirementType;
         timeframe: {
-            duration: number;
             unit: TimeUnit;
+            duration: number;
             notifyAt: number[];
         };
         importance: "low" | "medium" | "high";
@@ -2772,12 +3484,12 @@ declare const technologySchema: z.ZodObject<{
                 unit: z.ZodNativeEnum<typeof TimeUnit>;
                 notifyAt: z.ZodArray<z.ZodNumber, "many">;
             }, "strip", z.ZodTypeAny, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }>;
             importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -2788,8 +3500,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2798,8 +3510,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2814,12 +3526,12 @@ declare const technologySchema: z.ZodObject<{
                 unit: z.ZodNativeEnum<typeof TimeUnit>;
                 notifyAt: z.ZodArray<z.ZodNumber, "many">;
             }, "strip", z.ZodTypeAny, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }>;
             importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -2830,8 +3542,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2840,8 +3552,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2854,8 +3566,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2866,8 +3578,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2878,8 +3590,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -2890,8 +3602,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3394,8 +4106,9 @@ declare const technologySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     isActive: boolean;
-    contraindications: Contraindication[];
     family: ProcedureFamily;
+    contraindications: Contraindication[];
+    blockingConditions: BlockingCondition[];
     categoryId: string;
     subcategoryId: string;
     requirements: {
@@ -3405,8 +4118,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3417,14 +4130,18 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
         }[];
     };
-    blockingConditions: BlockingCondition[];
+    benefits: TreatmentBenefit[];
+    certificationRequirement: {
+        minimumLevel: CertificationLevel;
+        requiredSpecialties?: CertificationSpecialty[] | undefined;
+    };
     documentationTemplates: {
         id: string;
         createdAt: number;
@@ -3522,20 +4239,20 @@ declare const technologySchema: z.ZodObject<{
         description?: string | undefined;
         tags?: string[] | undefined;
     }[];
-    benefits: TreatmentBenefit[];
-    certificationRequirement: {
-        minimumLevel: CertificationLevel;
-        requiredSpecialties?: CertificationSpecialty[] | undefined;
-    };
     description?: string | undefined;
     technicalDetails?: string | undefined;
 }, {
     name: string;
-    contraindications: Contraindication[];
     family: ProcedureFamily;
+    contraindications: Contraindication[];
+    blockingConditions: BlockingCondition[];
     categoryId: string;
     subcategoryId: string;
-    blockingConditions: BlockingCondition[];
+    benefits: TreatmentBenefit[];
+    certificationRequirement: {
+        minimumLevel: CertificationLevel;
+        requiredSpecialties?: CertificationSpecialty[] | undefined;
+    };
     documentationTemplates: {
         id: string;
         createdAt: number;
@@ -3633,11 +4350,6 @@ declare const technologySchema: z.ZodObject<{
         isRequired?: boolean | undefined;
         sortingOrder?: number | undefined;
     }[];
-    benefits: TreatmentBenefit[];
-    certificationRequirement: {
-        minimumLevel: CertificationLevel;
-        requiredSpecialties?: CertificationSpecialty[] | undefined;
-    };
     isActive?: boolean | undefined;
     description?: string | undefined;
     technicalDetails?: string | undefined;
@@ -3647,8 +4359,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3659,8 +4371,8 @@ declare const technologySchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3758,12 +4470,12 @@ declare const technologyUpdateSchema: z.ZodObject<{
                 unit: z.ZodNativeEnum<typeof TimeUnit>;
                 notifyAt: z.ZodArray<z.ZodNumber, "many">;
             }, "strip", z.ZodTypeAny, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }>;
             importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -3774,8 +4486,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3784,8 +4496,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3800,12 +4512,12 @@ declare const technologyUpdateSchema: z.ZodObject<{
                 unit: z.ZodNativeEnum<typeof TimeUnit>;
                 notifyAt: z.ZodArray<z.ZodNumber, "many">;
             }, "strip", z.ZodTypeAny, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }, {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             }>;
             importance: z.ZodEnum<["low", "medium", "high"]>;
@@ -3816,8 +4528,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3826,8 +4538,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3840,8 +4552,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3852,8 +4564,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3864,8 +4576,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -3876,8 +4588,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -4381,9 +5093,10 @@ declare const technologyUpdateSchema: z.ZodObject<{
     name?: string | undefined;
     isActive?: boolean | undefined;
     description?: string | undefined;
+    family?: ProcedureFamily | undefined;
     technicalDetails?: string | undefined;
     contraindications?: Contraindication[] | undefined;
-    family?: ProcedureFamily | undefined;
+    blockingConditions?: BlockingCondition[] | undefined;
     categoryId?: string | undefined;
     subcategoryId?: string | undefined;
     requirements?: {
@@ -4393,8 +5106,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -4405,14 +5118,18 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
         }[];
     } | undefined;
-    blockingConditions?: BlockingCondition[] | undefined;
+    benefits?: TreatmentBenefit[] | undefined;
+    certificationRequirement?: {
+        minimumLevel: CertificationLevel;
+        requiredSpecialties?: CertificationSpecialty[] | undefined;
+    } | undefined;
     documentationTemplates?: {
         id: string;
         createdAt: number;
@@ -4510,18 +5227,14 @@ declare const technologyUpdateSchema: z.ZodObject<{
         description?: string | undefined;
         tags?: string[] | undefined;
     }[] | undefined;
-    benefits?: TreatmentBenefit[] | undefined;
-    certificationRequirement?: {
-        minimumLevel: CertificationLevel;
-        requiredSpecialties?: CertificationSpecialty[] | undefined;
-    } | undefined;
 }, {
     name?: string | undefined;
     isActive?: boolean | undefined;
     description?: string | undefined;
+    family?: ProcedureFamily | undefined;
     technicalDetails?: string | undefined;
     contraindications?: Contraindication[] | undefined;
-    family?: ProcedureFamily | undefined;
+    blockingConditions?: BlockingCondition[] | undefined;
     categoryId?: string | undefined;
     subcategoryId?: string | undefined;
     requirements?: {
@@ -4530,8 +5243,8 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
@@ -4542,15 +5255,19 @@ declare const technologyUpdateSchema: z.ZodObject<{
             description: string;
             type: RequirementType;
             timeframe: {
-                duration: number;
                 unit: TimeUnit;
+                duration: number;
                 notifyAt: number[];
             };
             importance: "low" | "medium" | "high";
             isActive?: boolean | undefined;
         }[];
     } | undefined;
-    blockingConditions?: BlockingCondition[] | undefined;
+    benefits?: TreatmentBenefit[] | undefined;
+    certificationRequirement?: {
+        minimumLevel: CertificationLevel;
+        requiredSpecialties?: CertificationSpecialty[] | undefined;
+    } | undefined;
     documentationTemplates?: {
         id: string;
         createdAt: number;
@@ -4567,940 +5284,223 @@ declare const technologyUpdateSchema: z.ZodObject<{
             type: DocumentElementType.PARAGRAPH;
             text: string;
             id?: string | undefined;
-            required?: boolean | undefined;
-        } | {
-            type: DocumentElementType.LIST;
-            items: string[];
-            listType: ListType;
-            id?: string | undefined;
-            required?: boolean | undefined;
-        } | {
-            type: DocumentElementType.DYNAMIC_TEXT;
-            text: string;
-            id?: string | undefined;
-            required?: boolean | undefined;
-        } | {
-            type: DocumentElementType.BINARY_CHOICE;
-            question: string;
-            id?: string | undefined;
-            required?: boolean | undefined;
-            defaultValue?: boolean | undefined;
-        } | {
-            type: DocumentElementType.MULTIPLE_CHOICE;
-            question: string;
-            options: string[];
-            id?: string | undefined;
-            required?: boolean | undefined;
-            defaultValues?: string[] | undefined;
-        } | {
-            type: DocumentElementType.SINGLE_CHOICE;
-            question: string;
-            options: string[];
-            id?: string | undefined;
-            required?: boolean | undefined;
-            defaultValue?: string | undefined;
-        } | {
-            type: DocumentElementType.RATING_SCALE;
-            question: string;
-            min: number;
-            max: number;
-            id?: string | undefined;
-            required?: boolean | undefined;
-            defaultValue?: number | undefined;
-            labels?: Record<string, string> | undefined;
-        } | {
-            type: DocumentElementType.TEXT_INPUT;
-            label: string;
-            id?: string | undefined;
-            required?: boolean | undefined;
-            defaultValue?: string | undefined;
-            placeholder?: string | undefined;
-            multiline?: boolean | undefined;
+            required?: boolean | undefined;
         } | {
-            type: DocumentElementType.DATE_PICKER;
-            label: string;
+            type: DocumentElementType.LIST;
+            items: string[];
+            listType: ListType;
             id?: string | undefined;
             required?: boolean | undefined;
-            defaultValue?: string | undefined;
         } | {
-            type: DocumentElementType.SIGNATURE;
-            label: string;
+            type: DocumentElementType.DYNAMIC_TEXT;
+            text: string;
             id?: string | undefined;
             required?: boolean | undefined;
         } | {
-            type: DocumentElementType.DITIGAL_SIGNATURE;
-            label: string;
+            type: DocumentElementType.BINARY_CHOICE;
+            question: string;
             id?: string | undefined;
             required?: boolean | undefined;
+            defaultValue?: boolean | undefined;
         } | {
-            type: DocumentElementType.FILE_UPLOAD;
-            label: string;
+            type: DocumentElementType.MULTIPLE_CHOICE;
+            question: string;
+            options: string[];
             id?: string | undefined;
             required?: boolean | undefined;
-            allowedFileTypes?: string[] | undefined;
-            maxFileSizeMB?: number | undefined;
-        })[];
-        createdBy: string;
-        version: number;
-        description?: string | undefined;
-        tags?: string[] | undefined;
-        isUserForm?: boolean | undefined;
-        isRequired?: boolean | undefined;
-        sortingOrder?: number | undefined;
-    }[] | undefined;
-    benefits?: TreatmentBenefit[] | undefined;
-    certificationRequirement?: {
-        minimumLevel: CertificationLevel;
-        requiredSpecialties?: CertificationSpecialty[] | undefined;
-    } | undefined;
-}>;
-declare const requirementUpdateSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodNativeEnum<typeof RequirementType>>;
-    timeframe: z.ZodOptional<z.ZodObject<{
-        duration: z.ZodNumber;
-        unit: z.ZodNativeEnum<typeof TimeUnit>;
-        notifyAt: z.ZodArray<z.ZodNumber, "many">;
-    }, "strip", z.ZodTypeAny, {
-        duration: number;
-        unit: TimeUnit;
-        notifyAt: number[];
-    }, {
-        duration: number;
-        unit: TimeUnit;
-        notifyAt: number[];
-    }>>;
-    importance: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
-    isActive: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    isActive?: boolean | undefined;
-    description?: string | undefined;
-    type?: RequirementType | undefined;
-    timeframe?: {
-        duration: number;
-        unit: TimeUnit;
-        notifyAt: number[];
-    } | undefined;
-    importance?: "low" | "medium" | "high" | undefined;
-}, {
-    name?: string | undefined;
-    isActive?: boolean | undefined;
-    description?: string | undefined;
-    type?: RequirementType | undefined;
-    timeframe?: {
-        duration: number;
-        unit: TimeUnit;
-        notifyAt: number[];
-    } | undefined;
-    importance?: "low" | "medium" | "high" | undefined;
-}>;
-
-declare class BaseService {
-    protected db: Firestore;
-    protected auth: Auth;
-    protected app: FirebaseApp;
-    protected storage: FirebaseStorage;
-    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
-    /**
-     * Generiše jedinstveni ID za dokumente
-     * Format: xxxxxxxxxxxx-timestamp
-     * Gde je x random karakter (broj ili slovo)
-     */
-    protected generateId(): string;
-}
-
-/**
- * Servis za upravljanje kategorijama procedura.
- * Kategorije su prvi nivo organizacije nakon procedure family (aesthetics/surgery).
- *
- * @example
- * const categoryService = new CategoryService();
- *
- * // Kreiranje nove kategorije
- * const category = await categoryService.create({
- *   name: "Injectables",
- *   family: ProcedureFamily.AESTHETICS
- * });
- */
-declare class CategoryService extends BaseService {
-    /**
-     * Referenca na Firestore kolekciju kategorija
-     */
-    private get categoriesRef();
-    /**
-     * Kreira novu kategoriju u sistemu
-     * @param category - Podaci za novu kategoriju
-     * @returns Kreirana kategorija sa generisanim ID-em
-     */
-    create(category: Omit<Category, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description: string;
-        family: ProcedureFamily;
-        id: string;
-    }>;
-    /**
-     * Vraća sve aktivne kategorije
-     * @returns Lista aktivnih kategorija
-     */
-    getAll(): Promise<Category[]>;
-    /**
-     * Vraća sve aktivne kategorije za određenu familiju procedura
-     * @param family - Familija procedura (aesthetics/surgery)
-     * @returns Lista kategorija koje pripadaju traženoj familiji
-     */
-    getAllByFamily(family: ProcedureFamily): Promise<Category[]>;
-    /**
-     * Ažurira postojeću kategoriju
-     * @param id - ID kategorije koja se ažurira
-     * @param category - Novi podaci za kategoriju
-     * @returns Ažurirana kategorija
-     */
-    update(id: string, category: Partial<Omit<Category, "id" | "createdAt">>): Promise<Category | null>;
-    /**
-     * Soft delete kategorije (postavlja isActive na false)
-     * @param id - ID kategorije koja se briše
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Vraća kategoriju po ID-u
-     * @param id - ID tražene kategorije
-     * @returns Kategorija ili null ako ne postoji
-     */
-    getById(id: string): Promise<Category | null>;
-}
-
-/**
- * Servis za upravljanje podkategorijama procedura.
- * Podkategorije su drugi nivo organizacije i pripadaju određenoj kategoriji.
- *
- * @example
- * const subcategoryService = new SubcategoryService();
- *
- * // Kreiranje nove podkategorije
- * const subcategory = await subcategoryService.create(categoryId, {
- *   name: "Anti-Wrinkle",
- *   description: "Treatments targeting facial wrinkles"
- * });
- */
-declare class SubcategoryService extends BaseService {
-    /**
-     * Vraća referencu na Firestore kolekciju podkategorija za određenu kategoriju
-     * @param categoryId - ID roditeljske kategorije
-     */
-    private getSubcategoriesRef;
-    /**
-     * Kreira novu podkategoriju u okviru kategorije
-     * @param categoryId - ID kategorije kojoj će pripadati nova podkategorija
-     * @param subcategory - Podaci za novu podkategoriju
-     * @returns Kreirana podkategorija sa generisanim ID-em
-     */
-    create(categoryId: string, subcategory: Omit<Subcategory, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description?: string | undefined;
-        categoryId: string;
-        id: string;
-    }>;
-    /**
-     * Vraća sve aktivne podkategorije za određenu kategoriju
-     * @param categoryId - ID kategorije čije podkategorije tražimo
-     * @returns Lista aktivnih podkategorija
-     */
-    getAllByCategoryId(categoryId: string): Promise<Subcategory[]>;
-    /**
-     * Ažurira postojeću podkategoriju
-     * @param categoryId - ID kategorije kojoj pripada podkategorija
-     * @param subcategoryId - ID podkategorije koja se ažurira
-     * @param subcategory - Novi podaci za podkategoriju
-     * @returns Ažurirana podkategorija
-     */
-    update(categoryId: string, subcategoryId: string, subcategory: Partial<Omit<Subcategory, "id" | "createdAt" | "categoryId">>): Promise<Subcategory | null>;
-    /**
-     * Soft delete podkategorije (postavlja isActive na false)
-     * @param categoryId - ID kategorije kojoj pripada podkategorija
-     * @param subcategoryId - ID podkategorije koja se briše
-     */
-    delete(categoryId: string, subcategoryId: string): Promise<void>;
-    /**
-     * Vraća podkategoriju po ID-u
-     * @param categoryId - ID kategorije kojoj pripada podkategorija
-     * @param subcategoryId - ID tražene podkategorije
-     * @returns Podkategorija ili null ako ne postoji
-     */
-    getById(categoryId: string, subcategoryId: string): Promise<Subcategory | null>;
-}
-
-/**
- * Condensed practitioner review information
- * @description Used for aggregated data attached to practitioner documents
- */
-interface PractitionerReviewInfo {
-    totalReviews: number;
-    averageRating: number;
-    knowledgeAndExpertise: number;
-    communicationSkills: number;
-    bedSideManner: number;
-    thoroughness: number;
-    trustworthiness: number;
-    recommendationPercentage: number;
-}
-
-declare enum PricingMeasure {
-    PER_ML = "per_ml",
-    PER_ZONE = "per_zone",
-    PER_AREA = "per_area",
-    PER_SESSION = "per_session",
-    PER_TREATMENT = "per_treatment",
-    PER_PACKAGE = "per_package"
-}
-declare enum Currency {
-    EUR = "EUR",
-    USD = "USD",
-    GBP = "GBP",
-    CHF = "CHF",
-    AUD = "AUD"
-}
-
-/**
- * Type that allows a field to be either a URL string or a File object
- */
-type MediaResource = string | File | Blob;
+            defaultValues?: string[] | undefined;
+        } | {
+            type: DocumentElementType.SINGLE_CHOICE;
+            question: string;
+            options: string[];
+            id?: string | undefined;
+            required?: boolean | undefined;
+            defaultValue?: string | undefined;
+        } | {
+            type: DocumentElementType.RATING_SCALE;
+            question: string;
+            min: number;
+            max: number;
+            id?: string | undefined;
+            required?: boolean | undefined;
+            defaultValue?: number | undefined;
+            labels?: Record<string, string> | undefined;
+        } | {
+            type: DocumentElementType.TEXT_INPUT;
+            label: string;
+            id?: string | undefined;
+            required?: boolean | undefined;
+            defaultValue?: string | undefined;
+            placeholder?: string | undefined;
+            multiline?: boolean | undefined;
+        } | {
+            type: DocumentElementType.DATE_PICKER;
+            label: string;
+            id?: string | undefined;
+            required?: boolean | undefined;
+            defaultValue?: string | undefined;
+        } | {
+            type: DocumentElementType.SIGNATURE;
+            label: string;
+            id?: string | undefined;
+            required?: boolean | undefined;
+        } | {
+            type: DocumentElementType.DITIGAL_SIGNATURE;
+            label: string;
+            id?: string | undefined;
+            required?: boolean | undefined;
+        } | {
+            type: DocumentElementType.FILE_UPLOAD;
+            label: string;
+            id?: string | undefined;
+            required?: boolean | undefined;
+            allowedFileTypes?: string[] | undefined;
+            maxFileSizeMB?: number | undefined;
+        })[];
+        createdBy: string;
+        version: number;
+        description?: string | undefined;
+        tags?: string[] | undefined;
+        isUserForm?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        sortingOrder?: number | undefined;
+    }[] | undefined;
+}>;
+declare const requirementUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodNativeEnum<typeof RequirementType>>;
+    timeframe: z.ZodOptional<z.ZodObject<{
+        duration: z.ZodNumber;
+        unit: z.ZodNativeEnum<typeof TimeUnit>;
+        notifyAt: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        unit: TimeUnit;
+        duration: number;
+        notifyAt: number[];
+    }, {
+        unit: TimeUnit;
+        duration: number;
+        notifyAt: number[];
+    }>>;
+    importance: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    isActive: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    isActive?: boolean | undefined;
+    description?: string | undefined;
+    type?: RequirementType | undefined;
+    timeframe?: {
+        unit: TimeUnit;
+        duration: number;
+        notifyAt: number[];
+    } | undefined;
+    importance?: "low" | "medium" | "high" | undefined;
+}, {
+    name?: string | undefined;
+    isActive?: boolean | undefined;
+    description?: string | undefined;
+    type?: RequirementType | undefined;
+    timeframe?: {
+        unit: TimeUnit;
+        duration: number;
+        notifyAt: number[];
+    } | undefined;
+    importance?: "low" | "medium" | "high" | undefined;
+}>;
 
 /**
- * Aggregated summary information for a procedure.
- * Used in arrays within Clinic and Practitioner documents for quick display.
+ * Default vrednosti za sertifikaciju
+ * Svaka nova tehnologija će imati ove vrednosti ako se ne specificira drugačije
  */
-interface ProcedureSummaryInfo {
-    id: string;
-    name: string;
-    description?: string;
-    photo?: string;
-    family: ProcedureFamily;
-    categoryName: string;
-    subcategoryName: string;
-    technologyName: string;
-    brandName?: string;
-    productName?: string;
-    price: number;
-    pricingMeasure: PricingMeasure;
-    currency: Currency;
-    duration: number;
-    clinicId: string;
-    clinicName: string;
-    practitionerId: string;
-    practitionerName: string;
-}
+declare const DEFAULT_CERTIFICATION_REQUIREMENT: CertificationRequirement;
 
 /**
- * Interface for clinic contact information
- */
-interface ClinicContactInfo {
-    email: string;
-    phoneNumber: string;
-    alternativePhoneNumber?: string | null;
-    website?: string | null;
-}
-/**
- * Interface for clinic location
+ * Bazna klasa za greške u backoffice sistemu
  */
-interface ClinicLocation {
-    address: string;
-    city: string;
-    country: string;
-    postalCode: string;
-    latitude: number;
-    longitude: number;
-    geohash?: string | null;
+declare class BackofficeError extends Error {
+    constructor(message: string);
 }
-
 /**
- * Interface for clinic profile information
+ * Errors related to Category operations
  */
-interface ClinicInfo {
-    id: string;
-    featuredPhoto: string;
-    name: string;
-    description?: string | null;
-    location: ClinicLocation;
-    contactInfo: ClinicContactInfo;
+declare class CategoryError extends BackofficeError {
+    constructor(message: string);
 }
-
-/**
- * Osnovne informacije o zdravstvenom radniku
- */
-interface PractitionerBasicInfo {
-    firstName: string;
-    lastName: string;
-    title: string;
-    email: string;
-    phoneNumber: string | null;
-    dateOfBirth: Timestamp | Date | null;
-    gender: "male" | "female" | "other";
-    profileImageUrl?: MediaResource | null;
-    bio?: string;
-    languages: string[];
+declare class CategoryNotFoundError extends CategoryError {
+    constructor(id: string);
 }
-/**
- * Sertifikacija zdravstvenog radnika
- */
-interface PractitionerCertification {
-    level: CertificationLevel;
-    specialties: CertificationSpecialty[];
-    licenseNumber: string;
-    issuingAuthority: string;
-    issueDate: Timestamp | Date;
-    expiryDate?: Timestamp | Date | null;
-    verificationStatus: "pending" | "verified" | "rejected";
+declare class InvalidCategoryDataError extends CategoryError {
+    constructor(message: string);
 }
 /**
- * Interfejs za radno vreme zdravstvenog radnika u klinici
+ * Errors related to Subcategory operations
  */
-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 | Date;
-    updatedAt: Timestamp | Date;
+declare class SubcategoryError extends BackofficeError {
+    constructor(message: string);
 }
-/**
- * Status of practitioner profile
- */
-declare enum PractitionerStatus {
-    DRAFT = "draft",
-    ACTIVE = "active"
+declare class SubcategoryNotFoundError extends SubcategoryError {
+    constructor(id: string);
 }
-/**
- * Interfejs za zdravstvenog radnika
- */
-interface Practitioner {
-    id: string;
-    userRef: string;
-    basicInfo: PractitionerBasicInfo;
-    certification: PractitionerCertification;
-    clinics: string[];
-    clinicWorkingHours: PractitionerClinicWorkingHours[];
-    clinicsInfo: ClinicInfo[];
-    procedures: string[];
-    freeConsultations?: Record<string, string> | null;
-    proceduresInfo: ProcedureSummaryInfo[];
-    reviewInfo: PractitionerReviewInfo;
-    isActive: boolean;
-    isVerified: boolean;
-    status: PractitionerStatus;
-    createdAt: Timestamp;
-    updatedAt: Timestamp;
+declare class InvalidSubcategoryDataError extends SubcategoryError {
+    constructor(message: string);
 }
-
 /**
- * Servis za upravljanje tehnologijama i njihovim zahtevima.
- * 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({
- *   name: "Botulinum Toxin",
- *   description: "Neurotoxin injections for wrinkle reduction",
- *   family: ProcedureFamily.AESTHETICS,
- *   categoryId: "category123",
- *   subcategoryId: "subcategory456"
- * });
- *
- * // Dodavanje zahteva
- * await technologyService.addRequirement(technology.id, {
- *   type: "pre",
- *   name: "Stay Hydrated",
- *   description: "Drink plenty of water"
- * });
+ * Errors related to Technology operations
  */
-declare class TechnologyService extends BaseService {
-    /**
-     * Vraća referencu na Firestore kolekciju tehnologija
-     */
-    private getTechnologiesRef;
-    /**
-     * Kreira novu tehnologiju
-     * @param technology - Podaci za novu tehnologiju
-     * @returns Kreirana tehnologija sa generisanim ID-em
-     */
-    create(technology: Omit<Technology, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description: string;
-        technicalDetails?: string | undefined;
-        contraindications: Contraindication[];
-        family: ProcedureFamily;
-        categoryId: string;
-        subcategoryId: string;
-        requirements: {
-            pre: Requirement[];
-            post: Requirement[];
-        };
-        blockingConditions: BlockingCondition[];
-        documentationTemplates?: TechnologyDocumentationTemplate[] | undefined;
-        benefits: TreatmentBenefit[];
-        certificationRequirement: CertificationRequirement;
-        id: string;
-    }>;
-    /**
-     * 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(subcategoryId: string): Promise<Technology[]>;
-    /**
-     * Ažurira postojeću tehnologiju
-     * @param technologyId - ID tehnologije
-     * @param technology - Novi podaci za tehnologiju
-     * @returns Ažurirana tehnologija
-     */
-    update(technologyId: string, technology: Partial<Omit<Technology, "id" | "createdAt" | "family" | "categoryId" | "subcategoryId">>): Promise<Technology | null>;
-    /**
-     * Soft delete tehnologije (postavlja isActive na false)
-     * @param technologyId - ID tehnologije koja se briše
-     */
-    delete(technologyId: string): Promise<void>;
-    /**
-     * Vraća tehnologiju po ID-u
-     * @param technologyId - ID tražene tehnologije
-     * @returns Tehnologija ili null ako ne postoji
-     */
-    getById(technologyId: string): Promise<Technology | null>;
-    /**
-     * Dodaje novi zahtev tehnologiji
-     * @param technologyId - ID tehnologije
-     * @param requirement - Zahtev koji se dodaje
-     * @returns Ažurirana tehnologija sa novim zahtevom
-     */
-    addRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
-    /**
-     * Uklanja zahtev iz tehnologije
-     * @param technologyId - ID tehnologije
-     * @param requirement - Zahtev koji se uklanja
-     * @returns Ažurirana tehnologija bez uklonjenog zahteva
-     */
-    removeRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
-    /**
-     * Vraća sve zahteve za tehnologiju
-     * @param technologyId - ID tehnologije
-     * @param type - Opcioni filter za tip zahteva (pre/post)
-     * @returns Lista zahteva
-     */
-    getRequirements(technologyId: string, type?: RequirementType): Promise<Requirement[]>;
-    /**
-     * Ažurira postojeći zahtev
-     * @param technologyId - ID tehnologije
-     * @param oldRequirement - Stari zahtev koji se menja
-     * @param newRequirement - Novi zahtev koji zamenjuje stari
-     * @returns Ažurirana tehnologija
-     */
-    updateRequirement(technologyId: string, oldRequirement: Requirement, newRequirement: Requirement): Promise<Technology | null>;
-    /**
-     * Dodaje blokirajući uslov tehnologiji
-     * @param technologyId - ID tehnologije
-     * @param condition - Blokirajući uslov koji se dodaje
-     * @returns Ažurirana tehnologija
-     */
-    addBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
-    /**
-     * Uklanja blokirajući uslov iz tehnologije
-     * @param technologyId - ID tehnologije
-     * @param condition - Blokirajući uslov koji se uklanja
-     * @returns Ažurirana tehnologija
-     */
-    removeBlockingCondition(technologyId: string, condition: BlockingCondition): Promise<Technology | null>;
-    /**
-     * Dodaje kontraindikaciju tehnologiji
-     * @param technologyId - ID tehnologije
-     * @param contraindication - Kontraindikacija koja se dodaje
-     * @returns Ažurirana tehnologija
-     */
-    addContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
-    /**
-     * Uklanja kontraindikaciju iz tehnologije
-     * @param technologyId - ID tehnologije
-     * @param contraindication - Kontraindikacija koja se uklanja
-     * @returns Ažurirana tehnologija
-     */
-    removeContraindication(technologyId: string, contraindication: Contraindication): Promise<Technology | null>;
-    /**
-     * Dodaje benefit tehnologiji
-     * @param technologyId - ID tehnologije
-     * @param benefit - Benefit koji se dodaje
-     * @returns Ažurirana tehnologija
-     */
-    addBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
-    /**
-     * Uklanja benefit iz tehnologije
-     * @param technologyId - ID tehnologije
-     * @param benefit - Benefit koji se uklanja
-     * @returns Ažurirana tehnologija
-     */
-    removeBenefit(technologyId: string, benefit: TreatmentBenefit): Promise<Technology | null>;
-    /**
-     * Vraća sve blokirajuće uslove za tehnologiju
-     * @param technologyId - ID tehnologije
-     * @returns Lista blokirajućih uslova
-     */
-    getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
-    /**
-     * Vraća sve kontraindikacije za tehnologiju
-     * @param technologyId - ID tehnologije
-     * @returns Lista kontraindikacija
-     */
-    getContraindications(technologyId: string): Promise<Contraindication[]>;
-    /**
-     * Vraća sve benefite za tehnologiju
-     * @param technologyId - ID tehnologije
-     * @returns Lista benefita
-     */
-    getBenefits(technologyId: string): Promise<TreatmentBenefit[]>;
-    /**
-     * Ažurira zahteve sertifikacije za tehnologiju
-     * @param technologyId - ID tehnologije
-     * @param certificationRequirement - Novi zahtevi sertifikacije
-     * @returns Ažurirana tehnologija
-     */
-    updateCertificationRequirement(technologyId: string, certificationRequirement: CertificationRequirement): Promise<Technology | null>;
-    /**
-     * Vraća zahteve sertifikacije za tehnologiju
-     * @param technologyId - ID tehnologije
-     * @returns Zahtevi sertifikacije ili null ako tehnologija ne postoji
-     */
-    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[];
-    }>;
+declare class TechnologyError extends BackofficeError {
+    constructor(message: string);
+}
+declare class TechnologyNotFoundError extends TechnologyError {
+    constructor(id: string);
+}
+declare class InvalidTechnologyDataError extends TechnologyError {
+    constructor(message: string);
 }
-
 /**
- * Servis za upravljanje globalnim zahtevima.
- * Zahtevi se mogu kreirati globalno i zatim povezati sa različitim tehnologijama.
- * Ovo omogućava ponovno korišćenje istih zahteva za različite tehnologije.
- *
- * @example
- * const requirementService = new RequirementService();
- *
- * // Kreiranje globalnog zahteva
- * const requirement = await requirementService.create({
- *   type: "pre",
- *   name: "Stay Hydrated",
- *   description: "Drink plenty of water",
- *   timeframe: {
- *     duration: 2,
- *     unit: "hours",
- *     notifyAt: [2, 1]
- *   },
- *   importance: "high"
- * });
+ * Errors related to Requirement operations
  */
-declare class RequirementService extends BaseService {
-    /**
-     * Referenca na Firestore kolekciju zahteva
-     */
-    private get requirementsRef();
-    /**
-     * Kreira novi globalni zahtev
-     * @param requirement - Podaci za novi zahtev
-     * @returns Kreirani zahtev sa generisanim ID-em
-     */
-    create(requirement: Omit<Requirement, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description: string;
-        type: RequirementType;
-        timeframe: TimeFrame;
-        importance: RequirementImportance;
-        id: string;
-    }>;
-    /**
-     * Vraća sve aktivne zahteve
-     * @returns Lista aktivnih zahteva
-     */
-    getAll(): Promise<Requirement[]>;
-    /**
-     * Vraća sve aktivne zahteve određenog tipa
-     * @param type - Tip zahteva (pre/post)
-     * @returns Lista zahteva određenog tipa
-     */
-    getAllByType(type: RequirementType): Promise<Requirement[]>;
-    /**
-     * Ažurira postojeći zahtev
-     * @param id - ID zahteva koji se ažurira
-     * @param requirement - Novi podaci za zahtev
-     * @returns Ažurirani zahtev
-     */
-    update(id: string, requirement: Partial<Omit<Requirement, "id" | "createdAt">>): Promise<Requirement | null>;
-    /**
-     * Soft delete zahteva (postavlja isActive na false)
-     * @param id - ID zahteva koji se briše
-     */
-    delete(id: string): Promise<void>;
-    /**
-     * Vraća zahtev po ID-u
-     * @param id - ID traženog zahteva
-     * @returns Zahtev ili null ako ne postoji
-     */
-    getById(id: string): Promise<Requirement | null>;
+declare class RequirementError extends BackofficeError {
+    constructor(message: string);
 }
-
-declare class BrandService extends BaseService {
-    /**
-     * Gets reference to brands collection
-     */
-    private getBrandsRef;
-    /**
-     * Creates a new brand
-     */
-    create(brand: Omit<Brand, "id" | "createdAt" | "updatedAt">): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
-        name: string;
-        isActive: boolean;
-        description?: string | undefined;
-        manufacturer: string;
-        website?: string | undefined;
-        id: string;
-    }>;
-    /**
-     * Gets all active brands
-     */
-    getAll(): Promise<Brand[]>;
-    /**
-     * Updates a brand
-     */
-    update(brandId: string, brand: Partial<Omit<Brand, "id" | "createdAt">>): Promise<Brand | null>;
-    /**
-     * Soft deletes a brand
-     */
-    delete(brandId: string): Promise<void>;
-    /**
-     * Gets a brand by ID
-     */
-    getById(brandId: string): Promise<Brand | null>;
+declare class RequirementNotFoundError extends RequirementError {
+    constructor(id: string);
 }
-
-declare class ProductService extends BaseService implements IProductService {
-    /**
-     * Gets reference to products collection under a technology
-     * @param technologyId - ID of the technology
-     * @returns Firestore collection reference
-     */
-    private getProductsRef;
-    /**
-     * Creates a new product under technology
-     */
-    create(technologyId: string, brandId: string, product: Omit<Product, "id" | "createdAt" | "updatedAt" | "brandId" | "technologyId">): Promise<Product>;
-    /**
-     * Gets all products for a technology
-     */
-    getAllByTechnology(technologyId: string): Promise<Product[]>;
-    /**
-     * Gets all products for a brand by filtering through all technologies
-     */
-    getAllByBrand(brandId: string): Promise<Product[]>;
-    /**
-     * Updates a product
-     */
-    update(technologyId: string, productId: string, product: Partial<Omit<Product, "id" | "createdAt" | "brandId" | "technologyId">>): Promise<Product | null>;
-    /**
-     * Soft deletes a product
-     */
-    delete(technologyId: string, productId: string): Promise<void>;
-    /**
-     * Gets a product by ID
-     */
-    getById(technologyId: string, productId: string): Promise<Product | null>;
+declare class InvalidRequirementDataError extends RequirementError {
+    constructor(message: string);
+}
+declare class InvalidTimeframeError extends RequirementError {
+    constructor(message: string);
 }
-
 /**
- * Service for managing documentation templates in the backoffice
+ * Errors related to relationships between entities
  */
-declare class DocumentationTemplateService {
-    private apiService;
-    /**
-     * Constructor for DocumentationTemplateService
-     * @param db - Firestore instance
-     * @param auth - Firebase Auth instance
-     * @param app - Firebase App instance
-     */
-    constructor(db: Firestore, auth: Auth, app: FirebaseApp);
-    /**
-     * Create a new document template
-     * @param data - Template data
-     * @param userId - ID of the user creating the template
-     * @returns The created template
-     */
-    createTemplate(data: CreateDocumentTemplateData, userId: string): Promise<DocumentTemplate>;
-    /**
-     * Get a document template by ID
-     * @param templateId - ID of the template to retrieve
-     * @param version - Optional version number to retrieve (defaults to latest version)
-     * @returns The template or null if not found
-     */
-    getTemplateById(templateId: string, version?: number): Promise<DocumentTemplate | null>;
-    /**
-     * Update an existing document template
-     * @param templateId - ID of the template to update
-     * @param data - Updated template data
-     * @returns The updated template
-     */
-    updateTemplate(templateId: string, data: UpdateDocumentTemplateData): Promise<DocumentTemplate>;
-    /**
-     * Delete a document template
-     * @param templateId - ID of the template to delete
-     */
-    deleteTemplate(templateId: string): Promise<void>;
-    /**
-     * Get all active templates
-     * @param pageSize - Number of templates to retrieve
-     * @param lastDoc - Last document from previous page for pagination
-     * @returns Array of templates and the last document for pagination
-     */
-    getActiveTemplates(pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
-        templates: DocumentTemplate[];
-        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-    }>;
-    /**
-     * Get templates by tags
-     * @param tags - Tags to filter by
-     * @param pageSize - Number of templates to retrieve
-     * @param lastDoc - Last document from previous page for pagination
-     * @returns Array of templates and the last document for pagination
-     */
-    getTemplatesByTags(tags: string[], pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
-        templates: DocumentTemplate[];
-        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-    }>;
-    /**
-     * Get templates created by a specific user
-     * @param userId - ID of the user who created the templates
-     * @param pageSize - Number of templates to retrieve
-     * @param lastDoc - Last document from previous page for pagination
-     * @returns Array of templates and the last document for pagination
-     */
-    getTemplatesByCreator(userId: string, pageSize?: number, lastDoc?: QueryDocumentSnapshot<DocumentTemplate>): Promise<{
-        templates: DocumentTemplate[];
-        lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
-    }>;
-    /**
-     * Get a specific version of a template
-     * @param templateId - ID of the template
-     * @param versionNumber - Version number to retrieve
-     * @returns The template version or null if not found
-     */
-    getTemplateVersion(templateId: string, versionNumber: number): Promise<DocumentTemplate | null>;
-    /**
-     * Get all versions of a template
-     * @param templateId - ID of the template
-     * @returns Array of template versions
-     */
-    getTemplateVersions(templateId: string): Promise<DocumentTemplate[]>;
+declare class RelationshipError extends BackofficeError {
+    constructor(message: string);
+}
+declare class InvalidHierarchyError extends RelationshipError {
+    constructor(message: string);
+}
+declare class CircularReferenceError extends RelationshipError {
+    constructor(message: string);
+}
+declare class BlockingConditionError extends BackofficeError {
+    constructor(message: string);
+}
+declare class InvalidBlockingConditionError extends BlockingConditionError {
+    constructor(condition: string);
+}
+declare class ContraindicationError extends BackofficeError {
+    constructor(message: string);
+}
+declare class InvalidContraindicationError extends ContraindicationError {
+    constructor(contraindication: string);
+}
+declare class TreatmentBenefitError extends BackofficeError {
+    constructor(message: string);
+}
+declare class InvalidTreatmentBenefitError extends TreatmentBenefitError {
+    constructor(benefit: string);
 }
 
 export { BackofficeError, BlockingCondition, BlockingConditionError, type Brand, BrandService, type Category, CategoryError, CategoryNotFoundError, CategoryService, CertificationLevel, type CertificationRequirement, CertificationSpecialty, CircularReferenceError, Contraindication, ContraindicationError, type CreateDocumentTemplateData, DEFAULT_CERTIFICATION_REQUIREMENT, type DocumentElement, DocumentElementType, type DocumentTemplate, DocumentationTemplateService, DynamicVariable, HeadingLevel, InvalidBlockingConditionError, InvalidCategoryDataError, InvalidContraindicationError, InvalidHierarchyError, InvalidRequirementDataError, InvalidSubcategoryDataError, InvalidTechnologyDataError, InvalidTimeframeError, InvalidTreatmentBenefitError, ListType, ProcedureFamily, type Product, ProductService, RelationshipError, type Requirement, RequirementError, type RequirementImportance, RequirementNotFoundError, RequirementService, RequirementType, type Subcategory, SubcategoryError, SubcategoryNotFoundError, SubcategoryService, type Technology, TechnologyError, TechnologyNotFoundError, type TechnologyRequirements, TechnologyService, type TimeFrame, TimeUnit, TreatmentBenefit, TreatmentBenefitError, type UpdateDocumentTemplateData, blockingConditionSchema, categorySchema, categoryUpdateSchema, certificationLevelSchema, certificationRequirementSchema, certificationSpecialtySchema, contraindicationSchema, createDocumentTemplateSchema, documentElementSchema, documentElementWithoutIdSchema, documentTemplateSchema, procedureFamilySchema, requirementSchema, requirementTypeSchema, requirementUpdateSchema, subcategorySchema, subcategoryUpdateSchema, technologyRequirementsSchema, technologySchema, technologyUpdateSchema, timeUnitSchema, timeframeSchema, treatmentBenefitSchema, updateDocumentTemplateSchema };