@blackcode_sa/metaestetics-api 1.7.38 → 1.7.40

package/dist/index.js

@@ -244,7 +244,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/validations/appointment.schema.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/types/appointment/index.ts
 var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
@@ -512,140 +512,197 @@ var updateFilledDocumentDataSchema = import_zod.z.object({
   status: filledDocumentStatusSchema.optional()
 });
 
+// src/backoffice/types/static/pricing.types.ts
+var PricingMeasure = /* @__PURE__ */ ((PricingMeasure3) => {
+  PricingMeasure3["PER_ML"] = "per_ml";
+  PricingMeasure3["PER_ZONE"] = "per_zone";
+  PricingMeasure3["PER_AREA"] = "per_area";
+  PricingMeasure3["PER_SESSION"] = "per_session";
+  PricingMeasure3["PER_TREATMENT"] = "per_treatment";
+  PricingMeasure3["PER_PACKAGE"] = "per_package";
+  return PricingMeasure3;
+})(PricingMeasure || {});
+var Currency = /* @__PURE__ */ ((Currency2) => {
+  Currency2["EUR"] = "EUR";
+  Currency2["USD"] = "USD";
+  Currency2["GBP"] = "GBP";
+  Currency2["CHF"] = "CHF";
+  Currency2["AUD"] = "AUD";
+  return Currency2;
+})(Currency || {});
+
+// src/validations/media.schema.ts
+var import_zod2 = require("zod");
+var mediaResourceSchema = import_zod2.z.union([
+  import_zod2.z.string().url(),
+  import_zod2.z.instanceof(File),
+  import_zod2.z.instanceof(Blob)
+]);
+
 // src/validations/appointment.schema.ts
 var MIN_STRING_LENGTH = 1;
 var MAX_STRING_LENGTH = 1024;
 var MAX_STRING_LENGTH_LONG = 4096;
 var MAX_ARRAY_LENGTH = 100;
-var appointmentStatusSchema = import_zod2.z.nativeEnum(AppointmentStatus);
-var paymentStatusSchema = import_zod2.z.nativeEnum(PaymentStatus);
-var mediaTypeSchema = import_zod2.z.nativeEnum(MediaType);
-var appointmentMediaItemSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(MIN_STRING_LENGTH, "Media item ID is required"),
+var appointmentStatusSchema = import_zod3.z.nativeEnum(AppointmentStatus);
+var paymentStatusSchema = import_zod3.z.nativeEnum(PaymentStatus);
+var mediaTypeSchema = import_zod3.z.nativeEnum(MediaType);
+var appointmentMediaItemSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(MIN_STRING_LENGTH, "Media item ID is required"),
   type: mediaTypeSchema,
-  url: import_zod2.z.string().url("Media URL must be a valid URL"),
-  fileName: import_zod2.z.string().optional(),
-  uploadedAt: import_zod2.z.any().refine(
+  url: import_zod3.z.string().url("Media URL must be a valid URL"),
+  fileName: import_zod3.z.string().optional(),
+  uploadedAt: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "uploadedAt must be a valid timestamp or Date object"
   ),
