@nyig/models 0.5.5 → 0.5.6

package/index.mjs

@@ -61,7 +61,7 @@ var BookingType = /* @__PURE__ */ ((BookingType2) => {
 })(BookingType || {});
 
 // src/interface/booking/campBooking.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/interface/tracking/attendState.ts
 var AttendState = /* @__PURE__ */ ((AttendState2) => {
@@ -72,7 +72,7 @@ var AttendState = /* @__PURE__ */ ((AttendState2) => {
 })(AttendState || {});
 
 // src/interface/tracking/attendance.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/interface/payment/tuition.ts
 import { z as z3 } from "zod";
@@ -189,43 +189,69 @@ var zBUser = z6.object({
   /**
    * For prompting the user to change their password on first login
    */
-  shouldChangePassword: z6.boolean().optional()
+  shouldChangePassword: z6.boolean().optional(),
+  /**
+   * Object storing user preferences
+   */
+  info: z6.string().optional()
 });
 var zUser = addAutoProps(zBUser);
 
-// src/interface/user/student.ts
+// src/interface/user/userInfo.ts
 import { z as z7 } from "zod";
+var zBUserProfile = z7.object({
+  firstName: z7.string().min(2).max(50).or(z7.literal("")).optional(),
+  lastName: z7.string().min(2).max(50).or(z7.literal("")).optional(),
+  address: z7.string().or(z7.literal("")).optional(),
+  rank: z7.enum(GoRank).optional(),
+  agaId: z7.string().regex(/^\d{4,5}$/, {
+    message: `Please enter a valid AGA ID`
+  }).or(z7.literal("")).optional(),
+  participateAs: z7.enum(["adult", "youth"]).optional(),
+  showOnWhoIsComing: z7.boolean().optional(),
+  preferredEmail: z7.email().optional(),
+  phoneNumber: z7.string().regex(/^\d{10}/, {
+    message: `Please enter a valid 10-digit US phone number with numbers only`
+  }).or(z7.literal("")).optional(),
+  birthDate: z7.string().regex(/^\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])$/, {
+    message: "Enter a valid date in yyyy-mm-dd format"
+  }).or(z7.literal("")).optional()
+});
+var zUserProfile = addAutoProps(zBUserProfile);
+
+// src/interface/user/student.ts
+import { z as z8 } from "zod";
 var zBStudent = zBUser.extend({
-  rank: z7.nativeEnum(GoRank),
-  guardian: z7.string().optional()
+  rank: z8.nativeEnum(GoRank),
+  guardian: z8.string().optional()
 });
 var zStudent = addAutoProps(zBStudent);
 
 // src/interface/user/teacher.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var zBTeacher = zBUser.extend({
-  rank: z8.nativeEnum(GoRank),
+  rank: z9.nativeEnum(GoRank),
   /**
    * Inactive teachers are not shown on public endpoints
    */
-  isInactive: z8.boolean().optional(),
+  isInactive: z9.boolean().optional(),
   /**
    * If true, teacher is never available for booking
    */
-  doesNotTeachPrivateLessons: z8.boolean().optional(),
+  doesNotTeachPrivateLessons: z9.boolean().optional(),
   /**
    * Teacher's position, e.g., instructor, president
    */
-  title: z8.string().optional(),
+  title: z9.string().optional(),
   /**
    * Teacher's bio text describing experience
    * new lines will be rendered as paragraphs
    */
-  bio: z8.string().optional(),
+  bio: z9.string().optional(),
   /**
    * Permanent URL of the image
    */
-  imageUrl: z8.string().optional(),
+  imageUrl: z9.string().optional(),
   /** Format is illustrated below, where teacher is available
    * Mon 9-12am 3-6pm & Tue 10-12am 6-10pm
    * [
@@ -238,54 +264,54 @@ var zBTeacher = zBUser.extend({
    *  [],
    * ]
    */
-  available: z8.array(z8.array(z8.array(z8.number()))).optional()
+  available: z9.array(z9.array(z9.array(z9.number()))).optional()
 });
 var zTeacher = addAutoProps(zBTeacher);
 var zTeacherResponse = zTeacher.omit({ password: true, roles: true, editedBy: true, updatedAt: true, createdAt: true }).extend({
-  role: z8.number().int()
+  role: z9.number().int()
 });
 
 // src/interface/user/auth.ts
