@blackcode_sa/metaestetics-api 1.6.13 → 1.6.15

package/dist/admin/index.d.mts

@@ -1,4 +1,4 @@
-import { Timestamp } from 'firebase/firestore';
+import { Timestamp, FieldValue } from 'firebase/firestore';
 import * as admin from 'firebase-admin';
 import { Timestamp as Timestamp$1 } from 'firebase-admin/firestore';
 
@@ -1505,6 +1505,88 @@ interface Appointment {
     /** NEW: Flag for soft deletion or archiving */
     isArchived?: boolean;
 }
+/**
+ * Data needed to create a new Appointment
+ */
+interface CreateAppointmentData {
+    clinicBranchId: string;
+    practitionerId: string;
+    patientId: string;
+    procedureId: string;
+    appointmentStartTime: Timestamp;
+    appointmentEndTime: Timestamp;
+    cost: number;
+    currency: Currency;
+    patientNotes?: string | null;
+    initialStatus: AppointmentStatus;
+    initialPaymentStatus?: PaymentStatus;
+}
+/**
+ * Data needed to create a new Appointment via CreateAppointmentHttp method
+ */
+interface CreateAppointmentHttpData {
+    patientId: string;
+    procedureId: string;
+    appointmentStartTime: Timestamp;
+    appointmentEndTime: Timestamp;
+    patientNotes?: string | null;
+}
+/**
+ * Data allowed for updating an Appointment
+ */
+interface UpdateAppointmentData {
+    status?: AppointmentStatus;
+    confirmationTime?: Timestamp | FieldValue | null;
+    cancellationTime?: Timestamp | FieldValue | null;
+    rescheduleTime?: Timestamp | FieldValue | null;
+    procedureActualStartTime?: Timestamp | FieldValue | null;
+    actualDurationMinutes?: number;
+    cancellationReason?: string | null;
+    canceledBy?: "patient" | "clinic" | "practitioner" | "system";
+    internalNotes?: string | null;
+    patientNotes?: string | FieldValue | null;
+    paymentStatus?: PaymentStatus;
+    paymentTransactionId?: string | FieldValue | null;
+    completedPreRequirements?: string[] | FieldValue;
+    completedPostRequirements?: string[] | FieldValue;
+    appointmentStartTime?: Timestamp;
+    appointmentEndTime?: Timestamp;
+    calendarEventId?: string;
+    cost?: number;
+    clinicBranchId?: string;
+    practitionerId?: string;
+    /** NEW: For updating linked forms - typically managed by dedicated methods */
+    linkedFormIds?: string[] | FieldValue;
+    linkedForms?: LinkedFormInfo[] | FieldValue;
+    /** NEW: For updating media items - typically managed by dedicated methods */
+    media?: AppointmentMediaItem[] | FieldValue;
+    /** NEW: For adding/updating review information */
+    reviewInfo?: PatientReviewInfo | FieldValue | null;
+    /** NEW: For setting practitioner finalization details */
+    finalizedDetails?: {
+        by: string;
+        at: Timestamp;
+        notes?: string;
+    } | FieldValue;
+    /** NEW: For archiving/unarchiving */
+    isArchived?: boolean;
+    updatedAt?: FieldValue;
+}
+/**
+ * Parameters for searching appointments
+ */
+interface SearchAppointmentsParams {
+    patientId?: string;
+    practitionerId?: string;
+    clinicBranchId?: string;
+    startDate?: Date;
+    endDate?: Date;
+    status?: AppointmentStatus | AppointmentStatus[];
+    limit?: number;
+    startAfter?: any;
+}
+/** Firestore collection name */
+declare const APPOINTMENTS_COLLECTION = "appointments";
 
 declare class NotificationsAdmin {
     private expo;
@@ -2266,4 +2348,263 @@ interface TimeInterval {
     end: Timestamp;
 }
 
-export { type Appointment, AppointmentAggregationService, type AppointmentReminderNotification, AppointmentStatus, type AvailableSlot, BaseMailingService, type BaseNotification, BookingAdmin, type BookingAvailabilityRequest, type BookingAvailabilityResponse, type Clinic, ClinicAggregationService, type ClinicInfo, type ClinicLocation, type DoctorInfo, NOTIFICATIONS_COLLECTION, type Notification, NotificationStatus, NotificationType, NotificationsAdmin, PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME, type PatientProfile as Patient, PatientAggregationService, PatientInstructionStatus, type PatientRequirementInstance, type PatientRequirementInstruction, PatientRequirementOverallStatus, PatientRequirementsAdminService, type PostRequirementNotification, type Practitioner, PractitionerAggregationService, PractitionerInviteMailingService, type PractitionerToken, PractitionerTokenStatus, type PreRequirementNotification, type Procedure, ProcedureAggregationService, type ProcedureSummaryInfo, type TimeInterval, UserRole };
+/**
+ * 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;
+}
+
+/**
+ * @class CalendarAdminService
+ * @description Handles administrative tasks for calendar events linked to appointments,
+ * such as status updates, time changes, or deletions, subsequent to their initial creation.
+ */
+declare class CalendarAdminService {
+    private db;
+    constructor(firestore?: admin.firestore.Firestore);
+    /**
+     * Updates the status of all three calendar events (practitioner, patient, clinic)
+     * associated with a given appointment.
+     *
+     * @param appointment - The appointment object containing references to its calendar events.
+     * @param newStatus - The new CalendarEventStatus to set.
+     * @returns {Promise<void>} A promise that resolves when all updates are attempted.
+     */
+    updateAppointmentCalendarEventsStatus(appointment: Appointment, newStatus: CalendarEventStatus): Promise<void>;
+    /**
+     * Updates the eventTime (start and end) of all three calendar events
+     * associated with a given appointment.
+     *
+     * @param appointment - The appointment object.
+     * @param newEventTime - The new CalendarEventTime object (using FirebaseClientTimestamp).
+     * @returns {Promise<void>} A promise that resolves when all updates are attempted.
+     */
+    updateAppointmentCalendarEventsTime(appointment: Appointment, newEventTime: CalendarEventTime): Promise<void>;
+    /**
+     * Deletes all three calendar events associated with a given appointment.
+     * Note: This is a hard delete. Consider marking as CANCELLED instead if soft delete is preferred.
+     *
+     * @param appointment - The appointment object.
+     * @returns {Promise<void>} A promise that resolves when all deletions are attempted.
+     */
+    deleteAppointmentCalendarEvents(appointment: Appointment): Promise<void>;
+}
+
+interface InitializeAppointmentFormsResult {
+    initializedFormsInfo: LinkedFormInfo[];
+    pendingUserFormsIds: string[];
+    allLinkedTemplateIds: string[];
+}
+declare class DocumentManagerAdminService {
+    private db;
+    constructor(firestore: admin.firestore.Firestore);
+    /**
+     * Adds operations to a Firestore batch to initialize all linked forms for a new appointment
+     * and returns an array of LinkedFormInfo objects, pendingUserFormsIds, and allLinkedTemplateIds.
+     *
+     * @param dbBatch - The Firestore batch to add operations to.
+     * @param appointmentId - The ID of the newly created appointment.
+     * @param procedureIdForForms - The ID of the procedure associated with this appointment.
+     * @param procedureTemplates - Array of document templates linked to the procedure.
+     * @param patientId - ID of the patient.
+     * @param practitionerId - ID of the practitioner associated with the procedure.
+     * @param clinicId - ID of the clinic where the procedure is performed.
+     * @param nowMillis - Current timestamp in milliseconds for createdAt/updatedAt.
+     * @returns An object containing initializedFormsInfo, pendingUserFormsIds, and allLinkedTemplateIds.
+     */
+    batchInitializeAppointmentForms(dbBatch: admin.firestore.WriteBatch, appointmentId: string, procedureIdForForms: string, procedureTemplates: DocumentTemplate[], patientId: string, practitionerId: string, clinicId: string, nowMillis: number): InitializeAppointmentFormsResult;
+}
+
+/**
+ * Cloud Functions-compatible logger with fallback for other environments
+ *
+ * This logger automatically detects if it's running in a Cloud Functions environment
+ * and uses the appropriate logging method. It falls back to console methods in other environments.
+ */
+/**
+ * Logger class that uses Firebase Functions logger when available
+ * with fallback to console methods when not in a Cloud Functions environment
+ */
+declare class Logger {
+    /**
+     * Log an error message
+     * @param message Message to log
+     * @param data Optional data to include
+     */
+    static error(message: string, data?: any): void;
+    /**
+     * Log a warning message
+     * @param message Message to log
+     * @param data Optional data to include
+     */
+    static warn(message: string, data?: any): void;
+    /**
+     * Log an info message
+     * @param message Message to log
+     * @param data Optional data to include
+     */
+    static info(message: string, data?: any): void;
+    /**
+     * Log a debug message
+     * @param message Message to log
+     * @param data Optional data to include
+     */
+    static debug(message: string, data?: any): void;
+}
+
+interface AppointmentEmailDataBase {
+    appointment: Appointment;
+    options?: {
+        customSubject?: string;
+        fromAddress?: string;
+        mailgunDomain?: string;
+    };
+}
+interface AppointmentConfirmationEmailData extends AppointmentEmailDataBase {
+    recipientProfile: PatientProfileInfo | PractitionerProfileInfo;
+    recipientRole: "patient" | "practitioner";
+}
+interface AppointmentRequestedEmailData extends AppointmentEmailDataBase {
+    clinicProfile: ClinicInfo;
+}
+interface AppointmentCancellationEmailData extends AppointmentEmailDataBase {
+    recipientProfile: PatientProfileInfo | PractitionerProfileInfo;
+    recipientRole: "patient" | "practitioner";
+    cancellationReason?: string;
+}
+interface AppointmentRescheduledProposalEmailData extends AppointmentEmailDataBase {
+    patientProfile: PatientProfileInfo;
+    previousStartTime: admin.firestore.Timestamp;
+    previousEndTime: admin.firestore.Timestamp;
+}
+interface ReviewRequestEmailData extends AppointmentEmailDataBase {
+    patientProfile: PatientProfileInfo;
+    reviewLink: string;
+}
+interface ReviewAddedEmailData extends AppointmentEmailDataBase {
+    recipientProfile: PractitionerProfileInfo | ClinicInfo;
+    recipientRole: "practitioner" | "clinic";
+    reviewerName: string;
+    reviewRating: number;
+    reviewComment?: string;
+}
+/**
+ * Service for sending appointment-related emails.
+ */
+declare class AppointmentMailingService extends BaseMailingService {
+    private readonly DEFAULT_MAILGUN_DOMAIN;
+    constructor(firestore: admin.firestore.Firestore, mailgunClient: NewMailgunClient$1);
+    sendAppointmentConfirmedEmail(data: AppointmentConfirmationEmailData): Promise<any>;
+    sendAppointmentRequestedEmailToClinic(data: AppointmentRequestedEmailData): Promise<any>;
+    sendAppointmentCancelledEmail(data: AppointmentCancellationEmailData): Promise<any>;
+    sendAppointmentRescheduledProposalEmail(data: AppointmentRescheduledProposalEmailData): Promise<any>;
+    sendReviewRequestEmail(data: ReviewRequestEmailData): Promise<any>;
+    sendReviewAddedEmail(data: ReviewAddedEmailData): Promise<any>;
+}
+
+export { APPOINTMENTS_COLLECTION, type Appointment, AppointmentAggregationService, type AppointmentCancellationEmailData, type AppointmentConfirmationEmailData, type AppointmentEmailDataBase, AppointmentMailingService, type AppointmentMediaItem, type AppointmentReminderNotification, type AppointmentRequestedEmailData, type AppointmentRescheduledProposalEmailData, AppointmentStatus, type AvailableSlot, BaseMailingService, type BaseNotification, BookingAdmin, BookingAvailabilityCalculator, type BookingAvailabilityRequest, type BookingAvailabilityResponse, CalendarAdminService, type Clinic, ClinicAggregationService, type ClinicInfo, type ClinicLocation, type CreateAppointmentData, type CreateAppointmentHttpData, type DoctorInfo, DocumentManagerAdminService, type InitializeAppointmentFormsResult, type LinkedFormInfo, Logger, MediaType, NOTIFICATIONS_COLLECTION, type Notification, NotificationStatus, NotificationType, NotificationsAdmin, type OrchestrateAppointmentCreationData, PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME, type PatientProfile as Patient, PatientAggregationService, PatientInstructionStatus, type PatientRequirementInstance, type PatientRequirementInstruction, PatientRequirementOverallStatus, PatientRequirementsAdminService, type PatientReviewInfo, PaymentStatus, type PostRequirementNotification, type Practitioner, PractitionerAggregationService, PractitionerInviteMailingService, type PractitionerToken, PractitionerTokenStatus, type PreRequirementNotification, type Procedure, ProcedureAggregationService, type ProcedureExtendedInfo, type ProcedureSummaryInfo, type ReviewAddedEmailData, type ReviewRequestEmailData, type SearchAppointmentsParams, type TimeInterval, type UpdateAppointmentData, UserRole };