-  uploadedBy: import_zod2.z.string().min(MIN_STRING_LENGTH, "Uploaded by user ID is required"),
-  description: import_zod2.z.string().max(MAX_STRING_LENGTH, "Description too long").optional()
-});
-var procedureExtendedInfoSchema = import_zod2.z.object({
-  id: import_zod2.z.string().min(MIN_STRING_LENGTH),
-  name: import_zod2.z.string().min(MIN_STRING_LENGTH),
-  description: import_zod2.z.string(),
-  cost: import_zod2.z.number().min(0),
-  duration: import_zod2.z.number().min(0),
-  procedureFamily: import_zod2.z.any(),
-  procedureCategoryId: import_zod2.z.string(),
-  procedureCategoryName: import_zod2.z.string(),
-  procedureSubCategoryId: import_zod2.z.string(),
-  procedureSubCategoryName: import_zod2.z.string(),
-  procedureTechnologyId: import_zod2.z.string(),
-  procedureTechnologyName: import_zod2.z.string(),
-  procedureProductBrandId: import_zod2.z.string(),
-  procedureProductBrandName: import_zod2.z.string(),
-  procedureProductId: import_zod2.z.string(),
-  procedureProductName: import_zod2.z.string()
-});
-var linkedFormInfoSchema = import_zod2.z.object({
-  formId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Form ID is required"),
-  templateId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Template ID is required"),
-  templateVersion: import_zod2.z.number().int().positive("Template version must be a positive integer"),
-  title: import_zod2.z.string().min(MIN_STRING_LENGTH, "Form title is required"),
-  isUserForm: import_zod2.z.boolean(),
-  isRequired: import_zod2.z.boolean().optional(),
+  uploadedBy: import_zod3.z.string().min(MIN_STRING_LENGTH, "Uploaded by user ID is required"),
+  description: import_zod3.z.string().max(MAX_STRING_LENGTH, "Description too long").optional()
+});
+var procedureExtendedInfoSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(MIN_STRING_LENGTH),
+  name: import_zod3.z.string().min(MIN_STRING_LENGTH),
+  description: import_zod3.z.string(),
+  cost: import_zod3.z.number().min(0),
+  duration: import_zod3.z.number().min(0),
+  procedureFamily: import_zod3.z.any(),
+  procedureCategoryId: import_zod3.z.string(),
+  procedureCategoryName: import_zod3.z.string(),
+  procedureSubCategoryId: import_zod3.z.string(),
+  procedureSubCategoryName: import_zod3.z.string(),
+  procedureTechnologyId: import_zod3.z.string(),
+  procedureTechnologyName: import_zod3.z.string(),
+  procedureProductBrandId: import_zod3.z.string(),
+  procedureProductBrandName: import_zod3.z.string(),
+  procedureProductId: import_zod3.z.string(),
+  procedureProductName: import_zod3.z.string()
+});
+var linkedFormInfoSchema = import_zod3.z.object({
+  formId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Form ID is required"),
+  templateId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Template ID is required"),
+  templateVersion: import_zod3.z.number().int().positive("Template version must be a positive integer"),
+  title: import_zod3.z.string().min(MIN_STRING_LENGTH, "Form title is required"),
+  isUserForm: import_zod3.z.boolean(),
+  isRequired: import_zod3.z.boolean().optional(),
   status: filledDocumentStatusSchema,
-  path: import_zod2.z.string().min(MIN_STRING_LENGTH, "Form path is required"),
-  submittedAt: import_zod2.z.any().refine(
+  path: import_zod3.z.string().min(MIN_STRING_LENGTH, "Form path is required"),
+  submittedAt: import_zod3.z.any().refine(
     (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "submittedAt must be a valid timestamp or Date object"
   ).optional(),
-  completedAt: import_zod2.z.any().refine(
+  completedAt: import_zod3.z.any().refine(
     (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "completedAt must be a valid timestamp or Date object"
   ).optional()
 });
-var patientReviewInfoSchema = import_zod2.z.object({
-  reviewId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Review ID is required"),
-  rating: import_zod2.z.number().min(1).max(5, "Rating must be between 1 and 5"),
-  comment: import_zod2.z.string().max(MAX_STRING_LENGTH_LONG, "Comment too long").optional(),
-  reviewedAt: import_zod2.z.any().refine(
+var patientReviewInfoSchema = import_zod3.z.object({
+  reviewId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Review ID is required"),
+  rating: import_zod3.z.number().min(1).max(5, "Rating must be between 1 and 5"),
+  comment: import_zod3.z.string().max(MAX_STRING_LENGTH_LONG, "Comment too long").optional(),
+  reviewedAt: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "reviewedAt must be a valid timestamp or Date object"
   )
 });
-var finalizedDetailsSchema = import_zod2.z.object({
-  by: import_zod2.z.string().min(MIN_STRING_LENGTH, "Finalized by user ID is required"),
-  at: import_zod2.z.any().refine(
+var finalizedDetailsSchema = import_zod3.z.object({
+  by: import_zod3.z.string().min(MIN_STRING_LENGTH, "Finalized by user ID is required"),
+  at: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "Finalized at must be a valid timestamp or Date object"
   ),
-  notes: import_zod2.z.string().max(MAX_STRING_LENGTH_LONG, "Finalization notes too long").optional()
-});
-var createAppointmentSchema = import_zod2.z.object({
-  clinicBranchId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
-  practitionerId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Practitioner ID is required"),
-  patientId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Patient ID is required"),
-  procedureId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Procedure ID is required"),
-  appointmentStartTime: import_zod2.z.any().refine(
+  notes: import_zod3.z.string().max(MAX_STRING_LENGTH_LONG, "Finalization notes too long").optional()
+});
+var beforeAfterPerZoneSchema = import_zod3.z.object({
+  before: mediaResourceSchema.nullable(),
+  after: mediaResourceSchema.nullable(),
+  note: import_zod3.z.string().nullable()
+});
+var billingPerZoneSchema = import_zod3.z.object({
+  Product: import_zod3.z.string().min(MIN_STRING_LENGTH, "Product name is required"),
+  ProductId: import_zod3.z.string().nullable(),
+  Quantity: import_zod3.z.number().min(0, "Quantity must be non-negative"),
+  UnitOfMeasurement: import_zod3.z.nativeEnum(PricingMeasure),
+  UnitPrice: import_zod3.z.number().min(0, "Unit price must be non-negative"),
+  UnitCurency: import_zod3.z.nativeEnum(Currency),
+  Subtotal: import_zod3.z.number().min(0, "Subtotal must be non-negative"),
+  Note: import_zod3.z.string().nullable()
+});
+var finalBillingSchema = import_zod3.z.object({
+  subtotalAll: import_zod3.z.number().min(0, "Subtotal all must be non-negative"),
+  taxRate: import_zod3.z.number().min(0).max(1, "Tax rate must be between 0 and 1"),
+  taxPrice: import_zod3.z.number().min(0, "Tax price must be non-negative"),
+  finalPrice: import_zod3.z.number().min(0, "Final price must be non-negative"),
+  finalQuantity: import_zod3.z.number().min(0, "Final quantity must be non-negative"),
+  currency: import_zod3.z.nativeEnum(Currency),
+  unitOfMeasurement: import_zod3.z.nativeEnum(PricingMeasure)
+});
+var appointmentMetadataSchema = import_zod3.z.object({
+  selectedZones: import_zod3.z.array(import_zod3.z.string()).nullable(),
+  zonePhotos: import_zod3.z.record(import_zod3.z.string(), beforeAfterPerZoneSchema).nullable(),
+  zoneBilling: import_zod3.z.record(import_zod3.z.string(), billingPerZoneSchema).nullable(),
+  finalbilling: finalBillingSchema.nullable()
+});
+var createAppointmentSchema = import_zod3.z.object({
+  clinicBranchId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
+  practitionerId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Practitioner ID is required"),
+  patientId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Patient ID is required"),
+  procedureId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Procedure ID is required"),
+  appointmentStartTime: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "Appointment start time must be a valid timestamp or Date object"
   ),
-  appointmentEndTime: import_zod2.z.any().refine(
+  appointmentEndTime: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "Appointment end time must be a valid timestamp or Date object"
   ),
-  cost: import_zod2.z.number().min(0, "Cost must be a non-negative number"),
-  currency: import_zod2.z.string().min(1, "Currency is required"),
-  patientNotes: import_zod2.z.string().max(MAX_STRING_LENGTH, "Patient notes too long").nullable().optional(),
+  cost: import_zod3.z.number().min(0, "Cost must be a non-negative number"),
+  currency: import_zod3.z.string().min(1, "Currency is required"),
+  patientNotes: import_zod3.z.string().max(MAX_STRING_LENGTH, "Patient notes too long").nullable().optional(),
   initialStatus: appointmentStatusSchema,
   initialPaymentStatus: paymentStatusSchema.optional().default("unpaid" /* UNPAID */)
 }).refine((data) => data.appointmentEndTime > data.appointmentStartTime, {
   message: "Appointment end time must be after start time",
   path: ["appointmentEndTime"]
 });
-var updateAppointmentSchema = import_zod2.z.object({
+var updateAppointmentSchema = import_zod3.z.object({
   status: appointmentStatusSchema.optional(),
-  confirmationTime: import_zod2.z.any().optional().nullable(),
-  cancellationTime: import_zod2.z.any().optional().nullable(),
-  rescheduleTime: import_zod2.z.any().optional().nullable(),
-  procedureActualStartTime: import_zod2.z.any().optional().nullable(),
-  actualDurationMinutes: import_zod2.z.number().int().positive("Duration must be a positive integer").optional(),
-  cancellationReason: import_zod2.z.string().max(MAX_STRING_LENGTH, "Cancellation reason too long").nullable().optional(),
-  canceledBy: import_zod2.z.enum(["patient", "clinic", "practitioner", "system"]).optional(),
-  internalNotes: import_zod2.z.string().max(MAX_STRING_LENGTH_LONG, "Internal notes too long").nullable().optional(),
-  patientNotes: import_zod2.z.any().optional().nullable(),
+  confirmationTime: import_zod3.z.any().optional().nullable(),
+  cancellationTime: import_zod3.z.any().optional().nullable(),
+  rescheduleTime: import_zod3.z.any().optional().nullable(),
+  procedureActualStartTime: import_zod3.z.any().optional().nullable(),
+  actualDurationMinutes: import_zod3.z.number().int().positive("Duration must be a positive integer").optional(),
+  cancellationReason: import_zod3.z.string().max(MAX_STRING_LENGTH, "Cancellation reason too long").nullable().optional(),
+  canceledBy: import_zod3.z.enum(["patient", "clinic", "practitioner", "system"]).optional(),
+  internalNotes: import_zod3.z.string().max(MAX_STRING_LENGTH_LONG, "Internal notes too long").nullable().optional(),
+  patientNotes: import_zod3.z.any().optional().nullable(),
   paymentStatus: paymentStatusSchema.optional(),
-  paymentTransactionId: import_zod2.z.any().optional().nullable(),
-  completedPreRequirements: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
-  completedPostRequirements: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
-  linkedFormIds: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
-  pendingUserFormsIds: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.any()]).optional(),
-  appointmentStartTime: import_zod2.z.any().refine(
+  paymentTransactionId: import_zod3.z.any().optional().nullable(),
+  completedPreRequirements: import_zod3.z.union([import_zod3.z.array(import_zod3.z.string()), import_zod3.z.any()]).optional(),
+  completedPostRequirements: import_zod3.z.union([import_zod3.z.array(import_zod3.z.string()), import_zod3.z.any()]).optional(),
+  linkedFormIds: import_zod3.z.union([import_zod3.z.array(import_zod3.z.string()), import_zod3.z.any()]).optional(),
+  pendingUserFormsIds: import_zod3.z.union([import_zod3.z.array(import_zod3.z.string()), import_zod3.z.any()]).optional(),
+  appointmentStartTime: import_zod3.z.any().refine(
     (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "Appointment start time must be a valid timestamp or Date object"
   ).optional(),
-  appointmentEndTime: import_zod2.z.any().refine(
+  appointmentEndTime: import_zod3.z.any().refine(
     (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "Appointment end time must be a valid timestamp or Date object"
   ).optional(),
-  calendarEventId: import_zod2.z.string().min(MIN_STRING_LENGTH).optional(),
-  cost: import_zod2.z.number().min(0).optional(),
-  clinicBranchId: import_zod2.z.string().min(MIN_STRING_LENGTH).optional(),
-  practitionerId: import_zod2.z.string().min(MIN_STRING_LENGTH).optional(),
-  linkedForms: import_zod2.z.union([import_zod2.z.array(linkedFormInfoSchema).max(MAX_ARRAY_LENGTH), import_zod2.z.any()]).optional(),
-  media: import_zod2.z.union([
-    import_zod2.z.array(appointmentMediaItemSchema).max(MAX_ARRAY_LENGTH),
-    import_zod2.z.any()
+  calendarEventId: import_zod3.z.string().min(MIN_STRING_LENGTH).optional(),
+  cost: import_zod3.z.number().min(0).optional(),
+  clinicBranchId: import_zod3.z.string().min(MIN_STRING_LENGTH).optional(),
+  practitionerId: import_zod3.z.string().min(MIN_STRING_LENGTH).optional(),
+  linkedForms: import_zod3.z.union([import_zod3.z.array(linkedFormInfoSchema).max(MAX_ARRAY_LENGTH), import_zod3.z.any()]).optional(),
+  media: import_zod3.z.union([
+    import_zod3.z.array(appointmentMediaItemSchema).max(MAX_ARRAY_LENGTH),
+    import_zod3.z.any()
   ]).optional(),
-  reviewInfo: import_zod2.z.union([patientReviewInfoSchema.nullable(), import_zod2.z.any()]).optional(),
-  finalizedDetails: import_zod2.z.union([finalizedDetailsSchema.nullable(), import_zod2.z.any()]).optional(),
-  isArchived: import_zod2.z.boolean().optional(),
-  updatedAt: import_zod2.z.any().optional(),
-  metadata: import_zod2.z.any().optional()
+  reviewInfo: import_zod3.z.union([patientReviewInfoSchema.nullable(), import_zod3.z.any()]).optional(),
+  finalizedDetails: import_zod3.z.union([finalizedDetailsSchema.nullable(), import_zod3.z.any()]).optional(),
+  isArchived: import_zod3.z.boolean().optional(),
+  updatedAt: import_zod3.z.any().optional(),
+  metadata: appointmentMetadataSchema.optional()
 }).refine(
   (data) => {
     if (data.status === "canceled_clinic" /* CANCELED_CLINIC */ || data.status === "canceled_patient" /* CANCELED_PATIENT */ || data.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */) {
@@ -669,24 +726,24 @@ var updateAppointmentSchema = import_zod2.z.object({
     path: ["appointmentEndTime"]
   }
 );
-var searchAppointmentsSchema = import_zod2.z.object({
-  patientId: import_zod2.z.string().optional(),
-  practitionerId: import_zod2.z.string().optional(),
-  clinicBranchId: import_zod2.z.string().optional(),
-  startDate: import_zod2.z.any().refine(
+var searchAppointmentsSchema = import_zod3.z.object({
+  patientId: import_zod3.z.string().optional(),
+  practitionerId: import_zod3.z.string().optional(),
+  clinicBranchId: import_zod3.z.string().optional(),
+  startDate: import_zod3.z.any().refine(
     (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "Start date must be a valid timestamp or Date object"
   ).optional(),
-  endDate: import_zod2.z.any().refine(
+  endDate: import_zod3.z.any().refine(
     (val) => val === void 0 || val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "End date must be a valid timestamp or Date object"
   ).optional(),
-  status: import_zod2.z.union([
+  status: import_zod3.z.union([
     appointmentStatusSchema,
-    import_zod2.z.array(appointmentStatusSchema).nonempty()
+    import_zod3.z.array(appointmentStatusSchema).nonempty()
   ]).optional(),
-  limit: import_zod2.z.number().positive().int().optional().default(20),
-  startAfter: import_zod2.z.any().optional()
+  limit: import_zod3.z.number().positive().int().optional().default(20),
+  startAfter: import_zod3.z.any().optional()
 }).refine(
   (data) => {
     if (!data.startDate && !data.endDate && !data.status) {
@@ -710,13 +767,13 @@ var searchAppointmentsSchema = import_zod2.z.object({
     path: ["endDate"]
   }
 );
-var rescheduleAppointmentSchema = import_zod2.z.object({
-  appointmentId: import_zod2.z.string().min(MIN_STRING_LENGTH, "Appointment ID is required"),
-  newStartTime: import_zod2.z.any().refine(
+var rescheduleAppointmentSchema = import_zod3.z.object({
+  appointmentId: import_zod3.z.string().min(MIN_STRING_LENGTH, "Appointment ID is required"),
+  newStartTime: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "New start time must be a valid timestamp, Date object, number, or string"
   ),
-  newEndTime: import_zod2.z.any().refine(
+  newEndTime: import_zod3.z.any().refine(
     (val) => val instanceof Date || (val == null ? void 0 : val._seconds) !== void 0 || (val == null ? void 0 : val.seconds) !== void 0 || typeof val === "number" || typeof val === "string" || val && typeof val.toMillis === "function",
     "New end time must be a valid timestamp, Date object, number, or string"
   )
@@ -817,24 +874,24 @@ var USERS_COLLECTION = "users";
 var import_zod20 = require("zod");
 
 // src/validations/schemas.ts
-var import_zod3 = require("zod");
-var emailSchema = import_zod3.z.string().email("Invalid email format").min(5, "Email must be at least 5 characters").max(255, "Email must be less than 255 characters");
-var passwordSchema = import_zod3.z.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
+var import_zod4 = require("zod");
+var emailSchema = import_zod4.z.string().email("Invalid email format").min(5, "Email must be at least 5 characters").max(255, "Email must be less than 255 characters");
+var passwordSchema = import_zod4.z.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
   /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d\w\W]{8,}$/,
   "Password must contain at least one uppercase letter, one lowercase letter, and one number"
 );
-var userRoleSchema = import_zod3.z.nativeEnum(UserRole);
-var userRolesSchema = import_zod3.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = import_zod3.z.custom((data) => {
+var userRoleSchema = import_zod4.z.nativeEnum(UserRole);
+var userRolesSchema = import_zod4.z.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
+var timestampSchema = import_zod4.z.custom((data) => {
   if (data && typeof data === "object" && "isEqual" in data) {
     return true;
   }
   return data && typeof data === "object" && "toDate" in data && "seconds" in data && "nanoseconds" in data;
 }, "Must be a Timestamp object or serverTimestamp");
-var clinicAdminOptionsSchema = import_zod3.z.object({
-  isGroupOwner: import_zod3.z.boolean(),
-  groupToken: import_zod3.z.string().optional(),
-  groupId: import_zod3.z.string().optional()
+var clinicAdminOptionsSchema = import_zod4.z.object({
+  isGroupOwner: import_zod4.z.boolean(),
+  groupToken: import_zod4.z.string().optional(),
+  groupId: import_zod4.z.string().optional()
 }).refine(
   (data) => {
     if (!data.isGroupOwner && (!data.groupToken || !data.groupId)) {
@@ -849,20 +906,20 @@ var clinicAdminOptionsSchema = import_zod3.z.object({
     message: "Invalid clinic admin options configuration"
   }
 );
-var createUserOptionsSchema = import_zod3.z.object({
+var createUserOptionsSchema = import_zod4.z.object({
   clinicAdminData: clinicAdminOptionsSchema.optional()
 });
-var userSchema = import_zod3.z.object({
-  uid: import_zod3.z.string(),
-  email: import_zod3.z.string().email().nullable(),
-  roles: import_zod3.z.array(userRoleSchema),
-  isAnonymous: import_zod3.z.boolean(),
+var userSchema = import_zod4.z.object({
+  uid: import_zod4.z.string(),
+  email: import_zod4.z.string().email().nullable(),
+  roles: import_zod4.z.array(userRoleSchema),
+  isAnonymous: import_zod4.z.boolean(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema,
   lastLoginAt: timestampSchema,
-  patientProfile: import_zod3.z.string().optional(),
-  practitionerProfile: import_zod3.z.string().optional(),
-  adminProfile: import_zod3.z.string().optional()
+  patientProfile: import_zod4.z.string().optional(),
+  practitionerProfile: import_zod4.z.string().optional(),
+  adminProfile: import_zod4.z.string().optional()
 });
 
 // src/errors/auth.errors.ts
@@ -1546,14 +1603,6 @@ var Gender = /* @__PURE__ */ ((Gender2) => {
 var import_zod7 = require("zod");
 var import_firestore5 = require("firebase/firestore");
 
-// src/validations/media.schema.ts
-var import_zod4 = require("zod");
-var mediaResourceSchema = import_zod4.z.union([
-  import_zod4.z.string().url(),
-  import_zod4.z.instanceof(File),
-  import_zod4.z.instanceof(Blob)
-]);
-
 // src/validations/patient/medical-info.schema.ts
 var import_zod6 = require("zod");
 
@@ -3747,25 +3796,6 @@ var ProcedureFamily = /* @__PURE__ */ ((ProcedureFamily2) => {
   return ProcedureFamily2;
 })(ProcedureFamily || {});
 
-// src/backoffice/types/static/pricing.types.ts
-var PricingMeasure = /* @__PURE__ */ ((PricingMeasure3) => {
-  PricingMeasure3["PER_ML"] = "per_ml";
-  PricingMeasure3["PER_ZONE"] = "per_zone";
-  PricingMeasure3["PER_AREA"] = "per_area";
-  PricingMeasure3["PER_SESSION"] = "per_session";
-  PricingMeasure3["PER_TREATMENT"] = "per_treatment";
-  PricingMeasure3["PER_PACKAGE"] = "per_package";
-  return PricingMeasure3;
-})(PricingMeasure || {});
-var Currency = /* @__PURE__ */ ((Currency2) => {
-  Currency2["EUR"] = "EUR";
-  Currency2["USD"] = "USD";
-  Currency2["GBP"] = "GBP";
-  Currency2["CHF"] = "CHF";
-  Currency2["AUD"] = "AUD";
-  return Currency2;
-})(Currency || {});
-
 // src/validations/shared.schema.ts
 var sharedClinicContactInfoSchema = import_zod12.z.object({
   email: import_zod12.z.string().email(),