@nyig/models 0.2.11 → 0.2.13

package/index.js

@@ -125,13 +125,14 @@ var BookingType = /* @__PURE__ */ ((BookingType2) => {
 })(BookingType || {});
 
 // src/interface/booking/campBooking.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
-// src/mongoose.ts
+// src/interface/mongoose/mongoose.ts
 var import_zod3 = require("zod");
+var import_mongoose = require("mongoose");
 function extendZodObjectForMongoose(original) {
   return original.extend({
-    _id: import_zod3.z.string(),
+    _id: import_zod3.z.instanceof(import_mongoose.Types.ObjectId),
     createdAt: import_zod3.z.coerce.date().optional(),
     updatedAt: import_zod3.z.coerce.date().optional()
   });
@@ -165,8 +166,9 @@ var CampOption = /* @__PURE__ */ ((CampOption2) => {
 })(CampOption || {});
 
 // src/interface/tracking/attendance.ts
+var import_mongoose3 = require("mongoose");
 var zAttendance = import_zod5.z.object({
-  student: import_zod5.z.string(),
+  student: import_zod5.z.instanceof(import_mongoose3.Types.ObjectId),
   states: import_zod5.z.array(import_zod5.z.nativeEnum(AttendState)),
   tuition: zTuition,
   paid: import_zod5.z.boolean().optional(),
@@ -175,37 +177,37 @@ var zAttendance = import_zod5.z.object({
 var zMAttendance = extendZodObjectForMongoose(zAttendance);
 
 // src/interface/tracking/campTracker.ts
+var import_zod7 = require("zod");
+
+// src/interface/tracking/tracker.ts
+var import_mongoose4 = require("mongoose");
 var import_zod6 = require("zod");
-var zCampTracker = import_zod6.z.object({
-  /**
-   * Mongoose object ID
-   */
-  course: import_zod6.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  teacher: import_zod6.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  semester: import_zod6.z.string(),
+var zTracker = import_zod6.z.object({
+  course: import_zod6.z.instanceof(import_mongoose4.Types.ObjectId),
+  teacher: import_zod6.z.instanceof(import_mongoose4.Types.ObjectId),
+  semester: import_zod6.z.instanceof(import_mongoose4.Types.ObjectId)
+});
+
+// src/interface/tracking/campTracker.ts
+var zCampTracker = import_zod7.z.object({
   /**
    * occurrences are tracked by week for camps
    */
-  occurrences: import_zod6.z.array(import_zod6.z.string()),
+  occurrences: import_zod7.z.array(import_zod7.z.string()),
   /**
    * attendances are tracked by week for camps
    */
-  attendances: import_zod6.z.array(import_zod6.z.string()),
-  notes: import_zod6.z.string().optional()
-});
+  attendances: import_zod7.z.array(import_zod7.z.string()),
+  notes: import_zod7.z.string().optional()
+}).merge(zTracker);
 var zMCampTracker = extendZodObjectForMongoose(zCampTracker);
 
 // src/interface/tracking/classTracker.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/interface/payment/invoice.ts
-var import_zod7 = require("zod");
+var import_mongoose6 = require("mongoose");
+var import_zod8 = require("zod");
 
 // src/interface/payment/paymentMethod.ts
 var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
@@ -217,94 +219,70 @@ var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
 })(PaymentMethod || {});
 
 // src/interface/payment/invoice.ts
-var zDiscount = import_zod7.z.object({
-  desc: import_zod7.z.string(),
-  amount: import_zod7.z.number()
+var zDiscount = import_zod8.z.object({
+  desc: import_zod8.z.string(),
+  amount: import_zod8.z.number()
 });
-var zInvoiceItem = import_zod7.z.object({
-  /**
-   * Mongoose object ID
-   */
-  course: import_zod7.z.string(),
-  price: import_zod7.z.number(),
-  units: import_zod7.z.number()
+var zInvoiceItem = import_zod8.z.object({
+  course: import_zod8.z.instanceof(import_mongoose6.Types.ObjectId),
+  price: import_zod8.z.number(),
+  units: import_zod8.z.number()
 });
-var zInvoicePackage = import_zod7.z.object({
-  /**
-   * Mongoose object ID
-   */
-  student: import_zod7.z.string(),
-  items: import_zod7.z.array(zInvoiceItem)
+var zInvoicePackage = import_zod8.z.object({
+  student: import_zod8.z.instanceof(import_mongoose6.Types.ObjectId),
+  items: import_zod8.z.array(zInvoiceItem)
 });
-var zInvoice = import_zod7.z.object({
-  billTo: import_zod7.z.string(),
-  packages: import_zod7.z.array(zInvoicePackage),
-  discounts: import_zod7.z.array(zDiscount),
-  textbook: import_zod7.z.number().int().min(1).optional(),
-  shipping: import_zod7.z.number().int().min(1).optional(),
-  paid: import_zod7.z.nativeEnum(PaymentMethod).optional(),
-  notes: import_zod7.z.string().optional(),
-  /**
-   * Mongoose object ID
-   */
-  createdBy: import_zod7.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  lastEditBy: import_zod7.z.string().optional()
+var zInvoice = import_zod8.z.object({
+  billTo: import_zod8.z.string(),
+  packages: import_zod8.z.array(zInvoicePackage),
+  discounts: import_zod8.z.array(zDiscount),
+  textbook: import_zod8.z.number().int().min(1).optional(),
+  shipping: import_zod8.z.number().int().min(1).optional(),
+  paid: import_zod8.z.nativeEnum(PaymentMethod).optional(),
+  notes: import_zod8.z.string().optional(),
+  createdBy: import_zod8.z.instanceof(import_mongoose6.Types.ObjectId),
+  lastEditBy: import_zod8.z.instanceof(import_mongoose6.Types.ObjectId).optional()
 });
 var zMInvoice = extendZodObjectForMongoose(zInvoice);
 
 // src/interface/payment/teacherPayment.ts
-var import_zod8 = require("zod");
-var zTeacherPaymentRow = import_zod8.z.object({
-  course: import_zod8.z.string(),
-  length: import_zod8.z.number(),
-  count: import_zod8.z.number(),
-  wage: import_zod8.z.number()
+var import_zod9 = require("zod");
+var zTeacherPaymentRow = import_zod9.z.object({
+  course: import_zod9.z.string(),
+  length: import_zod9.z.number(),
+  count: import_zod9.z.number(),
+  wage: import_zod9.z.number()
 });
-var zTeacherPayment = import_zod8.z.object({
-  teacher: import_zod8.z.string(),
-  rows: import_zod8.z.array(zTeacherPaymentRow),
-  paid: import_zod8.z.boolean().optional()
+var zTeacherPayment = import_zod9.z.object({
+  teacher: import_zod9.z.string(),
+  rows: import_zod9.z.array(zTeacherPaymentRow),
+  paid: import_zod9.z.boolean().optional()
 });
 var zMTeacherPayment = extendZodObjectForMongoose(zTeacherPayment);
 
 // src/interface/tracking/classTracker.ts
-var zClassTracker = import_zod9.z.object({
-  /**
-   * Mongoose object ID
-   */
-  course: import_zod9.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  teacher: import_zod9.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  semester: import_zod9.z.string(),
-  classTimes: import_zod9.z.array(import_zod9.z.coerce.date()),
-  completedList: import_zod9.z.array(import_zod9.z.boolean()),
+var zClassTracker = import_zod10.z.object({
+  classTimes: import_zod10.z.array(import_zod10.z.coerce.date()),
+  completedList: import_zod10.z.array(import_zod10.z.boolean()),
   /**
    * Virtual mongoose field when all values in completedList is true
    */
-  completed: import_zod9.z.boolean().optional(),
+  completed: import_zod10.z.boolean().optional(),
   tuition: zTuition.optional(),
-  paid: import_zod9.z.boolean().optional(),
-  notes: import_zod9.z.string().optional()
-});
+  paid: import_zod10.z.boolean().optional(),
+  notes: import_zod10.z.string().optional()
+}).merge(zTracker);
 var zMClassTracker = extendZodObjectForMongoose(zClassTracker);
 
 // src/interface/tracking/groupTracker.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/interface/tracking/scheduleData.ts
-var import_zod10 = require("zod");
-var zScheduleData = import_zod10.z.object({
-  startTime: import_zod10.z.string(),
+var import_zod11 = require("zod");
+var zScheduleData = import_zod11.z.object({
+  startTime: import_zod11.z.string(),
   // String in 24 hour "HH:mm" format
-  dayOfWeek: import_zod10.z.number().int().min(0).max(6)
+  dayOfWeek: import_zod11.z.number().int().min(0).max(6)
   // integeters in 0 - 6
 });
 
@@ -333,138 +311,126 @@ var NYIGSchool = /* @__PURE__ */ ((NYIGSchool2) => {
 })(NYIGSchool || {});
 
 // src/interface/course/course.ts
-var import_zod11 = require("zod");
-var zCourse = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  category: import_zod11.z.nativeEnum(CourseCategory),
+var import_zod12 = require("zod");
+var zCourse = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  category: import_zod12.z.nativeEnum(CourseCategory),
   /**
    * @unit SECONDS - Duration of the course in seconds
    */
-  duration: import_zod11.z.number(),
+  duration: import_zod12.z.number(),
   /**
    * @unit CENTS - Price of the course in cents
    */
-  price: import_zod11.z.number(),
-  description: import_zod11.z.string().optional(),
+  price: import_zod12.z.number(),
+  description: import_zod12.z.string().optional(),
   /**
    * NYIG School locations
    */
-  nyigSchool: import_zod11.z.nativeEnum(NYIGSchool),
+  nyigSchool: import_zod12.z.nativeEnum(NYIGSchool),
   /**
    * Recommended level before taking this course
    */
-  recLevel: import_zod11.z.string(),
+  recLevel: import_zod12.z.string(),
   /**
    * Camp tuition for half-day option
    */
-  halfCampTuition: import_zod11.z.number(),
+  halfCampTuition: import_zod12.z.number(),
   /**
    * Camp tuition for full-day option
    */
-  fullCampTuition: import_zod11.z.number()
+  fullCampTuition: import_zod12.z.number()
 });
 var zMCourse = extendZodObjectForMongoose(zCourse);
 
 // src/interface/tracking/groupTracker.ts
-var zGroupTracker = import_zod12.z.object({
-  /**
-   * Mongoose object ID
-   */
-  course: import_zod12.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  teacher: import_zod12.z.string(),
-  /**
-   * Mongoose object ID
-   */
-  semester: import_zod12.z.string(),
+var zGroupTracker = import_zod13.z.object({
   scheduleData: zScheduleData,
   /**
    * occurrences are tracked by week for Groups
    */
-  occurrences: import_zod12.z.array(import_zod12.z.coerce.date()),
+  occurrences: import_zod13.z.array(import_zod13.z.coerce.date()),
   /**
    * attendances are tracked by week for Groups
    */
-  attendances: import_zod12.z.array(import_zod12.z.string()),
+  attendances: import_zod13.z.array(import_zod13.z.string()),
   /**
-   * ID of the course instance, e.g., 101
+   * public-facing ID of the course instance, e.g., 101
    */
-  courseId: import_zod12.z.string().optional(),
+  courseId: import_zod13.z.string().optional(),
   /**
    * Age group of the class instance, e.g. "adult", "youth"
    */
-  ageGroup: import_zod12.z.nativeEnum(AgeGroup).optional(),
+  ageGroup: import_zod13.z.nativeEnum(AgeGroup).optional(),
   /**
    * If true, the course is hidden from public view
    */
-  isNonPublic: import_zod12.z.boolean().optional(),
-  notes: import_zod12.z.string().optional()
-});
+  isNonPublic: import_zod13.z.boolean().optional(),
+  notes: import_zod13.z.string().optional()
+}).merge(zTracker);
 var zMGroupTracker = extendZodObjectForMongoose(zGroupTracker);
 
 // src/interface/booking/campBooking.ts
-var zCampBooking = import_zod13.z.object({
-  userId: import_zod13.z.string().optional(),
-  ctId: import_zod13.z.string().optional(),
-  isOnline: import_zod13.z.boolean(),
-  classDates: import_zod13.z.string(),
-  campOption: import_zod13.z.nativeEnum(CampOption),
-  shipping: import_zod13.z.boolean().optional()
+var zCampBooking = import_zod14.z.object({
+  userId: import_zod14.z.string().optional(),
+  ctId: import_zod14.z.string().optional(),
+  isOnline: import_zod14.z.boolean(),
+  classDates: import_zod14.z.string(),
+  campOption: import_zod14.z.nativeEnum(CampOption),
+  shipping: import_zod14.z.boolean().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMCampBooking = extendZodObjectForMongoose(zCampBooking);
 
 // src/interface/booking/groupBooking.ts
-var import_zod14 = require("zod");
-var zGroupBooking = import_zod14.z.object({
-  userId: import_zod14.z.string().optional(),
-  gtId: import_zod14.z.string().optional(),
-  isTrial: import_zod14.z.boolean().optional(),
-  isOnline: import_zod14.z.boolean(),
-  classDate: import_zod14.z.string().optional(),
-  shipping: import_zod14.z.boolean().optional()
+var import_zod15 = require("zod");
+var zGroupBooking = import_zod15.z.object({
+  userId: import_zod15.z.string().optional(),
+  gtId: import_zod15.z.string().optional(),
+  isTrial: import_zod15.z.boolean().optional(),
+  isOnline: import_zod15.z.boolean(),
+  classDate: import_zod15.z.string().optional(),
+  shipping: import_zod15.z.boolean().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMGroupBooking = extendZodObjectForMongoose(zGroupBooking);
 
 // src/interface/booking/privateBooking.ts
-var import_zod15 = require("zod");
-var zPrivateBooking = import_zod15.z.object({
-  userId: import_zod15.z.string().optional(),
-  courseId: import_zod15.z.string(),
-  teacherId: import_zod15.z.string(),
-  classDate: import_zod15.z.string().optional()
+var import_zod16 = require("zod");
+var zPrivateBooking = import_zod16.z.object({
+  userId: import_zod16.z.string().optional(),
+  courseId: import_zod16.z.string(),
+  teacherId: import_zod16.z.string(),
+  classDate: import_zod16.z.string().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMPrivateBooking = extendZodObjectForMongoose(zPrivateBooking);
 
 // src/interface/public/aurora.ts
-var import_zod16 = require("zod");
-var zTeacherDisplay = import_zod16.z.object({
-  name: import_zod16.z.string(),
-  email: import_zod16.z.string().email(),
-  title: import_zod16.z.string(),
-  imageUrl: import_zod16.z.string(),
-  bio: import_zod16.z.string()
+var import_zod17 = require("zod");
+var zTeacherDisplay = import_zod17.z.object({
+  name: import_zod17.z.string(),
+  email: import_zod17.z.string().email(),
+  title: import_zod17.z.string(),
+  imageUrl: import_zod17.z.string(),
+  bio: import_zod17.z.string()
 });
-var zCourseTable = import_zod16.z.object({
-  id: import_zod16.z.string(),
-  name: import_zod16.z.string(),
-  duration: import_zod16.z.number(),
-  dateAndTime: import_zod16.z.string(),
-  recommendedLevel: import_zod16.z.string(),
-  tuition: import_zod16.z.string()
+var zCourseTable = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  name: import_zod17.z.string(),
+  duration: import_zod17.z.number(),
+  dateAndTime: import_zod17.z.string(),
+  recommendedLevel: import_zod17.z.string(),
+  tuition: import_zod17.z.string()
 });
 
 // src/interface/public/imageDef.ts
-var import_zod17 = require("zod");
-var zImageDef = import_zod17.z.object({
-  url: import_zod17.z.string(),
-  height: import_zod17.z.number(),
-  width: import_zod17.z.number()
+var import_zod18 = require("zod");
+var zImageDef = import_zod18.z.object({
+  url: import_zod18.z.string(),
+  height: import_zod18.z.number(),
+  width: import_zod18.z.number()
 });
 
 // src/interface/reporting/reportTicket.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/interface/reporting/ticketStatus.ts
 var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
@@ -476,12 +442,12 @@ var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
 })(TicketStatus || {});
 
 // src/interface/reporting/reportTicket.ts
-var zReportTicket = import_zod18.z.object({
-  requester: import_zod18.z.string(),
-  resolver: import_zod18.z.string(),
-  status: import_zod18.z.nativeEnum(TicketStatus),
-  title: import_zod18.z.string(),
-  description: import_zod18.z.string()
+var zReportTicket = import_zod19.z.object({
+  requester: import_zod19.z.string(),
+  resolver: import_zod19.z.string(),
+  status: import_zod19.z.nativeEnum(TicketStatus),
+  title: import_zod19.z.string(),
+  description: import_zod19.z.string()
 });
 var zMReportTicket = extendZodObjectForMongoose(zReportTicket);
 
@@ -494,73 +460,74 @@ var Season = /* @__PURE__ */ ((Season2) => {
 })(Season || {});
 
 // src/interface/semester/semester.ts
-var import_zod19 = require("zod");
-var zSemester = import_zod19.z.object({
-  season: import_zod19.z.nativeEnum(Season),
-  year: import_zod19.z.number().min(2022).max(2999),
-  startDate: import_zod19.z.coerce.date(),
-  endDate: import_zod19.z.coerce.date(),
+var import_zod20 = require("zod");
+var zSemester = import_zod20.z.object({
+  season: import_zod20.z.nativeEnum(Season),
+  year: import_zod20.z.number().min(2022).max(2999),
+  startDate: import_zod20.z.coerce.date(),
+  endDate: import_zod20.z.coerce.date(),
   /**
    * Format: start, end, start, end, ...
    */
-  blackoutDates: import_zod19.z.array(import_zod19.z.coerce.date()),
+  blackoutDates: import_zod20.z.array(import_zod20.z.coerce.date()),
   /**
    * List of names of some break: date range
    */
-  importantDates: import_zod19.z.array(import_zod19.z.string())
+  importantDates: import_zod20.z.array(import_zod20.z.string())
 });
 var zMSemester = extendZodObjectForMongoose(zSemester);
 
 // src/interface/tournament/tConfig.ts
-var import_zod21 = require("zod");
+var import_mongoose17 = require("mongoose");
+var import_zod22 = require("zod");
 
 // src/interface/tournament/table.ts
-var import_zod20 = require("zod");
-var zTable = import_zod20.z.array(import_zod20.z.object({}));
-var zDetailsTable = import_zod20.z.object({
-  fields: import_zod20.z.array(import_zod20.z.string()).length(2),
+var import_zod21 = require("zod");
+var zTable = import_zod21.z.array(import_zod21.z.object({}));
+var zDetailsTable = import_zod21.z.object({
+  fields: import_zod21.z.array(import_zod21.z.string()).length(2),
   data: zTable
 });
-var zScheduleTable = import_zod20.z.object({
-  fields: import_zod20.z.array(import_zod20.z.string()).length(2),
-  data: import_zod20.z.map(import_zod20.z.string(), zTable)
+var zScheduleTable = import_zod21.z.object({
+  fields: import_zod21.z.array(import_zod21.z.string()).length(2),
+  data: import_zod21.z.map(import_zod21.z.string(), zTable)
 });
 
 // src/interface/tournament/tConfig.ts
-var zTConfig = import_zod21.z.object({
+var zTConfig = import_zod22.z.object({
   /**
    * Location of the event
    */
-  location: import_zod21.z.string().optional(),
+  location: import_zod22.z.string().optional(),
   /**
    * URL of the tournament on the official website
    * Must be a valid URL link
    */
-  url: import_zod21.z.string(),
+  url: import_zod22.z.string(),
   /**
    * Full name of the tournament
    */
-  title: import_zod21.z.string(),
+  title: import_zod22.z.string(),
   /**
    * Abbreviated title of the tournament
    */
-  shortTitle: import_zod21.z.string(),
+  shortTitle: import_zod22.z.string(),
   /**
    * Tournament start date and time
    */
-  tStart: import_zod21.z.coerce.date(),
+  tStart: import_zod22.z.coerce.date(),
   /**
    * Tournament end date and time
    */
-  tEnd: import_zod21.z.coerce.date(),
+  tEnd: import_zod22.z.coerce.date(),
   /**
    * Short description for tournament card
    */
-  shortDescription: import_zod21.z.string(),
+  shortDescription: import_zod22.z.string(),
   /**
    * Full description
    */
-  description: import_zod21.z.string(),
+  description: import_zod22.z.string(),
   /**
    * Defines the tournament details table with 2 columns
    * typically Time and Event
@@ -574,15 +541,15 @@ var zTConfig = import_zod21.z.object({
   /**
    * List of ticket object IDs for this tournament
    */
-  tickets: import_zod21.z.array(import_zod21.z.string()),
+  tickets: import_zod22.z.array(import_zod22.z.instanceof(import_mongoose17.Types.ObjectId)),
   /**
    * If false, the tournament registration is closed
    */
-  canRegister: import_zod21.z.boolean(),
+  canRegister: import_zod22.z.boolean(),
   /**
    * If true, free form donation amounts are disabled.
    */
-  donationsDisabled: import_zod21.z.boolean().optional(),
+  donationsDisabled: import_zod22.z.boolean().optional(),
   /**
    * Defines URL, height, width of the image
    */
@@ -591,64 +558,60 @@ var zTConfig = import_zod21.z.object({
 var zMTConfig = extendZodObjectForMongoose(zTConfig);
 
 // src/interface/tournament/tReg.ts
-var import_zod23 = require("zod");
+var import_mongoose20 = require("mongoose");
+var import_zod24 = require("zod");
 
 // src/interface/tournament/tTicketReg.ts
-var import_zod22 = require("zod");
-var zTTicketReg = import_zod22.z.object({
-  /**
-   * Mongoose ID of the ticket
-   */
-  ticket: import_zod22.z.string(),
+var import_zod23 = require("zod");
+var import_mongoose19 = require("mongoose");
+var zTTicketReg = import_zod23.z.object({
+  ticket: import_zod23.z.instanceof(import_mongoose19.Types.ObjectId),
   /**
    * integer minimum 1, otherwise no ticket is being bought
    */
-  amount: import_zod22.z.number().int().min(1)
+  amount: import_zod23.z.number().int().min(1)
 });
 
 // src/interface/tournament/tReg.ts
-var zTReg = import_zod23.z.object({
-  agaId: import_zod23.z.string(),
-  /**
-   * Mongoose ID of the tournament that the participant is registering for
-   */
-  tournamentId: import_zod23.z.string(),
-  tickets: import_zod23.z.array(zTTicketReg),
+var zTReg = import_zod24.z.object({
+  agaId: import_zod24.z.string(),
+  tournamentId: import_zod24.z.instanceof(import_mongoose20.Types.ObjectId),
+  tickets: import_zod24.z.array(zTTicketReg),
   /**
    * @units CENTS - Donation in cents
    */
-  donation: import_zod23.z.number().optional(),
+  donation: import_zod24.z.number().optional(),
   /**
    * How the registration was created, namely through public endpoint or admin
    */
-  createMethod: import_zod23.z.string().optional(),
+  createMethod: import_zod24.z.string().optional(),
   /**
    * Mongoose ID of the admin that edited the registration
    */
-  edited: import_zod23.z.string().optional()
+  edited: import_zod24.z.instanceof(import_mongoose20.Types.ObjectId).optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMTReg = extendZodObjectForMongoose(zTReg);
 
 // src/interface/tournament/tTicket.ts
-var import_zod24 = require("zod");
-var zTTicket = import_zod24.z.object({
-  name: import_zod24.z.string(),
+var import_zod25 = require("zod");
+var zTTicket = import_zod25.z.object({
+  name: import_zod25.z.string(),
   /**
    * Price in cents
    */
-  price: import_zod24.z.number(),
+  price: import_zod25.z.number(),
   /**
    * @optional description of the ticket
    */
-  description: import_zod24.z.string().optional(),
+  description: import_zod25.z.string().optional(),
   /**
    *  @optional The ticket cannot be purchased if true
    */
-  isNotBuyable: import_zod24.z.boolean().optional(),
+  isNotBuyable: import_zod25.z.boolean().optional(),
   /**
    *  @optional If date is provided and in the past, ticket cannot be purchased
    */
-  lastBuyableDate: import_zod24.z.coerce.date().optional()
+  lastBuyableDate: import_zod25.z.coerce.date().optional()
 });
 var zMTTicket = extendZodObjectForMongoose(zTTicket);
 
@@ -699,50 +662,50 @@ var GoRank = /* @__PURE__ */ ((GoRank2) => {
 })(GoRank || {});
 
 // src/interface/user/user.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // src/interface/user/userRoles.ts
-var import_zod25 = require("zod");
-var zUserRoles = import_zod25.z.object({
-  user: import_zod25.z.number().int(),
-  admin: import_zod25.z.number().int(),
-  superadmin: import_zod25.z.number().int()
+var import_zod26 = require("zod");
+var zUserRoles = import_zod26.z.object({
+  user: import_zod26.z.number().int(),
+  admin: import_zod26.z.number().int(),
+  superadmin: import_zod26.z.number().int()
 });
 
 // src/interface/user/user.ts
-var zUser = import_zod26.z.object({
-  name: import_zod26.z.string().min(2).max(100),
-  username: import_zod26.z.string().optional(),
-  password: import_zod26.z.string().optional(),
+var import_mongoose24 = require("mongoose");
+var zUser = import_zod27.z.object({
+  name: import_zod27.z.string().min(2).max(100),
+  username: import_zod27.z.string().optional(),
+  password: import_zod27.z.string().optional(),
   roles: zUserRoles.optional(),
-  email: import_zod26.z.string().email().max(100).optional(),
-  address: import_zod26.z.string().optional(),
-  country: import_zod26.z.string().optional(),
-  phoneNumber: import_zod26.z.string().optional(),
-  birthDate: import_zod26.z.string().optional()
+  email: import_zod27.z.string().email().max(100).optional(),
+  address: import_zod27.z.string().optional(),
+  country: import_zod27.z.string().optional(),
+  phoneNumber: import_zod27.z.string().optional(),
+  birthDate: import_zod27.z.string().optional()
 });
 var zMUser = extendZodObjectForMongoose(zUser);
 var zStudent = zUser.extend({
-  rank: import_zod26.z.nativeEnum(GoRank),
-  // Object ID in mongoose linked to a user
-  guardian: import_zod26.z.string().optional()
+  rank: import_zod27.z.nativeEnum(GoRank),
+  guardian: import_zod27.z.instanceof(import_mongoose24.Types.ObjectId).optional()
 });
 var zMStudent = extendZodObjectForMongoose(zStudent);
 var zTeacher = zUser.extend({
-  rank: import_zod26.z.nativeEnum(GoRank),
+  rank: import_zod27.z.nativeEnum(GoRank),
   /**
    * Inactive teachers are not shown on public endpoints
    */
-  isInactive: import_zod26.z.boolean().optional(),
+  isInactive: import_zod27.z.boolean().optional(),
   /**
    * Teacher's position, e.g., instructor, president
    */
-  title: import_zod26.z.string().optional(),
+  title: import_zod27.z.string().optional(),
   /**
    * Teacher's bio text describing experience
    * new lines will be rendered as paragraphs
    */
-  bio: import_zod26.z.string().optional(),
+  bio: import_zod27.z.string().optional(),
   /** Format is illustrated below, where teacher is available
    * Mon 9-12am 3-6pm & Tue 10-12am 6-10pm
    * [
@@ -755,7 +718,7 @@ var zTeacher = zUser.extend({
    *  [],
    * ]
    */
-  available: import_zod26.z.array(import_zod26.z.array(import_zod26.z.array(import_zod26.z.number()))).optional()
+  available: import_zod27.z.array(import_zod27.z.array(import_zod27.z.array(import_zod27.z.number()))).optional()
 });
 var zMTeacher = extendZodObjectForMongoose(zTeacher);
 // Annotate the CommonJS export names for ESM import in node: