@blackcode_sa/metaestetics-api 1.5.32 → 1.5.33

package/dist/admin/index.d.mts

@@ -1,5 +1,6 @@
 import { Timestamp } from 'firebase/firestore';
 import * as admin from 'firebase-admin';
+import { Timestamp as Timestamp$1 } from 'firebase-admin/firestore';
 import * as mailgun from 'mailgun-js';
 
 /**
@@ -607,6 +608,8 @@ interface ProcedureSummaryInfo {
     categoryName: string;
     subcategoryName: string;
     technologyName: string;
+    brandName?: string;
+    productName?: string;
     price: number;
     pricingMeasure: PricingMeasure;
     currency: Currency;
@@ -736,6 +739,17 @@ interface PractitionerToken {
     usedAt?: Timestamp;
 }
 
+/**
+ * Enumeracija za pol pacijenta
+ */
+declare enum Gender {
+    MALE = "male",
+    FEMALE = "female",
+    TRANSGENDER_MALE = "transgender_male",
+    TRANSGENDER_FEMALE = "transgender_female",
+    PREFER_NOT_TO_SAY = "prefer_not_to_say",
+    OTHER = "other"
+}
 /**
  * Interfejs za gamifikaciju
  */
@@ -798,6 +812,28 @@ interface ClinicInfo {
     location: ClinicLocation;
     contactInfo: ClinicContactInfo;
 }