-import { z as z9 } from "zod";
-var zCreateAdminAccountRequest = z9.object({
-  _id: z9.string(),
-  user: z9.string().min(3, "Username must be at least 3 characters"),
-  pwd: z9.string().min(6)
+import { z as z10 } from "zod";
+var zCreateAdminAccountRequest = z10.object({
+  _id: z10.string(),
+  user: z10.string().min(3, "Username must be at least 3 characters"),
+  pwd: z10.string().min(6)
 });
-var zChangePasswordRequest = z9.object({
-  prev: z9.string().min(6),
-  next: z9.string().min(6)
+var zChangePasswordRequest = z10.object({
+  prev: z10.string().min(6),
+  next: z10.string().min(6)
 });
-var zLoginRequest = z9.object({
-  user: z9.string().min(3, "Username must be at least 3 characters"),
-  pwd: z9.string().min(6)
+var zLoginRequest = z10.object({
+  user: z10.string().min(3, "Username must be at least 3 characters"),
+  pwd: z10.string().min(6)
 });
-var zLoginResponse = z9.object({
-  user: z9.string(),
-  token: z9.string()
+var zLoginResponse = z10.object({
+  user: z10.string(),
+  token: z10.string()
 });
 
 // src/interface/tracking/attendance.ts
-var zBAttendance = z10.object({
-  student: z10.string(),
-  states: z10.array(z10.nativeEnum(AttendState)),
+var zBAttendance = z11.object({
+  student: z11.string(),
+  states: z11.array(z11.nativeEnum(AttendState)),
   /**
    * @deprecated This field is no longer used
    */
   tuition: zTuition.optional(),
-  paid: z10.boolean().optional(),
-  campOption: z10.nativeEnum(CampOption).optional()
+  paid: z11.boolean().optional(),
+  campOption: z11.nativeEnum(CampOption).optional()
 });
 var zAttendance = addAutoProps(zBAttendance);
 var zAttendanceRequest = zAttendance.extend({
-  _id: z10.string().optional()
+  _id: z11.string().optional()
 });
 var zAttendanceResponse = zAttendance.extend({
   student: zStudent
 });
 
 // src/interface/tracking/campTracker.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/interface/course/ageGroup.ts
 var AgeGroup = /* @__PURE__ */ ((AgeGroup2) => {
@@ -313,36 +339,36 @@ var NYIGSchool = /* @__PURE__ */ ((NYIGSchool2) => {
 })(NYIGSchool || {});
 
 // src/interface/course/course.ts
-import { z as z11 } from "zod";
-var zBCourse = z11.object({
-  name: z11.string(),
-  category: z11.nativeEnum(CourseCategory),
+import { z as z12 } from "zod";
+var zBCourse = z12.object({
+  name: z12.string(),
+  category: z12.nativeEnum(CourseCategory),
   /**
    * @unit SECONDS - Duration of the course in seconds
    */
-  duration: z11.coerce.number().int("Duration in seconds must be a whole number").min(1, "Duration in seconds must not be less than or equal to 0"),
+  duration: z12.coerce.number().int("Duration in seconds must be a whole number").min(1, "Duration in seconds must not be less than or equal to 0"),
   /**
    * @unit CENTS - Price of the course in cents
    */
-  price: z11.coerce.number().int("Tuition must be a whole number in cents").min(1, "Tuition must not be less than or equal to 0"),
-  description: z11.string().or(z11.literal("")).optional(),
+  price: z12.coerce.number().int("Tuition must be a whole number in cents").min(1, "Tuition must not be less than or equal to 0"),
+  description: z12.string().or(z12.literal("")).optional(),
   /**
    * NYIG School locations
    */
-  nyigSchool: z11.nativeEnum(NYIGSchool),
+  nyigSchool: z12.nativeEnum(NYIGSchool),
   /**
    * Recommended level before taking this course
    */
-  recLevel: z11.string().or(z11.literal("")).optional(),
+  recLevel: z12.string().or(z12.literal("")).optional(),
   /**
    * Camp tuition for half-day option
    */
-  halfCampTuition: z11.coerce.number().int("Tuition must be a whole number in cents").min(1, "Tuition must not be less than or equal to 0").optional(),
+  halfCampTuition: z12.coerce.number().int("Tuition must be a whole number in cents").min(1, "Tuition must not be less than or equal to 0").optional(),
   /**
    * Camp tuition for full-day option
    */
-  fullCampTuition: z11.coerce.number().int("Tuition must be a whole number in cents").min(1, "Tuition must not be less than or equal to 0").optional(),
-  superadminOnly: z11.boolean().optional()
+  fullCampTuition: z12.coerce.number().int("Tuition must be a whole number in cents").min(1, "Tuition must not be less than or equal to 0").optional(),
+  superadminOnly: z12.boolean().optional()
 });
 var zCourse = addAutoProps(zBCourse);
 
@@ -355,57 +381,57 @@ var Season = /* @__PURE__ */ ((Season2) => {
 })(Season || {});
 
 // src/interface/semester/semester.ts
-import { z as z12 } from "zod";
-var zBSemester = z12.object({
-  season: z12.nativeEnum(Season),
-  year: z12.coerce.number().min(2022).max(2999),
-  startDate: z12.coerce.date(),
-  endDate: z12.coerce.date(),
+import { z as z13 } from "zod";
+var zBSemester = z13.object({
+  season: z13.nativeEnum(Season),
+  year: z13.coerce.number().min(2022).max(2999),
+  startDate: z13.coerce.date(),
+  endDate: z13.coerce.date(),
   /**
    * Format: start, end, start, end, ...
    */
-  blackoutDates: z12.array(z12.coerce.date()),
+  blackoutDates: z13.array(z13.coerce.date()),
   /**
    * List of names of some break: date range
    */
-  importantDates: z12.array(z12.string())
+  importantDates: z13.array(z13.string())
 });
 var zSemester = addAutoProps(zBSemester);
 
 // src/interface/tracking/campTracker.ts
 var MAX_TEACHERS = 10;
-var zBCampTracker = z13.object({
-  course: z13.string(),
-  teachers: z13.array(z13.string()).min(1, "Camp must have at least 1 teacher").max(MAX_TEACHERS, `Camp can have at most ${MAX_TEACHERS} teachers`),
-  semester: z13.string(),
+var zBCampTracker = z14.object({
+  course: z14.string(),
+  teachers: z14.array(z14.string()).min(1, "Camp must have at least 1 teacher").max(MAX_TEACHERS, `Camp can have at most ${MAX_TEACHERS} teachers`),
+  semester: z14.string(),
   /**
    * occurrences are tracked by week for camps
    */
-  occurrences: z13.array(z13.string()).min(1, "Camp must have at least 1 date range"),
+  occurrences: z14.array(z14.string()).min(1, "Camp must have at least 1 date range"),
   /**
    * attendances are tracked by week for camps
    */
-  attendances: z13.array(zAttendanceRequest),
-  publicDescription: z13.string().optional(),
-  isNonPublic: z13.boolean().optional(),
-  notes: z13.string().optional()
+  attendances: z14.array(zAttendanceRequest),
+  publicDescription: z14.string().optional(),
+  isNonPublic: z14.boolean().optional(),
+  notes: z14.string().optional()
 });
 var zCampTracker = addAutoProps(zBCampTracker);
 var zCampTrackerResponse = zCampTracker.extend({
   course: zCourse,
-  teachers: z13.array(zTeacher).min(1, "Camp must have at least 1 teacher").max(MAX_TEACHERS, `Camp can have at most ${MAX_TEACHERS} teachers`),
+  teachers: z14.array(zTeacher).min(1, "Camp must have at least 1 teacher").max(MAX_TEACHERS, `Camp can have at most ${MAX_TEACHERS} teachers`),
   semester: zSemester,
-  attendances: z13.array(zAttendanceResponse)
+  attendances: z14.array(zAttendanceResponse)
 });
 
 // src/interface/tracking/classTracker.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/interface/tracking/classTimesInput.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/interface/tracking/dayOfWeek.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var DayOfWeek = /* @__PURE__ */ ((DayOfWeek2) => {
   DayOfWeek2[DayOfWeek2["SUNDAY"] = 0] = "SUNDAY";
   DayOfWeek2[DayOfWeek2["MONDAY"] = 1] = "MONDAY";
@@ -416,33 +442,33 @@ var DayOfWeek = /* @__PURE__ */ ((DayOfWeek2) => {
   DayOfWeek2[DayOfWeek2["SATURDAY"] = 6] = "SATURDAY";
   return DayOfWeek2;
 })(DayOfWeek || {});
-var zDayOfWeek = z14.nativeEnum(DayOfWeek);
+var zDayOfWeek = z15.nativeEnum(DayOfWeek);
 
 // src/interface/tracking/classTimesInput.ts
-var zClassTimesInput = z15.object({
-  startDate: z15.date(),
-  freq: z15.coerce.number().min(1, "Please select a valid frequency"),
-  daysOfWeek: z15.array(zDayOfWeek),
-  numberOfClasses: z15.coerce.number().int().min(1, "Must enroll in at least one class")
+var zClassTimesInput = z16.object({
+  startDate: z16.date(),
+  freq: z16.coerce.number().min(1, "Please select a valid frequency"),
+  daysOfWeek: z16.array(zDayOfWeek),
+  numberOfClasses: z16.coerce.number().int().min(1, "Must enroll in at least one class")
 });
 
 // src/interface/tracking/classTracker.ts
-var zBClassTracker = z16.object({
-  course: z16.string(),
-  teacher: z16.string(),
-  student: z16.string(),
-  classTimes: z16.array(z16.coerce.date()),
-  completedList: z16.array(z16.boolean()),
+var zBClassTracker = z17.object({
+  course: z17.string(),
+  teacher: z17.string(),
+  student: z17.string(),
+  classTimes: z17.array(z17.coerce.date()),
+  completedList: z17.array(z17.boolean()),
   /**
    * Virtual mongoose field when all values in completedList is true
    */
-  completed: z16.boolean().optional(),
+  completed: z17.boolean().optional(),
   /**
    * @deprecated This field is no longer used
    */
-  paid: z16.boolean().optional(),
-  paused: z16.boolean().optional(),
-  notes: z16.string().optional()
+  paid: z17.boolean().optional(),
+  paused: z17.boolean().optional(),
+  notes: z17.string().optional()
 });
 var zClassTracker = addAutoProps(zBClassTracker);
 var zClassTrackerResponse = zClassTracker.extend({
@@ -455,89 +481,89 @@ var zTrackerCreate = zBClassTracker.extend({
 });
 
 // src/interface/tracking/groupTracker.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/interface/tracking/scheduleData.ts
-import { z as z17 } from "zod";
-var zScheduleData = z17.object({
-  startTime: z17.string(),
+import { z as z18 } from "zod";
+var zScheduleData = z18.object({
+  startTime: z18.string(),
   // String in 24 hour "HH:mm" format
-  dayOfWeek: z17.number().int().min(0).max(6),
+  dayOfWeek: z18.number().int().min(0).max(6),
   // integeters in 0 - 6
-  startDate: z17.string().optional(),
+  startDate: z18.string().optional(),
   // First day of class, optional for backwards compatibility
-  numberOfClasses: z17.number().int().min(0).optional()
+  numberOfClasses: z18.number().int().min(0).optional()
   // optional for backwards compatibility
 });
 
 // src/interface/tracking/groupTracker.ts
-var zBGroupTracker = z18.object({
-  course: z18.string(),
-  teacher: z18.string(),
-  semester: z18.string(),
+var zBGroupTracker = z19.object({
+  course: z19.string(),
+  teacher: z19.string(),
+  semester: z19.string(),
   scheduleData: zScheduleData,
   /**
    * occurrences are tracked by week for Groups
    */
-  occurrences: z18.array(z18.string()),
+  occurrences: z19.array(z19.string()),
   /**
    * attendances are tracked by week for Groups
    */
-  attendances: z18.array(zAttendanceRequest),
+  attendances: z19.array(zAttendanceRequest),
   /**
    * public-facing ID of the course instance, e.g., 101
    */
-  courseId: z18.string().optional(),
+  courseId: z19.string().optional(),
   /**
    * Age group of the class instance, e.g. "adult", "youth"
    */
-  ageGroup: z18.nativeEnum(AgeGroup).optional(),
+  ageGroup: z19.nativeEnum(AgeGroup).optional(),
   /**
    * If true, the course is hidden from public view
    */
-  isNonPublic: z18.boolean().optional(),
-  notes: z18.string().optional()
+  isNonPublic: z19.boolean().optional(),
+  notes: z19.string().optional()
 });
 var zGroupTracker = addAutoProps(zBGroupTracker);
 var zGroupTrackerResponse = zGroupTracker.extend({
   course: zCourse,
   teacher: zTeacher,
   semester: zSemester,
-  attendances: z18.array(zAttendanceResponse)
+  attendances: z19.array(zAttendanceResponse)
 });
 
 // src/interface/booking/campBooking.ts
-var zBCampBooking = z19.object({
-  ctId: z19.string().optional(),
-  isOnline: z19.boolean(),
-  classDates: z19.string(),
-  campOption: z19.nativeEnum(CampOption),
-  shipping: z19.boolean().optional()
+var zBCampBooking = z20.object({
+  ctId: z20.string().optional(),
+  isOnline: z20.boolean(),
+  classDates: z20.string(),
+  campOption: z20.nativeEnum(CampOption),
+  shipping: z20.boolean().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zCampBooking = addAutoProps(zBCampBooking);
 
 // src/interface/booking/groupBooking.ts
-import { z as z20 } from "zod";
-var zBGroupBooking = z20.object({
-  gtId: z20.string().optional(),
-  isTrial: z20.boolean().optional(),
-  isOnline: z20.boolean(),
-  classDate: z20.string().optional(),
-  shipping: z20.boolean().optional()
+import { z as z21 } from "zod";
+var zBGroupBooking = z21.object({
+  gtId: z21.string().optional(),
+  isTrial: z21.boolean().optional(),
+  isOnline: z21.boolean(),
+  classDate: z21.string().optional(),
+  shipping: z21.boolean().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zGroupBooking = addAutoProps(zBGroupBooking);
 
 // src/interface/booking/privateBooking.ts
-import { z as z21 } from "zod";
-var zBPrivateBooking = z21.object({
-  courseId: z21.string(),
-  teacherId: z21.string(),
-  classDate: z21.string().optional()
+import { z as z22 } from "zod";
+var zBPrivateBooking = z22.object({
+  courseId: z22.string(),
+  teacherId: z22.string(),
+  classDate: z22.string().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zPrivateBooking = addAutoProps(zBPrivateBooking);
 
 // src/interface/payment/invoice.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // src/interface/payment/paymentMethod.ts
 var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
@@ -549,93 +575,93 @@ var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
 })(PaymentMethod || {});
 
 // src/interface/payment/invoice.ts
-var zDiscount = z22.object({
-  desc: z22.string().min(1, "Discount description cannot be empty"),
-  amount: z22.coerce.number()
+var zDiscount = z23.object({
+  desc: z23.string().min(1, "Discount description cannot be empty"),
+  amount: z23.coerce.number()
 });
-var zInvoiceItem = z22.object({
-  course: z22.string().min(1, "Course description cannot be empty"),
-  price: z22.coerce.number(),
-  units: z22.coerce.number()
+var zInvoiceItem = z23.object({
+  course: z23.string().min(1, "Course description cannot be empty"),
+  price: z23.coerce.number(),
+  units: z23.coerce.number()
 });
-var zInvoicePackage = z22.object({
-  student: z22.string(),
-  items: z22.array(zInvoiceItem).min(1, "Package must contain at least one item")
+var zInvoicePackage = z23.object({
+  student: z23.string(),
+  items: z23.array(zInvoiceItem).min(1, "Package must contain at least one item")
 });
 var zInvoicePackageResponse = zInvoicePackage.extend({
   student: zStudent
 });
-var zBInvoice = z22.object({
-  billTo: z22.string().min(1, "The 'Bill To' field must not be empty"),
-  packages: z22.array(zInvoicePackage).min(1, "Invoice must include at least one package"),
-  discounts: z22.array(zDiscount),
-  textbook: z22.coerce.number().int().min(0).optional(),
-  shipping: z22.coerce.number().int().min(0).optional(),
-  paid: z22.nativeEnum(PaymentMethod).optional(),
-  paidAt: z22.string().optional(),
-  showEin: z22.boolean().optional(),
-  notes: z22.string().or(z22.literal("")).optional(),
-  feeLabel: z22.string().optional(),
-  createdBy: z22.string()
+var zBInvoice = z23.object({
+  billTo: z23.string().min(1, "The 'Bill To' field must not be empty"),
+  packages: z23.array(zInvoicePackage).min(1, "Invoice must include at least one package"),
+  discounts: z23.array(zDiscount),
+  textbook: z23.coerce.number().int().min(0).optional(),
+  shipping: z23.coerce.number().int().min(0).optional(),
+  paid: z23.nativeEnum(PaymentMethod).optional(),
+  paidAt: z23.string().optional(),
+  showEin: z23.boolean().optional(),
+  notes: z23.string().or(z23.literal("")).optional(),
+  feeLabel: z23.string().optional(),
+  createdBy: z23.string()
 });
 var zInvoice = addAutoProps(zBInvoice);
 var zInvoiceResponse = zInvoice.extend({
   createdBy: zTeacher,
   editedBy: zTeacher.optional(),
-  packages: z22.array(zInvoicePackageResponse)
+  packages: z23.array(zInvoicePackageResponse)
 });
 
 // src/interface/payment/teacherPayment.ts
-import { z as z23 } from "zod";
-var zTeacherPaymentRow = z23.object({
-  course: z23.string().min(1, "select or enter a course"),
-  length: z23.coerce.number().gt(0, "must be > 0"),
-  count: z23.coerce.number().int().gt(0, "must be > 0"),
-  wage: z23.coerce.number().gt(0, "wage must be > 0")
+import { z as z24 } from "zod";
+var zTeacherPaymentRow = z24.object({
+  course: z24.string().min(1, "select or enter a course"),
+  length: z24.coerce.number().gt(0, "must be > 0"),
+  count: z24.coerce.number().int().gt(0, "must be > 0"),
+  wage: z24.coerce.number().gt(0, "wage must be > 0")
 });
-var zBTeacherPayment = z23.object({
-  teacher: z23.string().min(1, "select or enter a teacher"),
-  rows: z23.array(zTeacherPaymentRow),
-  paid: z23.boolean().optional(),
+var zBTeacherPayment = z24.object({
+  teacher: z24.string().min(1, "select or enter a teacher"),
+  rows: z24.array(zTeacherPaymentRow),
+  paid: z24.boolean().optional(),
   /**
    * paymentNotes differentiates from notes as it is displayed on the rendered PDF
    */
-  paymentNotes: z23.string().optional()
+  paymentNotes: z24.string().optional()
 });
 var zTeacherPayment = addAutoProps(zBTeacherPayment);
 var zTeacherPaymentResponse = zTeacherPayment.extend({
-  teacher: z23.object({ _id: z23.string(), name: z23.string(), rank: z23.string().optional() }),
-  editedBy: z23.object({ _id: z23.string(), name: z23.string(), rank: z23.string().optional() })
+  teacher: z24.object({ _id: z24.string(), name: z24.string(), rank: z24.string().optional() }),
+  editedBy: z24.object({ _id: z24.string(), name: z24.string(), rank: z24.string().optional() })
 });
 
 // src/interface/public/aurora.ts
-import { z as z24 } from "zod";
-var zTeacherDisplay = z24.object({
-  name: z24.string(),
-  email: z24.string().email(),
-  title: z24.string(),
-  imageUrl: z24.string(),
-  bio: z24.string()
-});
-var zCourseTable = z24.object({
-  id: z24.string(),
-  name: z24.string(),
-  duration: z24.number(),
-  dateAndTime: z24.string(),
-  recommendedLevel: z24.string(),
-  tuition: z24.string()
+import { z as z25 } from "zod";
+var zTeacherDisplay = z25.object({
+  name: z25.string(),
+  email: z25.string().email(),
+  title: z25.string(),
+  imageUrl: z25.string(),
+  bio: z25.string()
+});
+var zCourseTable = z25.object({
+  id: z25.string(),
+  name: z25.string(),
+  duration: z25.number(),
+  dateAndTime: z25.string(),
+  recommendedLevel: z25.string(),
+  tuition: z25.string()
 });
 
 // src/interface/public/imageDef.ts
-import { z as z25 } from "zod";
-var zImageDef = z25.object({
-  url: z25.string().url(),
-  height: z25.coerce.number().int(),
-  width: z25.coerce.number().int()
+import { z as z26 } from "zod";
+var zImageDef = z26.object({
+  url: z26.string().url(),
+  height: z26.coerce.number().int(),
+  width: z26.coerce.number().int()
 });
 
 // src/interface/reporting/reportTicket.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/interface/reporting/ticketStatus.ts
 var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
@@ -647,12 +673,12 @@ var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
 })(TicketStatus || {});
 
 // src/interface/reporting/reportTicket.ts
-var zBReportTicket = z26.object({
-  requester: z26.string(),
-  resolver: z26.string().optional(),
-  status: z26.nativeEnum(TicketStatus),
-  title: z26.string(),
-  description: z26.string()
+var zBReportTicket = z27.object({
+  requester: z27.string(),
+  resolver: z27.string().optional(),
+  status: z27.nativeEnum(TicketStatus),
+  title: z27.string(),
+  description: z27.string()
 });
 var zReportTicket = addAutoProps(zBReportTicket);
 var zReportTicketResponse = zReportTicket.extend({
@@ -661,45 +687,45 @@ var zReportTicketResponse = zReportTicket.extend({
 });
 
 // src/interface/event/eConfig.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/interface/event/eTicket.ts
-import { z as z27 } from "zod";
-var zBEventTicket = z27.object({
-  name: z27.string().min(4, "Name must be at least 4 characters"),
+import { z as z28 } from "zod";
+var zBEventTicket = z28.object({
+  name: z28.string().min(4, "Name must be at least 4 characters"),
   /**
    * Price in cents
    */
-  price: z27.coerce.number().min(0, "Price must not be negative"),
+  price: z28.coerce.number().min(0, "Price must not be negative"),
   /**
    * @optional description of the ticket
    */
-  description: z27.string().optional(),
+  description: z28.string().optional(),
   /**
    *  @optional The ticket cannot be purchased if true
    */
-  isNotBuyable: z27.boolean().optional(),
+  isNotBuyable: z28.boolean().optional(),
   /**
    *  @optional If date is provided and in the past, ticket cannot be purchased
    */
-  lastBuyableDate: z27.coerce.date().optional(),
+  lastBuyableDate: z28.coerce.date().optional(),
   /**
    *  @optional max limit is 1 unless maxPerOrder is specified
    */
-  maxPerOrder: z27.coerce.number().int().min(2).optional()
+  maxPerOrder: z28.coerce.number().int().optional()
 });
 var zEventTicket = addAutoProps(zBEventTicket);
 
 // src/interface/event/table.ts
-import { z as z28 } from "zod";
-var zTable = z28.array(z28.record(z28.string(), z28.string()));
-var zDetailsTable = z28.object({
-  fields: z28.array(z28.string()).length(2),
+import { z as z29 } from "zod";
+var zTable = z29.array(z29.record(z29.string(), z29.string()));
+var zDetailsTable = z29.object({
+  fields: z29.array(z29.string()).length(2),
   data: zTable
 });
-var zScheduleTable = z28.object({
-  fields: z28.array(z28.string()).length(2),
-  data: z28.record(z28.string(), zTable)
+var zScheduleTable = z29.object({
+  fields: z29.array(z29.string()).length(2),
+  data: z29.record(z29.string(), zTable)
 });
 
 // src/interface/event/youthOrAdult.ts
@@ -710,40 +736,40 @@ var YouthOrAdult = /* @__PURE__ */ ((YouthOrAdult2) => {
 })(YouthOrAdult || {});
 
 // src/interface/event/eConfig.ts
-var zBEventConfig = z29.object({
+var zBEventConfig = z30.object({
   /**
    * Location of the event
    */
-  location: z29.string().optional(),
+  location: z30.string().optional(),
   /**
    * URL of the tournament on the official website
    * Must be a valid URL link
    */
-  url: z29.string(),
+  url: z30.string(),
   /**
    * Full name of the tournament
    */
-  title: z29.string().min(5),
+  title: z30.string().min(5),
   /**
    * Abbreviated title of the tournament
    */
-  shortTitle: z29.string().min(2),
+  shortTitle: z30.string().min(2),
   /**
    * Tournament start date and time
    */
-  tStart: z29.coerce.date(),
+  tStart: z30.coerce.date(),
   /**
    * Tournament end date and time
    */
-  tEnd: z29.coerce.date(),
+  tEnd: z30.coerce.date(),
   /**
    * Short description for tournament card
    */
-  shortDescription: z29.string().min(5),
+  shortDescription: z30.string().min(5),
   /**
    * Full description
    */
-  description: z29.string().min(5),
+  description: z30.string().min(5),
   /**
    * Defines the tournament details table with 2 columns
    * typically Time and Event
@@ -758,30 +784,30 @@ var zBEventConfig = z29.object({
    * @optional description of the tickets step, shown in service
    * when the customer is on step 1 of the booking page
    */
-  ticketsStepDescription: z29.string().optional(),
+  ticketsStepDescription: z30.string().optional(),
   /**
    * @optional description of the participant step, shown in service
    * when the customer is on step 2 of the booking page
    */
-  participantStepDescription: z29.string().optional(),
+  participantStepDescription: z30.string().optional(),
   /**
    * List of ticket object IDs for this tournament
    */
-  tickets: z29.array(z29.string()),
+  tickets: z30.array(z30.string()),
   /**
    * If false, the tournament registration is closed
    */
-  canRegister: z29.boolean(),
+  canRegister: z30.boolean(),
   /**
    * Defines the registration of youth and adults in the event
    * youth_only - only youth
    * both - both youth and adult
    */
-  youthOrAdult: z29.nativeEnum(YouthOrAdult).optional(),
+  youthOrAdult: z30.nativeEnum(YouthOrAdult).optional(),
   /**
    * If true, free form donation amounts are disabled.
    */
-  donationsDisabled: z29.boolean().optional(),
+  donationsDisabled: z30.boolean().optional(),
   /**
    * Defines URL, height, width of the image
    */
@@ -789,42 +815,42 @@ var zBEventConfig = z29.object({
 });
 var zEventConfig = addAutoProps(zBEventConfig);
 var zEventConfigResponse = zEventConfig.extend({
-  tickets: z29.array(zEventTicket)
+  tickets: z30.array(zEventTicket)
 });
 
 // src/interface/event/eReg.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/interface/event/eTicketReg.ts
-import { z as z30 } from "zod";
-var zEventTicketReg = z30.object({
-  ticket: z30.string(),
+import { z as z31 } from "zod";
+var zEventTicketReg = z31.object({
+  ticket: z31.string(),
   /**
    * integer minimum 1, otherwise no ticket is being bought
    */
-  amount: z30.number().int().min(1)
+  amount: z31.number().int().min(1)
 });
 var zEventTicketRegResponse = zEventTicketReg.extend({
   ticket: zEventTicket
 });
 
 // src/interface/event/eReg.ts
-var zBEventReg = z31.object({
-  agaId: z31.string(),
-  tournamentId: z31.string(),
-  tickets: z31.array(zEventTicketReg),
+var zBEventReg = z32.object({
+  agaId: z32.string(),
+  tournamentId: z32.string(),
+  tickets: z32.array(zEventTicketReg),
   /**
    * @units CENTS - Donation in cents
    */
-  donation: z31.coerce.number().optional(),
+  donation: z32.coerce.number().optional(),
   /**
    * How the registration was created, through public endpoint or admin
    */
-  createMethod: z31.string().optional()
+  createMethod: z32.string().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zEventReg = addAutoProps(zBEventReg);
 var zEventRegResponse = zEventReg.extend({
-  tickets: z31.array(zEventTicketRegResponse)
+  tickets: z32.array(zEventTicketRegResponse)
 });
 export {
   AgeGroup,
@@ -865,6 +891,7 @@ export {
   zBTeacherPayment,
   zBUser,
   zBUserInfo,
+  zBUserProfile,
   zCampBooking,
   zCampTracker,
   zCampTrackerResponse,
@@ -910,5 +937,6 @@ export {
   zTrackerCreate,
   zTuition,
   zUser,
+  zUserProfile,
   zUserRoles
 };