@nyig/models 0.2.11 → 0.2.13

package/index.mjs

@@ -39,13 +39,14 @@ var BookingType = /* @__PURE__ */ ((BookingType2) => {
 })(BookingType || {});
 
 // src/interface/booking/campBooking.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
-// src/mongoose.ts
+// src/interface/mongoose/mongoose.ts
 import { z as z3 } from "zod";
+import { Types } from "mongoose";
 function extendZodObjectForMongoose(original) {
   return original.extend({
-    _id: z3.string(),
+    _id: z3.instanceof(Types.ObjectId),
     createdAt: z3.coerce.date().optional(),
     updatedAt: z3.coerce.date().optional()
   });
@@ -79,8 +80,9 @@ var CampOption = /* @__PURE__ */ ((CampOption2) => {
 })(CampOption || {});
 
 // src/interface/tracking/attendance.ts
+import { Types as Types2 } from "mongoose";
 var zAttendance = z5.object({
-  student: z5.string(),
+  student: z5.instanceof(Types2.ObjectId),
   states: z5.array(z5.nativeEnum(AttendState)),
   tuition: zTuition,
   paid: z5.boolean().optional(),
@@ -89,37 +91,37 @@ var zAttendance = z5.object({
 var zMAttendance = extendZodObjectForMongoose(zAttendance);
 
 // src/interface/tracking/campTracker.ts
+import { z as z7 } from "zod";
+
+// src/interface/tracking/tracker.ts
+import { Types as Types3 } from "mongoose";
 import { z as z6 } from "zod";
-var zCampTracker = z6.object({
-  /**
-   * Mongoose object ID
-   */
-  course: z6.string(),
-  /**
-   * Mongoose object ID
-   */
-  teacher: z6.string(),
-  /**
-   * Mongoose object ID
-   */
-  semester: z6.string(),
+var zTracker = z6.object({
+  course: z6.instanceof(Types3.ObjectId),
+  teacher: z6.instanceof(Types3.ObjectId),
+  semester: z6.instanceof(Types3.ObjectId)
+});
+
+// src/interface/tracking/campTracker.ts
+var zCampTracker = z7.object({
   /**
    * occurrences are tracked by week for camps
    */
-  occurrences: z6.array(z6.string()),
+  occurrences: z7.array(z7.string()),
   /**
    * attendances are tracked by week for camps
    */
-  attendances: z6.array(z6.string()),
-  notes: z6.string().optional()
-});
+  attendances: z7.array(z7.string()),
+  notes: z7.string().optional()
+}).merge(zTracker);
 var zMCampTracker = extendZodObjectForMongoose(zCampTracker);
 
 // src/interface/tracking/classTracker.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/interface/payment/invoice.ts
-import { z as z7 } from "zod";
+import { Types as Types4 } from "mongoose";
+import { z as z8 } from "zod";
 
 // src/interface/payment/paymentMethod.ts
 var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
@@ -131,94 +133,70 @@ var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
 })(PaymentMethod || {});
 
 // src/interface/payment/invoice.ts
-var zDiscount = z7.object({
-  desc: z7.string(),
-  amount: z7.number()
+var zDiscount = z8.object({
+  desc: z8.string(),
+  amount: z8.number()
 });
-var zInvoiceItem = z7.object({
-  /**
-   * Mongoose object ID
-   */
-  course: z7.string(),
-  price: z7.number(),
-  units: z7.number()
+var zInvoiceItem = z8.object({
+  course: z8.instanceof(Types4.ObjectId),
+  price: z8.number(),
+  units: z8.number()
 });
-var zInvoicePackage = z7.object({
-  /**
-   * Mongoose object ID
-   */
-  student: z7.string(),
-  items: z7.array(zInvoiceItem)
+var zInvoicePackage = z8.object({
+  student: z8.instanceof(Types4.ObjectId),
+  items: z8.array(zInvoiceItem)
 });
-var zInvoice = z7.object({
-  billTo: z7.string(),
-  packages: z7.array(zInvoicePackage),
-  discounts: z7.array(zDiscount),
-  textbook: z7.number().int().min(1).optional(),
-  shipping: z7.number().int().min(1).optional(),
-  paid: z7.nativeEnum(PaymentMethod).optional(),
-  notes: z7.string().optional(),
-  /**
-   * Mongoose object ID
-   */
-  createdBy: z7.string(),
-  /**
-   * Mongoose object ID
-   */
-  lastEditBy: z7.string().optional()
+var zInvoice = z8.object({
+  billTo: z8.string(),
+  packages: z8.array(zInvoicePackage),
+  discounts: z8.array(zDiscount),
+  textbook: z8.number().int().min(1).optional(),
+  shipping: z8.number().int().min(1).optional(),
+  paid: z8.nativeEnum(PaymentMethod).optional(),
+  notes: z8.string().optional(),
+  createdBy: z8.instanceof(Types4.ObjectId),
+  lastEditBy: z8.instanceof(Types4.ObjectId).optional()
 });
 var zMInvoice = extendZodObjectForMongoose(zInvoice);
 
 // src/interface/payment/teacherPayment.ts
-import { z as z8 } from "zod";
-var zTeacherPaymentRow = z8.object({
-  course: z8.string(),
-  length: z8.number(),
-  count: z8.number(),
-  wage: z8.number()
+import { z as z9 } from "zod";
+var zTeacherPaymentRow = z9.object({
+  course: z9.string(),
+  length: z9.number(),
+  count: z9.number(),
+  wage: z9.number()
 });
-var zTeacherPayment = z8.object({
-  teacher: z8.string(),
-  rows: z8.array(zTeacherPaymentRow),
-  paid: z8.boolean().optional()
+var zTeacherPayment = z9.object({
+  teacher: z9.string(),
+  rows: z9.array(zTeacherPaymentRow),
+  paid: z9.boolean().optional()
 });
 var zMTeacherPayment = extendZodObjectForMongoose(zTeacherPayment);
 
 // src/interface/tracking/classTracker.ts
-var zClassTracker = z9.object({
-  /**
-   * Mongoose object ID
-   */
-  course: z9.string(),
-  /**
-   * Mongoose object ID
-   */
-  teacher: z9.string(),
-  /**
-   * Mongoose object ID
-   */
-  semester: z9.string(),
-  classTimes: z9.array(z9.coerce.date()),
-  completedList: z9.array(z9.boolean()),
+var zClassTracker = z10.object({
+  classTimes: z10.array(z10.coerce.date()),
+  completedList: z10.array(z10.boolean()),
   /**
    * Virtual mongoose field when all values in completedList is true
    */
-  completed: z9.boolean().optional(),
+  completed: z10.boolean().optional(),
   tuition: zTuition.optional(),
-  paid: z9.boolean().optional(),
-  notes: z9.string().optional()
-});
+  paid: z10.boolean().optional(),
+  notes: z10.string().optional()
+}).merge(zTracker);
 var zMClassTracker = extendZodObjectForMongoose(zClassTracker);
 
 // src/interface/tracking/groupTracker.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/interface/tracking/scheduleData.ts
-import { z as z10 } from "zod";
-var zScheduleData = z10.object({
-  startTime: z10.string(),
+import { z as z11 } from "zod";
+var zScheduleData = z11.object({
+  startTime: z11.string(),
   // String in 24 hour "HH:mm" format
-  dayOfWeek: z10.number().int().min(0).max(6)
+  dayOfWeek: z11.number().int().min(0).max(6)
   // integeters in 0 - 6
 });
 
@@ -247,138 +225,126 @@ var NYIGSchool = /* @__PURE__ */ ((NYIGSchool2) => {
 })(NYIGSchool || {});
 
 // src/interface/course/course.ts
-import { z as z11 } from "zod";
-var zCourse = z11.object({
-  name: z11.string(),
-  category: z11.nativeEnum(CourseCategory),
+import { z as z12 } from "zod";
+var zCourse = z12.object({
+  name: z12.string(),
+  category: z12.nativeEnum(CourseCategory),
   /**
    * @unit SECONDS - Duration of the course in seconds
    */
-  duration: z11.number(),
+  duration: z12.number(),
   /**
    * @unit CENTS - Price of the course in cents
    */
-  price: z11.number(),
-  description: z11.string().optional(),
+  price: z12.number(),
+  description: z12.string().optional(),
   /**
    * NYIG School locations
    */
-  nyigSchool: z11.nativeEnum(NYIGSchool),
+  nyigSchool: z12.nativeEnum(NYIGSchool),
   /**
    * Recommended level before taking this course
    */
-  recLevel: z11.string(),
+  recLevel: z12.string(),
   /**
    * Camp tuition for half-day option
    */
-  halfCampTuition: z11.number(),
+  halfCampTuition: z12.number(),
   /**
    * Camp tuition for full-day option
    */
-  fullCampTuition: z11.number()
+  fullCampTuition: z12.number()
 });
 var zMCourse = extendZodObjectForMongoose(zCourse);
 
 // src/interface/tracking/groupTracker.ts
-var zGroupTracker = z12.object({
-  /**
-   * Mongoose object ID
-   */
-  course: z12.string(),
-  /**
-   * Mongoose object ID
-   */
-  teacher: z12.string(),
-  /**
-   * Mongoose object ID
-   */
-  semester: z12.string(),
+var zGroupTracker = z13.object({
   scheduleData: zScheduleData,
   /**
    * occurrences are tracked by week for Groups
    */
-  occurrences: z12.array(z12.coerce.date()),
+  occurrences: z13.array(z13.coerce.date()),
   /**
    * attendances are tracked by week for Groups
    */
-  attendances: z12.array(z12.string()),
+  attendances: z13.array(z13.string()),
   /**
-   * ID of the course instance, e.g., 101
+   * public-facing ID of the course instance, e.g., 101
    */
-  courseId: z12.string().optional(),
+  courseId: z13.string().optional(),
   /**
    * Age group of the class instance, e.g. "adult", "youth"
    */
-  ageGroup: z12.nativeEnum(AgeGroup).optional(),
+  ageGroup: z13.nativeEnum(AgeGroup).optional(),
   /**
    * If true, the course is hidden from public view
    */
-  isNonPublic: z12.boolean().optional(),
-  notes: z12.string().optional()
-});
+  isNonPublic: z13.boolean().optional(),
+  notes: z13.string().optional()
+}).merge(zTracker);
 var zMGroupTracker = extendZodObjectForMongoose(zGroupTracker);
 
 // src/interface/booking/campBooking.ts
-var zCampBooking = z13.object({
-  userId: z13.string().optional(),
-  ctId: z13.string().optional(),
-  isOnline: z13.boolean(),
-  classDates: z13.string(),
-  campOption: z13.nativeEnum(CampOption),
-  shipping: z13.boolean().optional()
+var zCampBooking = z14.object({
+  userId: z14.string().optional(),
+  ctId: z14.string().optional(),
+  isOnline: z14.boolean(),
+  classDates: z14.string(),
+  campOption: z14.nativeEnum(CampOption),
+  shipping: z14.boolean().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMCampBooking = extendZodObjectForMongoose(zCampBooking);
 
 // src/interface/booking/groupBooking.ts
-import { z as z14 } from "zod";
-var zGroupBooking = z14.object({
-  userId: z14.string().optional(),
-  gtId: z14.string().optional(),
-  isTrial: z14.boolean().optional(),
-  isOnline: z14.boolean(),
-  classDate: z14.string().optional(),
-  shipping: z14.boolean().optional()
+import { z as z15 } from "zod";
+var zGroupBooking = z15.object({
+  userId: z15.string().optional(),
+  gtId: z15.string().optional(),
+  isTrial: z15.boolean().optional(),
+  isOnline: z15.boolean(),
+  classDate: z15.string().optional(),
+  shipping: z15.boolean().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMGroupBooking = extendZodObjectForMongoose(zGroupBooking);
 
 // src/interface/booking/privateBooking.ts
-import { z as z15 } from "zod";
-var zPrivateBooking = z15.object({
-  userId: z15.string().optional(),
-  courseId: z15.string(),
-  teacherId: z15.string(),
-  classDate: z15.string().optional()
+import { z as z16 } from "zod";
+var zPrivateBooking = z16.object({
+  userId: z16.string().optional(),
+  courseId: z16.string(),
+  teacherId: z16.string(),
+  classDate: z16.string().optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMPrivateBooking = extendZodObjectForMongoose(zPrivateBooking);
 
 // src/interface/public/aurora.ts
-import { z as z16 } from "zod";
-var zTeacherDisplay = z16.object({
-  name: z16.string(),
-  email: z16.string().email(),
-  title: z16.string(),
-  imageUrl: z16.string(),
-  bio: z16.string()
+import { z as z17 } from "zod";
+var zTeacherDisplay = z17.object({
+  name: z17.string(),
+  email: z17.string().email(),
+  title: z17.string(),
+  imageUrl: z17.string(),
+  bio: z17.string()
 });
-var zCourseTable = z16.object({
-  id: z16.string(),
-  name: z16.string(),
-  duration: z16.number(),
-  dateAndTime: z16.string(),
-  recommendedLevel: z16.string(),
-  tuition: z16.string()
+var zCourseTable = z17.object({
+  id: z17.string(),
+  name: z17.string(),
+  duration: z17.number(),
+  dateAndTime: z17.string(),
+  recommendedLevel: z17.string(),
+  tuition: z17.string()
 });
 
 // src/interface/public/imageDef.ts
-import { z as z17 } from "zod";
-var zImageDef = z17.object({
-  url: z17.string(),
-  height: z17.number(),
-  width: z17.number()
+import { z as z18 } from "zod";
+var zImageDef = z18.object({
+  url: z18.string(),
+  height: z18.number(),
+  width: z18.number()
 });
 
 // src/interface/reporting/reportTicket.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/interface/reporting/ticketStatus.ts
 var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
@@ -390,12 +356,12 @@ var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
 })(TicketStatus || {});
 
 // src/interface/reporting/reportTicket.ts
-var zReportTicket = z18.object({
-  requester: z18.string(),
-  resolver: z18.string(),
-  status: z18.nativeEnum(TicketStatus),
-  title: z18.string(),
-  description: z18.string()
+var zReportTicket = z19.object({
+  requester: z19.string(),
+  resolver: z19.string(),
+  status: z19.nativeEnum(TicketStatus),
+  title: z19.string(),
+  description: z19.string()
 });
 var zMReportTicket = extendZodObjectForMongoose(zReportTicket);
 
@@ -408,73 +374,74 @@ var Season = /* @__PURE__ */ ((Season2) => {
 })(Season || {});
 
 // src/interface/semester/semester.ts
-import { z as z19 } from "zod";
-var zSemester = z19.object({
-  season: z19.nativeEnum(Season),
-  year: z19.number().min(2022).max(2999),
-  startDate: z19.coerce.date(),
-  endDate: z19.coerce.date(),
+import { z as z20 } from "zod";
+var zSemester = z20.object({
+  season: z20.nativeEnum(Season),
+  year: z20.number().min(2022).max(2999),
+  startDate: z20.coerce.date(),
+  endDate: z20.coerce.date(),
   /**
    * Format: start, end, start, end, ...
    */
-  blackoutDates: z19.array(z19.coerce.date()),
+  blackoutDates: z20.array(z20.coerce.date()),
   /**
    * List of names of some break: date range
    */
-  importantDates: z19.array(z19.string())
+  importantDates: z20.array(z20.string())
 });
 var zMSemester = extendZodObjectForMongoose(zSemester);
 
 // src/interface/tournament/tConfig.ts
-import { z as z21 } from "zod";
+import { Types as Types5 } from "mongoose";
+import { z as z22 } from "zod";
 
 // src/interface/tournament/table.ts
-import { z as z20 } from "zod";
-var zTable = z20.array(z20.object({}));
-var zDetailsTable = z20.object({
-  fields: z20.array(z20.string()).length(2),
+import { z as z21 } from "zod";
+var zTable = z21.array(z21.object({}));
+var zDetailsTable = z21.object({
+  fields: z21.array(z21.string()).length(2),
   data: zTable
 });
-var zScheduleTable = z20.object({
-  fields: z20.array(z20.string()).length(2),
-  data: z20.map(z20.string(), zTable)
+var zScheduleTable = z21.object({
+  fields: z21.array(z21.string()).length(2),
+  data: z21.map(z21.string(), zTable)
 });
 
 // src/interface/tournament/tConfig.ts
-var zTConfig = z21.object({
+var zTConfig = z22.object({
   /**
    * Location of the event
    */
-  location: z21.string().optional(),
+  location: z22.string().optional(),
   /**
    * URL of the tournament on the official website
    * Must be a valid URL link
    */
-  url: z21.string(),
+  url: z22.string(),
   /**
    * Full name of the tournament
    */
-  title: z21.string(),
+  title: z22.string(),
   /**
    * Abbreviated title of the tournament
    */
-  shortTitle: z21.string(),
+  shortTitle: z22.string(),
   /**
    * Tournament start date and time
    */
-  tStart: z21.coerce.date(),
+  tStart: z22.coerce.date(),
   /**
    * Tournament end date and time
    */
-  tEnd: z21.coerce.date(),
+  tEnd: z22.coerce.date(),
   /**
    * Short description for tournament card
    */
-  shortDescription: z21.string(),
+  shortDescription: z22.string(),
   /**
    * Full description
    */
-  description: z21.string(),
+  description: z22.string(),
   /**
    * Defines the tournament details table with 2 columns
    * typically Time and Event
@@ -488,15 +455,15 @@ var zTConfig = z21.object({
   /**
    * List of ticket object IDs for this tournament
    */
-  tickets: z21.array(z21.string()),
+  tickets: z22.array(z22.instanceof(Types5.ObjectId)),
   /**
    * If false, the tournament registration is closed
    */
-  canRegister: z21.boolean(),
+  canRegister: z22.boolean(),
   /**
    * If true, free form donation amounts are disabled.
    */
-  donationsDisabled: z21.boolean().optional(),
+  donationsDisabled: z22.boolean().optional(),
   /**
    * Defines URL, height, width of the image
    */
@@ -505,64 +472,60 @@ var zTConfig = z21.object({
 var zMTConfig = extendZodObjectForMongoose(zTConfig);
 
 // src/interface/tournament/tReg.ts
-import { z as z23 } from "zod";
+import { Types as Types7 } from "mongoose";
+import { z as z24 } from "zod";
 
 // src/interface/tournament/tTicketReg.ts
-import { z as z22 } from "zod";
-var zTTicketReg = z22.object({
-  /**
-   * Mongoose ID of the ticket
-   */
-  ticket: z22.string(),
+import { z as z23 } from "zod";
+import { Types as Types6 } from "mongoose";
+var zTTicketReg = z23.object({
+  ticket: z23.instanceof(Types6.ObjectId),
   /**
    * integer minimum 1, otherwise no ticket is being bought
    */
-  amount: z22.number().int().min(1)
+  amount: z23.number().int().min(1)
 });
 
 // src/interface/tournament/tReg.ts
-var zTReg = z23.object({
-  agaId: z23.string(),
-  /**
-   * Mongoose ID of the tournament that the participant is registering for
-   */
-  tournamentId: z23.string(),
-  tickets: z23.array(zTTicketReg),
+var zTReg = z24.object({
+  agaId: z24.string(),
+  tournamentId: z24.instanceof(Types7.ObjectId),
+  tickets: z24.array(zTTicketReg),
   /**
    * @units CENTS - Donation in cents
    */
-  donation: z23.number().optional(),
+  donation: z24.number().optional(),
   /**
    * How the registration was created, namely through public endpoint or admin
    */
-  createMethod: z23.string().optional(),
+  createMethod: z24.string().optional(),
   /**
    * Mongoose ID of the admin that edited the registration
    */
-  edited: z23.string().optional()
+  edited: z24.instanceof(Types7.ObjectId).optional()
 }).merge(zBUserInfo).merge(zBPaymentInfo);
 var zMTReg = extendZodObjectForMongoose(zTReg);
 
 // src/interface/tournament/tTicket.ts
-import { z as z24 } from "zod";
-var zTTicket = z24.object({
-  name: z24.string(),
+import { z as z25 } from "zod";
+var zTTicket = z25.object({
+  name: z25.string(),
   /**
    * Price in cents
    */
-  price: z24.number(),
+  price: z25.number(),
   /**
    * @optional description of the ticket
    */
-  description: z24.string().optional(),
+  description: z25.string().optional(),
   /**
    *  @optional The ticket cannot be purchased if true
    */
-  isNotBuyable: z24.boolean().optional(),
+  isNotBuyable: z25.boolean().optional(),
   /**
    *  @optional If date is provided and in the past, ticket cannot be purchased
    */
-  lastBuyableDate: z24.coerce.date().optional()
+  lastBuyableDate: z25.coerce.date().optional()
 });
 var zMTTicket = extendZodObjectForMongoose(zTTicket);
 
@@ -613,50 +576,50 @@ var GoRank = /* @__PURE__ */ ((GoRank2) => {
 })(GoRank || {});
 
 // src/interface/user/user.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/interface/user/userRoles.ts
-import { z as z25 } from "zod";
-var zUserRoles = z25.object({
-  user: z25.number().int(),
-  admin: z25.number().int(),
-  superadmin: z25.number().int()
+import { z as z26 } from "zod";
+var zUserRoles = z26.object({
+  user: z26.number().int(),
+  admin: z26.number().int(),
+  superadmin: z26.number().int()
 });
 
 // src/interface/user/user.ts
-var zUser = z26.object({
-  name: z26.string().min(2).max(100),
-  username: z26.string().optional(),
-  password: z26.string().optional(),
+import { Types as Types8 } from "mongoose";
+var zUser = z27.object({
+  name: z27.string().min(2).max(100),
+  username: z27.string().optional(),
+  password: z27.string().optional(),
   roles: zUserRoles.optional(),
-  email: z26.string().email().max(100).optional(),
-  address: z26.string().optional(),
-  country: z26.string().optional(),
-  phoneNumber: z26.string().optional(),
-  birthDate: z26.string().optional()
+  email: z27.string().email().max(100).optional(),
+  address: z27.string().optional(),
+  country: z27.string().optional(),
+  phoneNumber: z27.string().optional(),
+  birthDate: z27.string().optional()
 });
 var zMUser = extendZodObjectForMongoose(zUser);
 var zStudent = zUser.extend({
-  rank: z26.nativeEnum(GoRank),
-  // Object ID in mongoose linked to a user
-  guardian: z26.string().optional()
+  rank: z27.nativeEnum(GoRank),
+  guardian: z27.instanceof(Types8.ObjectId).optional()
 });
 var zMStudent = extendZodObjectForMongoose(zStudent);
 var zTeacher = zUser.extend({
-  rank: z26.nativeEnum(GoRank),
+  rank: z27.nativeEnum(GoRank),
   /**
    * Inactive teachers are not shown on public endpoints
    */
-  isInactive: z26.boolean().optional(),
+  isInactive: z27.boolean().optional(),
   /**
    * Teacher's position, e.g., instructor, president
    */
-  title: z26.string().optional(),
+  title: z27.string().optional(),
   /**
    * Teacher's bio text describing experience
    * new lines will be rendered as paragraphs
    */
-  bio: z26.string().optional(),
+  bio: z27.string().optional(),
   /** Format is illustrated below, where teacher is available
    * Mon 9-12am 3-6pm & Tue 10-12am 6-10pm
    * [
@@ -669,7 +632,7 @@ var zTeacher = zUser.extend({
    *  [],
    * ]
    */
-  available: z26.array(z26.array(z26.array(z26.number()))).optional()
+  available: z27.array(z27.array(z27.array(z27.number()))).optional()
 });
 var zMTeacher = extendZodObjectForMongoose(zTeacher);
 export {