+/**
+ * Interface for practitioner profile information
+ */
+interface PractitionerProfileInfo {
+    id: string;
+    practitionerPhoto: string | null;
+    name: string;
+    email: string;
+    phone: string | null;
+    certification: PractitionerCertification;
+}
+/**
+ * Interface for patient profile information
+ */
+interface PatientProfileInfo {
+    id: string;
+    fullName: string;
+    email: string;
+    phone: string | null;
+    dateOfBirth: Timestamp$1;
+    gender: Gender;
+}
 
 /**
  * Enum for all possible clinic tags
@@ -978,6 +1014,96 @@ interface Clinic {
     logo?: string;
 }
 
+/**
+ * Enum for synced calendar provider
+ */
+declare enum SyncedCalendarProvider {
+    GOOGLE = "google",
+    OUTLOOK = "outlook",
+    APPLE = "apple"
+}
+
+/**
+ * Enum for calendar event status
+ */
+declare enum CalendarEventStatus {
+    PENDING = "pending",// When event is created, but not confirmed
+    CONFIRMED = "confirmed",// When event is confirmed and ready to be used
+    REJECTED = "rejected",// When event is rejected by the clinic administrator or patient
+    CANCELED = "canceled",// When event is canceled by the patient
+    RESCHEDULED = "rescheduled",// When event is rescheduled by the clinic administrator
+    COMPLETED = "completed"
+}
+/**
+ * Enum for calendar event sync status
+ */
+declare enum CalendarSyncStatus {
+    INTERNAL = "internal",
+    EXTERNAL = "external"
+}
+/**
+ * Enum for calendar event types
+ */
+declare enum CalendarEventType {
+    APPOINTMENT = "appointment",
+    BLOCKING = "blocking",
+    BREAK = "break",
+    FREE_DAY = "free_day",
+    OTHER = "other"
+}
+/**
+ * Interface for calendar event time
+ */
+interface CalendarEventTime {
+    start: Timestamp;
+    end: Timestamp;
+}
+interface ProcedureInfo {
+    name: string;
+    description: string;
+    duration: number;
+    price: number;
+    currency: Currency;
+}
+interface ProcedureCategorization {
+    procedureFamily: ProcedureFamily;
+    procedureCategory: Category;
+    procedureSubcategory: Subcategory;
+    procedureTechnology: Technology;
+    procedureProduct: Product;
+}
+interface SyncedCalendarEvent {
+    eventId: string;
+    syncedCalendarProvider: SyncedCalendarProvider;
+    syncedAt: Timestamp;
+}
+/**
+ * Interface for calendar event
+ */
+interface CalendarEvent {
+    id: string;
+    clinicBranchId?: string | null;
+    clinicBranchInfo?: ClinicInfo | null;
+    practitionerProfileId?: string | null;
+    practitionerProfileInfo?: PractitionerProfileInfo | null;
+    patientProfileId?: string | null;
+    patientProfileInfo?: PatientProfileInfo | null;
+    procedureId?: string | null;
+    procedureInfo?: ProcedureInfo | null;
+    procedureCategorization?: ProcedureCategorization | null;
+    appointmentId?: string | null;
+    syncedCalendarEventId?: SyncedCalendarEvent[] | null;
+    eventName: string;
+    eventLocation?: ClinicLocation;
+    eventTime: CalendarEventTime;
+    description?: string;
+    status: CalendarEventStatus;
+    syncStatus: CalendarSyncStatus;
+    eventType: CalendarEventType;
+    createdAt: Timestamp;
+    updatedAt: Timestamp;
+}
+
 declare enum UserRole {
     PATIENT = "patient",
     PRACTITIONER = "practitioner",
@@ -1475,4 +1601,214 @@ declare class PractitionerInviteMailingService extends BaseMailingService {
     handleTokenCreationEvent(tokenData: PractitionerToken, fromAddress: string): Promise<void>;
 }
 
-export { type AppointmentNotification, type AppointmentReminderNotification, BaseMailingService, type BaseNotification, type Clinic, ClinicAggregationService, type ClinicInfo, type ClinicLocation, type DoctorInfo, NOTIFICATIONS_COLLECTION, type Notification, NotificationStatus, NotificationType, NotificationsAdmin, type PatientProfile as Patient, PatientAggregationService, type PostRequirementNotification, type Practitioner, PractitionerAggregationService, PractitionerInviteMailingService, type PractitionerToken, PractitionerTokenStatus, type PreRequirementNotification, type Procedure, ProcedureAggregationService, type ProcedureSummaryInfo, UserRole };
+/**
+ * Request parameters for calculating available booking slots
+ */
+interface BookingAvailabilityRequest {
+    /** The clinic for which to calculate booking slots */
+    clinic: Clinic;
+    /** The practitioner for which to calculate booking slots */
+    practitioner: Practitioner;
+    /** The procedure for which to calculate booking slots */
+    procedure: Procedure;
+    /** The timeframe for which to calculate booking slots */
+    timeframe: {
+        start: Timestamp;
+        end: Timestamp;
+    };
+    /** Calendar events for the clinic during the specified timeframe */
+    clinicCalendarEvents: CalendarEvent[];
+    /** Calendar events for the practitioner during the specified timeframe */
+    practitionerCalendarEvents: CalendarEvent[];
+}
+/**
+ * Represents a single available booking slot
+ */
+interface AvailableSlot {
+    /** Start time of the available booking slot */
+    start: Timestamp;
+}
+/**
+ * Response with available booking slots
+ */
+interface BookingAvailabilityResponse {
+    /** Array of available booking slots */
+    availableSlots: AvailableSlot[];
+}
+/**
+ * Represents a time interval with start and end times
+ * Used internally for availability calculations
+ */
+interface TimeInterval {
+    start: Timestamp;
+    end: Timestamp;
+}
+
+/**
+ * Calculator for determining available booking slots
+ * This class handles the complex logic of determining when appointments can be scheduled
+ * based on clinic working hours, practitioner availability, and existing calendar events.
+ */
+declare class BookingAvailabilityCalculator {
+    /** Default scheduling interval in minutes if not specified by the clinic */
+    private static readonly DEFAULT_INTERVAL_MINUTES;
+    /**
+     * Calculate available booking slots based on the provided data
+     *
+     * @param request - The request containing all necessary data for calculation
+     * @returns Response with available booking slots
+     */
+    static calculateSlots(request: BookingAvailabilityRequest): BookingAvailabilityResponse;
+    /**
+     * Apply clinic working hours to available intervals
+     *
+     * @param intervals - Current available intervals
+     * @param workingHours - Clinic working hours
+     * @param timeframe - Overall timeframe being considered
+     * @returns Intervals filtered by clinic working hours
+     */
+    private static applyClinicWorkingHours;
+    /**
+     * Create time intervals for working hours across multiple days
+     *
+     * @param workingHours - Working hours definition
+     * @param startDate - Start date of the overall timeframe
+     * @param endDate - End date of the overall timeframe
+     * @returns Array of time intervals representing working hours
+     */
+    private static createWorkingHoursIntervals;
+    /**
+     * Subtract blocking events from available intervals
+     *
+     * @param intervals - Current available intervals
+     * @param events - Calendar events to subtract
+     * @returns Available intervals after removing blocking events
+     */
+    private static subtractBlockingEvents;
+    /**
+     * Apply practitioner's specific working hours for the given clinic
+     *
+     * @param intervals - Current available intervals
+     * @param practitioner - Practitioner object
+     * @param clinicId - ID of the clinic
+     * @param timeframe - Overall timeframe being considered
+     * @returns Intervals filtered by practitioner's working hours
+     */
+    private static applyPractitionerWorkingHours;
+    /**
+     * Create time intervals for practitioner's working hours across multiple days
+     *
+     * @param workingHours - Practitioner's working hours definition
+     * @param startDate - Start date of the overall timeframe
+     * @param endDate - End date of the overall timeframe
+     * @returns Array of time intervals representing practitioner's working hours
+     */
+    private static createPractitionerWorkingHoursIntervals;
+    /**
+     * Subtract practitioner's busy times from available intervals
+     *
+     * @param intervals - Current available intervals
+     * @param events - Practitioner's calendar events
+     * @returns Available intervals after removing busy times
+     */
+    private static subtractPractitionerBusyTimes;
+    /**
+     * Generate available booking slots based on the final available intervals
+     *
+     * @param intervals - Final available intervals
+     * @param intervalMinutes - Scheduling interval in minutes
+     * @param durationMinutes - Procedure duration in minutes
+     * @returns Array of available booking slots
+     */
+    private static generateAvailableSlots;
+    /**
+     * Check if a time slot is fully available within the given intervals
+     *
+     * @param slotStart - Start time of the slot
+     * @param slotEnd - End time of the slot
+     * @param intervals - Available intervals
+     * @returns True if the slot is fully contained within an available interval
+     */
+    private static isSlotFullyAvailable;
+    /**
+     * Intersect two sets of time intervals
+     *
+     * @param intervalsA - First set of intervals
+     * @param intervalsB - Second set of intervals
+     * @returns Intersection of the two sets of intervals
+     */
+    private static intersectIntervals;
+    /**
+     * Subtract one interval from another, potentially resulting in 0, 1, or 2 intervals
+     *
+     * @param interval - Interval to subtract from
+     * @param subtrahend - Interval to subtract
+     * @returns Array of remaining intervals after subtraction
+     */
+    private static subtractInterval;
+    /**
+     * Merge overlapping intervals to simplify the result
+     *
+     * @param intervals - Intervals to merge
+     * @returns Merged intervals
+     */
+    private static mergeOverlappingIntervals;
+}
+
+/**
+ * Admin service for handling booking-related operations.
+ * This is the cloud-based implementation that will be used in Cloud Functions.
+ */
+declare class BookingAdmin {
+    private db;
+    /**
+     * Creates a new BookingAdmin instance
+     * @param firestore - Firestore instance provided by the caller
+     */
+    constructor(firestore?: admin.firestore.Firestore);
+    /**
+     * Gets available booking time slots for a specific clinic, practitioner, and procedure
+     *
+     * @param clinicId - ID of the clinic
+     * @param practitionerId - ID of the practitioner
+     * @param procedureId - ID of the procedure
+     * @param timeframe - Time range to check for availability
+     * @returns Promise resolving to an array of available booking slots
+     */
+    getAvailableBookingSlots(clinicId: string, practitionerId: string, procedureId: string, timeframe: {
+        start: Date | admin.firestore.Timestamp;
+        end: Date | admin.firestore.Timestamp;
+    }): Promise<{
+        availableSlots: {
+            start: admin.firestore.Timestamp;
+        }[];
+    }>;
+    /**
+     * Converts an admin Firestore Timestamp to a client Firestore Timestamp
+     */
+    private adminTimestampToClientTimestamp;
+    /**
+     * Converts timestamps in calendar events from admin Firestore Timestamps to client Firestore Timestamps
+     */
+    private convertEventsTimestamps;
+    /**
+     * Fetches clinic calendar events for a specific time range
+     *
+     * @param clinicId - ID of the clinic
+     * @param start - Start time of the range
+     * @param end - End time of the range
+     * @returns Promise resolving to an array of calendar events
+     */
+    private getClinicCalendarEvents;
+    /**
+     * Fetches practitioner calendar events for a specific time range
+     *
+     * @param practitionerId - ID of the practitioner
+     * @param start - Start time of the range
+     * @param end - End time of the range
+     * @returns Promise resolving to an array of calendar events
+     */
+    private getPractitionerCalendarEvents;
+}
+
+export { type AppointmentNotification, type AppointmentReminderNotification, type AvailableSlot, BaseMailingService, type BaseNotification, BookingAdmin, BookingAvailabilityCalculator, type BookingAvailabilityRequest, type BookingAvailabilityResponse, type Clinic, ClinicAggregationService, type ClinicInfo, type ClinicLocation, type DoctorInfo, NOTIFICATIONS_COLLECTION, type Notification, NotificationStatus, NotificationType, NotificationsAdmin, type PatientProfile as Patient, PatientAggregationService, type PostRequirementNotification, type Practitioner, PractitionerAggregationService, PractitionerInviteMailingService, type PractitionerToken, PractitionerTokenStatus, type PreRequirementNotification, type Procedure, ProcedureAggregationService, type ProcedureSummaryInfo, type TimeInterval, UserRole };