@blackcode_sa/metaestetics-api 1.7.38 → 1.7.40

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/validations/appointment.schema.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/types/appointment/index.ts
 var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
@@ -267,140 +267,197 @@ var updateFilledDocumentDataSchema = 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
+import { z as z2 } from "zod";
+var mediaResourceSchema = z2.union([
+  z2.string().url(),
+  z2.instanceof(File),
+  z2.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 = z2.nativeEnum(AppointmentStatus);
-var paymentStatusSchema = z2.nativeEnum(PaymentStatus);
-var mediaTypeSchema = z2.nativeEnum(MediaType);
-var appointmentMediaItemSchema = z2.object({
-  id: z2.string().min(MIN_STRING_LENGTH, "Media item ID is required"),
+var appointmentStatusSchema = z3.nativeEnum(AppointmentStatus);
+var paymentStatusSchema = z3.nativeEnum(PaymentStatus);
+var mediaTypeSchema = z3.nativeEnum(MediaType);
+var appointmentMediaItemSchema = z3.object({
+  id: z3.string().min(MIN_STRING_LENGTH, "Media item ID is required"),
   type: mediaTypeSchema,
-  url: z2.string().url("Media URL must be a valid URL"),
-  fileName: z2.string().optional(),
-  uploadedAt: z2.any().refine(
+  url: z3.string().url("Media URL must be a valid URL"),
+  fileName: z3.string().optional(),
+  uploadedAt: z3.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: z2.string().min(MIN_STRING_LENGTH, "Uploaded by user ID is required"),
-  description: z2.string().max(MAX_STRING_LENGTH, "Description too long").optional()
+  uploadedBy: z3.string().min(MIN_STRING_LENGTH, "Uploaded by user ID is required"),
+  description: z3.string().max(MAX_STRING_LENGTH, "Description too long").optional()
 });
-var procedureExtendedInfoSchema = z2.object({
-  id: z2.string().min(MIN_STRING_LENGTH),
-  name: z2.string().min(MIN_STRING_LENGTH),
-  description: z2.string(),
-  cost: z2.number().min(0),
-  duration: z2.number().min(0),
-  procedureFamily: z2.any(),
-  procedureCategoryId: z2.string(),
-  procedureCategoryName: z2.string(),
-  procedureSubCategoryId: z2.string(),
-  procedureSubCategoryName: z2.string(),
-  procedureTechnologyId: z2.string(),
-  procedureTechnologyName: z2.string(),
-  procedureProductBrandId: z2.string(),
-  procedureProductBrandName: z2.string(),
-  procedureProductId: z2.string(),
-  procedureProductName: z2.string()
+var procedureExtendedInfoSchema = z3.object({
+  id: z3.string().min(MIN_STRING_LENGTH),
+  name: z3.string().min(MIN_STRING_LENGTH),
+  description: z3.string(),
+  cost: z3.number().min(0),
+  duration: z3.number().min(0),
+  procedureFamily: z3.any(),
+  procedureCategoryId: z3.string(),
+  procedureCategoryName: z3.string(),
+  procedureSubCategoryId: z3.string(),
+  procedureSubCategoryName: z3.string(),
+  procedureTechnologyId: z3.string(),
+  procedureTechnologyName: z3.string(),
+  procedureProductBrandId: z3.string(),
+  procedureProductBrandName: z3.string(),
+  procedureProductId: z3.string(),
+  procedureProductName: z3.string()
 });
-var linkedFormInfoSchema = z2.object({
-  formId: z2.string().min(MIN_STRING_LENGTH, "Form ID is required"),
-  templateId: z2.string().min(MIN_STRING_LENGTH, "Template ID is required"),
-  templateVersion: z2.number().int().positive("Template version must be a positive integer"),
-  title: z2.string().min(MIN_STRING_LENGTH, "Form title is required"),
-  isUserForm: z2.boolean(),
-  isRequired: z2.boolean().optional(),
+var linkedFormInfoSchema = z3.object({
+  formId: z3.string().min(MIN_STRING_LENGTH, "Form ID is required"),
+  templateId: z3.string().min(MIN_STRING_LENGTH, "Template ID is required"),
+  templateVersion: z3.number().int().positive("Template version must be a positive integer"),
+  title: z3.string().min(MIN_STRING_LENGTH, "Form title is required"),
+  isUserForm: z3.boolean(),
+  isRequired: z3.boolean().optional(),
   status: filledDocumentStatusSchema,
-  path: z2.string().min(MIN_STRING_LENGTH, "Form path is required"),
-  submittedAt: z2.any().refine(
+  path: z3.string().min(MIN_STRING_LENGTH, "Form path is required"),
+  submittedAt: z3.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: z2.any().refine(
+  completedAt: z3.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 = z2.object({
-  reviewId: z2.string().min(MIN_STRING_LENGTH, "Review ID is required"),
-  rating: z2.number().min(1).max(5, "Rating must be between 1 and 5"),
-  comment: z2.string().max(MAX_STRING_LENGTH_LONG, "Comment too long").optional(),
-  reviewedAt: z2.any().refine(
+var patientReviewInfoSchema = z3.object({
+  reviewId: z3.string().min(MIN_STRING_LENGTH, "Review ID is required"),
+  rating: z3.number().min(1).max(5, "Rating must be between 1 and 5"),
+  comment: z3.string().max(MAX_STRING_LENGTH_LONG, "Comment too long").optional(),
+  reviewedAt: z3.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 = z2.object({
-  by: z2.string().min(MIN_STRING_LENGTH, "Finalized by user ID is required"),
-  at: z2.any().refine(
+var finalizedDetailsSchema = z3.object({
+  by: z3.string().min(MIN_STRING_LENGTH, "Finalized by user ID is required"),
+  at: z3.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: z2.string().max(MAX_STRING_LENGTH_LONG, "Finalization notes too long").optional()
+  notes: z3.string().max(MAX_STRING_LENGTH_LONG, "Finalization notes too long").optional()
+});
+var beforeAfterPerZoneSchema = z3.object({
+  before: mediaResourceSchema.nullable(),
+  after: mediaResourceSchema.nullable(),
+  note: z3.string().nullable()
+});
+var billingPerZoneSchema = z3.object({
+  Product: z3.string().min(MIN_STRING_LENGTH, "Product name is required"),
+  ProductId: z3.string().nullable(),
+  Quantity: z3.number().min(0, "Quantity must be non-negative"),
+  UnitOfMeasurement: z3.nativeEnum(PricingMeasure),
+  UnitPrice: z3.number().min(0, "Unit price must be non-negative"),
+  UnitCurency: z3.nativeEnum(Currency),
+  Subtotal: z3.number().min(0, "Subtotal must be non-negative"),
+  Note: z3.string().nullable()
 });
-var createAppointmentSchema = z2.object({
-  clinicBranchId: z2.string().min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
-  practitionerId: z2.string().min(MIN_STRING_LENGTH, "Practitioner ID is required"),
-  patientId: z2.string().min(MIN_STRING_LENGTH, "Patient ID is required"),
-  procedureId: z2.string().min(MIN_STRING_LENGTH, "Procedure ID is required"),
-  appointmentStartTime: z2.any().refine(
+var finalBillingSchema = z3.object({
+  subtotalAll: z3.number().min(0, "Subtotal all must be non-negative"),
+  taxRate: z3.number().min(0).max(1, "Tax rate must be between 0 and 1"),
+  taxPrice: z3.number().min(0, "Tax price must be non-negative"),
+  finalPrice: z3.number().min(0, "Final price must be non-negative"),
+  finalQuantity: z3.number().min(0, "Final quantity must be non-negative"),
+  currency: z3.nativeEnum(Currency),
+  unitOfMeasurement: z3.nativeEnum(PricingMeasure)
+});
+var appointmentMetadataSchema = z3.object({
+  selectedZones: z3.array(z3.string()).nullable(),
+  zonePhotos: z3.record(z3.string(), beforeAfterPerZoneSchema).nullable(),
+  zoneBilling: z3.record(z3.string(), billingPerZoneSchema).nullable(),
+  finalbilling: finalBillingSchema.nullable()
+});
+var createAppointmentSchema = z3.object({
+  clinicBranchId: z3.string().min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
+  practitionerId: z3.string().min(MIN_STRING_LENGTH, "Practitioner ID is required"),
+  patientId: z3.string().min(MIN_STRING_LENGTH, "Patient ID is required"),
+  procedureId: z3.string().min(MIN_STRING_LENGTH, "Procedure ID is required"),
+  appointmentStartTime: z3.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: z2.any().refine(
+  appointmentEndTime: z3.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: z2.number().min(0, "Cost must be a non-negative number"),
-  currency: z2.string().min(1, "Currency is required"),
-  patientNotes: z2.string().max(MAX_STRING_LENGTH, "Patient notes too long").nullable().optional(),
+  cost: z3.number().min(0, "Cost must be a non-negative number"),
+  currency: z3.string().min(1, "Currency is required"),
+  patientNotes: z3.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 = z2.object({
+var updateAppointmentSchema = z3.object({
   status: appointmentStatusSchema.optional(),
-  confirmationTime: z2.any().optional().nullable(),
-  cancellationTime: z2.any().optional().nullable(),
-  rescheduleTime: z2.any().optional().nullable(),
-  procedureActualStartTime: z2.any().optional().nullable(),
-  actualDurationMinutes: z2.number().int().positive("Duration must be a positive integer").optional(),
-  cancellationReason: z2.string().max(MAX_STRING_LENGTH, "Cancellation reason too long").nullable().optional(),
-  canceledBy: z2.enum(["patient", "clinic", "practitioner", "system"]).optional(),
-  internalNotes: z2.string().max(MAX_STRING_LENGTH_LONG, "Internal notes too long").nullable().optional(),
-  patientNotes: z2.any().optional().nullable(),
+  confirmationTime: z3.any().optional().nullable(),
+  cancellationTime: z3.any().optional().nullable(),
+  rescheduleTime: z3.any().optional().nullable(),
+  procedureActualStartTime: z3.any().optional().nullable(),
+  actualDurationMinutes: z3.number().int().positive("Duration must be a positive integer").optional(),
+  cancellationReason: z3.string().max(MAX_STRING_LENGTH, "Cancellation reason too long").nullable().optional(),
+  canceledBy: z3.enum(["patient", "clinic", "practitioner", "system"]).optional(),
+  internalNotes: z3.string().max(MAX_STRING_LENGTH_LONG, "Internal notes too long").nullable().optional(),
+  patientNotes: z3.any().optional().nullable(),
   paymentStatus: paymentStatusSchema.optional(),
-  paymentTransactionId: z2.any().optional().nullable(),
-  completedPreRequirements: z2.union([z2.array(z2.string()), z2.any()]).optional(),
-  completedPostRequirements: z2.union([z2.array(z2.string()), z2.any()]).optional(),
-  linkedFormIds: z2.union([z2.array(z2.string()), z2.any()]).optional(),
-  pendingUserFormsIds: z2.union([z2.array(z2.string()), z2.any()]).optional(),
-  appointmentStartTime: z2.any().refine(
+  paymentTransactionId: z3.any().optional().nullable(),
+  completedPreRequirements: z3.union([z3.array(z3.string()), z3.any()]).optional(),
+  completedPostRequirements: z3.union([z3.array(z3.string()), z3.any()]).optional(),
+  linkedFormIds: z3.union([z3.array(z3.string()), z3.any()]).optional(),
+  pendingUserFormsIds: z3.union([z3.array(z3.string()), z3.any()]).optional(),
+  appointmentStartTime: z3.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: z2.any().refine(
+  appointmentEndTime: z3.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: z2.string().min(MIN_STRING_LENGTH).optional(),
-  cost: z2.number().min(0).optional(),
-  clinicBranchId: z2.string().min(MIN_STRING_LENGTH).optional(),
-  practitionerId: z2.string().min(MIN_STRING_LENGTH).optional(),
-  linkedForms: z2.union([z2.array(linkedFormInfoSchema).max(MAX_ARRAY_LENGTH), z2.any()]).optional(),
-  media: z2.union([
-    z2.array(appointmentMediaItemSchema).max(MAX_ARRAY_LENGTH),
-    z2.any()
+  calendarEventId: z3.string().min(MIN_STRING_LENGTH).optional(),
+  cost: z3.number().min(0).optional(),
+  clinicBranchId: z3.string().min(MIN_STRING_LENGTH).optional(),
+  practitionerId: z3.string().min(MIN_STRING_LENGTH).optional(),
+  linkedForms: z3.union([z3.array(linkedFormInfoSchema).max(MAX_ARRAY_LENGTH), z3.any()]).optional(),
+  media: z3.union([
+    z3.array(appointmentMediaItemSchema).max(MAX_ARRAY_LENGTH),
+    z3.any()
   ]).optional(),
-  reviewInfo: z2.union([patientReviewInfoSchema.nullable(), z2.any()]).optional(),
-  finalizedDetails: z2.union([finalizedDetailsSchema.nullable(), z2.any()]).optional(),
-  isArchived: z2.boolean().optional(),
-  updatedAt: z2.any().optional(),
-  metadata: z2.any().optional()
+  reviewInfo: z3.union([patientReviewInfoSchema.nullable(), z3.any()]).optional(),
+  finalizedDetails: z3.union([finalizedDetailsSchema.nullable(), z3.any()]).optional(),
+  isArchived: z3.boolean().optional(),
+  updatedAt: z3.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 */) {
@@ -424,24 +481,24 @@ var updateAppointmentSchema = z2.object({
     path: ["appointmentEndTime"]
   }
 );
-var searchAppointmentsSchema = z2.object({
-  patientId: z2.string().optional(),
-  practitionerId: z2.string().optional(),
-  clinicBranchId: z2.string().optional(),
-  startDate: z2.any().refine(
+var searchAppointmentsSchema = z3.object({
+  patientId: z3.string().optional(),
+  practitionerId: z3.string().optional(),
+  clinicBranchId: z3.string().optional(),
+  startDate: z3.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: z2.any().refine(
+  endDate: z3.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: z2.union([
+  status: z3.union([
     appointmentStatusSchema,
-    z2.array(appointmentStatusSchema).nonempty()
+    z3.array(appointmentStatusSchema).nonempty()
   ]).optional(),
-  limit: z2.number().positive().int().optional().default(20),
-  startAfter: z2.any().optional()
+  limit: z3.number().positive().int().optional().default(20),
+  startAfter: z3.any().optional()
 }).refine(
   (data) => {
     if (!data.startDate && !data.endDate && !data.status) {
@@ -465,13 +522,13 @@ var searchAppointmentsSchema = z2.object({
     path: ["endDate"]
   }
 );
-var rescheduleAppointmentSchema = z2.object({
-  appointmentId: z2.string().min(MIN_STRING_LENGTH, "Appointment ID is required"),
-  newStartTime: z2.any().refine(
+var rescheduleAppointmentSchema = z3.object({
+  appointmentId: z3.string().min(MIN_STRING_LENGTH, "Appointment ID is required"),
+  newStartTime: z3.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: z2.any().refine(
+  newEndTime: z3.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"
   )
@@ -591,24 +648,24 @@ var USERS_COLLECTION = "users";
 import { z as z20 } from "zod";
 
 // src/validations/schemas.ts
-import { z as z3 } from "zod";
-var emailSchema = z3.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 = z3.string().min(8, "Password must be at least 8 characters").max(100, "Password must be less than 100 characters").regex(
+import { z as z4 } from "zod";
+var emailSchema = z4.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 = z4.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 = z3.nativeEnum(UserRole);
-var userRolesSchema = z3.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
-var timestampSchema = z3.custom((data) => {
+var userRoleSchema = z4.nativeEnum(UserRole);
+var userRolesSchema = z4.array(userRoleSchema).min(1, "User must have at least one role").max(3, "User cannot have more than 3 roles");
+var timestampSchema = z4.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 = z3.object({
-  isGroupOwner: z3.boolean(),
-  groupToken: z3.string().optional(),
-  groupId: z3.string().optional()
+var clinicAdminOptionsSchema = z4.object({
+  isGroupOwner: z4.boolean(),
+  groupToken: z4.string().optional(),
+  groupId: z4.string().optional()
 }).refine(
   (data) => {
     if (!data.isGroupOwner && (!data.groupToken || !data.groupId)) {
@@ -623,20 +680,20 @@ var clinicAdminOptionsSchema = z3.object({
     message: "Invalid clinic admin options configuration"
   }
 );
-var createUserOptionsSchema = z3.object({
+var createUserOptionsSchema = z4.object({
   clinicAdminData: clinicAdminOptionsSchema.optional()
 });
-var userSchema = z3.object({
-  uid: z3.string(),
-  email: z3.string().email().nullable(),
-  roles: z3.array(userRoleSchema),
-  isAnonymous: z3.boolean(),
+var userSchema = z4.object({
+  uid: z4.string(),
+  email: z4.string().email().nullable(),
+  roles: z4.array(userRoleSchema),
+  isAnonymous: z4.boolean(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema,
   lastLoginAt: timestampSchema,
-  patientProfile: z3.string().optional(),
-  practitionerProfile: z3.string().optional(),
-  adminProfile: z3.string().optional()
+  patientProfile: z4.string().optional(),
+  practitionerProfile: z4.string().optional(),
+  adminProfile: z4.string().optional()
 });
 
 // src/errors/auth.errors.ts
@@ -1372,14 +1429,6 @@ var Gender = /* @__PURE__ */ ((Gender2) => {
 import { z as z7 } from "zod";
 import { Timestamp as Timestamp3 } from "firebase/firestore";
 
-// src/validations/media.schema.ts
-import { z as z4 } from "zod";
-var mediaResourceSchema = z4.union([
-  z4.string().url(),
-  z4.instanceof(File),
-  z4.instanceof(Blob)
-]);
-
 // src/validations/patient/medical-info.schema.ts
 import { z as z6 } from "zod";
 
@@ -3634,25 +3683,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 = z12.object({
   email: z12.string().email(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.7.38",
+  "version": "1.7.40",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/index.ts

@@ -134,6 +134,10 @@ export type {
   CreateAppointmentHttpData,
   UpdateAppointmentData,
   SearchAppointmentsParams,
+  AppointmentMetadata,
+  BeforeAfterPerZone,
+  BillingPerZone,
+  FinalBilling,
 } from "./types/appointment";
 export {
   AppointmentStatus,

package/src/types/appointment/index.ts

@@ -5,12 +5,16 @@ import {
   PatientProfileInfo,
 } from "../profile";
 import { ProcedureSummaryInfo } from "../procedure";
-import { Currency } from "../../backoffice/types/static/pricing.types";
+import {
+  Currency,
+  type PricingMeasure,
+} from "../../backoffice/types/static/pricing.types";
 import { BlockingCondition } from "../../backoffice/types/static/blocking-condition.types";
 import { Contraindication } from "../../backoffice/types/static/contraindication.types";
 import { Requirement } from "../../backoffice/types/requirement.types";
 import { FilledDocumentStatus } from "../documentation-templates";
 import type { ProcedureFamily } from "../../backoffice";
+import type { MediaResource } from "../../services/media/media.service";
 
 /**
  * Enum defining the possible statuses of an appointment.
@@ -111,6 +115,74 @@ export interface PatientReviewInfo {
   reviewedAt: Timestamp;
 }
 
+/**
+ * Interface for before/after photos and notes per zone
+ */
+export interface BeforeAfterPerZone {
+  /** URL for before photo or null if not available */
+  before: MediaResource | null;
+  /** URL for after photo or null if not available */
+  after: MediaResource | null;
+  /** Optional note for the zone */
+  note: string | null;
+}
+
+/**
+ * Interface for billing information per zone
+ */
+export interface BillingPerZone {
+  /** Product name/description */
+  Product: string;
+  /** Product ID */
+  ProductId: string | null;
+  /** Quantity used (can be decimal) */
+  Quantity: number;
+  /** Unit of measurement */
+  UnitOfMeasurement: PricingMeasure;
+  /** Unit price for the product */
+  UnitPrice: number;
+  /** Currency for the unit price */
+  UnitCurency: Currency;
+  /** Calculated subtotal */
+  Subtotal: number;
+  /** Optional billing note */
+  Note: string | null;
+}
+
+/**
+ * Interface for final billing calculations of the appointment
+ */
+export interface FinalBilling {
+  /** Total of all subtotals from all zones */
+  subtotalAll: number;
+  /** Tax rate as percentage (e.g., 0.20 for 20%) */
+  taxRate: number;
+  /** Calculated tax amount */
+  taxPrice: number;
+  /** Final price including tax */
+  finalPrice: number;
+  /** Total final quantity across all zones */
+  finalQuantity: number;
+  /** Currency for the final billing */
+  currency: Currency;
+  /** Unit of measurement for the final billing */
+  unitOfMeasurement: PricingMeasure;
+}
+
+/**
+ * Interface for appointment metadata containing zone-specific information
+ */
+export interface AppointmentMetadata {
+  /** Array of selected zones for the appointment */
+  selectedZones: string[] | null;
+  /** Map of zone photos with before/after images and notes */
+  zonePhotos: Record<string, BeforeAfterPerZone> | null;
+  /** Map of billing information per zone */
+  zoneBilling: Record<string, BillingPerZone> | null;
+  /** Final billing calculations for the appointment */
+  finalbilling: FinalBilling | null;
+}
+
 /**
  * Represents a booked appointment, aggregating key information and relevant procedure rules.
  */
@@ -209,7 +281,7 @@ export interface Appointment {
   isArchived?: boolean;
 
   /** NEW: Metadata for the appointment - used for area selection and photos */
-  metadata?: any;
+  metadata?: AppointmentMetadata;
 }
 
 /**
@@ -284,7 +356,7 @@ export interface UpdateAppointmentData {
   updatedAt?: FieldValue; // To set server timestamp
 
   /** NEW: For updating metadata */
-  metadata?: any;
+  metadata?: AppointmentMetadata;
 }
 
 /**

package/src/validations/appointment.schema.ts

@@ -5,6 +5,11 @@ import {
   MediaType,
 } from "../types/appointment";
 import { filledDocumentStatusSchema } from "./documentation-templates.schema";
+import {
+  Currency,
+  PricingMeasure,
+} from "../backoffice/types/static/pricing.types";
+import { mediaResourceSchema } from "./media.schema";
 
 // Define common constants locally if not available from common.schema.ts
 const MIN_STRING_LENGTH = 1;
@@ -147,6 +152,52 @@ export const finalizedDetailsSchema = z.object({
     .optional(),
 });
 
+/**
+ * Schema for before/after photos and notes per zone
+ */
+export const beforeAfterPerZoneSchema = z.object({
+  before: mediaResourceSchema.nullable(),
+  after: mediaResourceSchema.nullable(),
+  note: z.string().nullable(),
+});
+
+/**
+ * Schema for billing information per zone
+ */
+export const billingPerZoneSchema = z.object({
+  Product: z.string().min(MIN_STRING_LENGTH, "Product name is required"),
+  ProductId: z.string().nullable(),
+  Quantity: z.number().min(0, "Quantity must be non-negative"),
+  UnitOfMeasurement: z.nativeEnum(PricingMeasure),
+  UnitPrice: z.number().min(0, "Unit price must be non-negative"),
+  UnitCurency: z.nativeEnum(Currency),
+  Subtotal: z.number().min(0, "Subtotal must be non-negative"),
+  Note: z.string().nullable(),
+});
+
+/**
+ * Schema for final billing calculations of the appointment
+ */
+export const finalBillingSchema = z.object({
+  subtotalAll: z.number().min(0, "Subtotal all must be non-negative"),
+  taxRate: z.number().min(0).max(1, "Tax rate must be between 0 and 1"),
+  taxPrice: z.number().min(0, "Tax price must be non-negative"),
+  finalPrice: z.number().min(0, "Final price must be non-negative"),
+  finalQuantity: z.number().min(0, "Final quantity must be non-negative"),
+  currency: z.nativeEnum(Currency),
+  unitOfMeasurement: z.nativeEnum(PricingMeasure),
+});
+
+/**
+ * Schema for appointment metadata containing zone-specific information
+ */
+export const appointmentMetadataSchema = z.object({
+  selectedZones: z.array(z.string()).nullable(),
+  zonePhotos: z.record(z.string(), beforeAfterPerZoneSchema).nullable(),
+  zoneBilling: z.record(z.string(), billingPerZoneSchema).nullable(),
+  finalbilling: finalBillingSchema.nullable(),
+});
+
 // --- Main Appointment Schemas ---
 
 /**
@@ -291,7 +342,7 @@ export const updateAppointmentSchema = z
       .optional(),
     isArchived: z.boolean().optional(),
     updatedAt: z.any().optional(),
-    metadata: z.any().optional(),
+    metadata: appointmentMetadataSchema.optional(),
   })
   .refine(
     (data) => {