@nyig/models 0.2.5 → 0.2.7

package/index.js

@@ -20,17 +20,794 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  zStudent: () => zStudent
+  booking: () => booking_exports,
+  course: () => course_exports,
+  payment: () => payment_exports,
+  pub: () => public_exports,
+  reporting: () => reporting_exports,
+  semester: () => semester_exports,
+  tournament: () => tournament_exports,
+  tracking: () => tracking_exports,
+  user: () => user_exports
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/z/student.ts
+// src/interface/booking/index.ts
+var booking_exports = {};
+__export(booking_exports, {
+  zBPaymentInfo: () => zBPaymentInfo,
+  zBUserInfo: () => zBUserInfo,
+  zCampBooking: () => zCampBooking,
+  zGroupBooking: () => zGroupBooking,
+  zMCampBooking: () => zMCampBooking,
+  zMGroupBooking: () => zMGroupBooking,
+  zMPrivateBooking: () => zMPrivateBooking,
+  zPrivateBooking: () => zPrivateBooking
+});
+
+// src/interface/booking/bUserInfo.ts
 var import_zod = require("zod");
-var zStudent = import_zod.z.object({
-  name: import_zod.z.string(),
-  email: import_zod.z.string().email()
+var zBUserInfo = import_zod.z.object({
+  firstName: import_zod.z.string(),
+  lastName: import_zod.z.string(),
+  rank: import_zod.z.string(),
+  email: import_zod.z.string(),
+  phone: import_zod.z.string().optional(),
+  address: import_zod.z.string().optional(),
+  notes: import_zod.z.string().optional()
+});
+
+// src/interface/booking/privateBooking.ts
+var import_zod4 = require("zod");
+
+// src/mongoose.ts
+var import_zod2 = require("zod");
+function extendZodObjectForMongoose(original) {
+  return original.extend({
+    _id: import_zod2.z.string(),
+    createdAt: import_zod2.z.coerce.date().optional(),
+    updatedAt: import_zod2.z.coerce.date().optional()
+  });
+}
+
+// src/interface/booking/bPaymentInfo.ts
+var import_zod3 = require("zod");
+var zBPaymentInfo = import_zod3.z.object({
+  /**
+   * @units CENTS - Proposed payment amount in cents of the booking
+   */
+  paymentAmount: import_zod3.z.number(),
+  /**
+   * True if the payment has been received. Populated by webhook.
+   */
+  paymentReceived: import_zod3.z.boolean().optional(),
+  /**
+   * When Date is reached, document is deleted by MongoDB sweeper.
+   * Creation typically marks one to two weeks.
+   * After payment, webhook should extend this date to essentially infinite.
+   */
+  expireAt: import_zod3.z.coerce.date().optional()
+});
+
+// src/interface/booking/privateBooking.ts
+var zPrivateBooking = import_zod4.z.object({
+  userId: import_zod4.z.string().optional(),
+  courseId: import_zod4.z.string(),
+  teacherId: import_zod4.z.string(),
+  classDate: import_zod4.z.string().optional()
+}).merge(zBUserInfo).merge(zBPaymentInfo);
+var zMPrivateBooking = extendZodObjectForMongoose(zPrivateBooking);
+
+// src/interface/booking/groupBooking.ts
+var import_zod5 = require("zod");
+var zGroupBooking = import_zod5.z.object({
+  userId: import_zod5.z.string().optional(),
+  gtId: import_zod5.z.string().optional(),
+  isTrial: import_zod5.z.boolean().optional(),
+  isOnline: import_zod5.z.boolean(),
+  classDate: import_zod5.z.string().optional(),
+  shipping: import_zod5.z.boolean().optional()
+}).merge(zBUserInfo).merge(zBPaymentInfo);
+var zMGroupBooking = extendZodObjectForMongoose(zGroupBooking);
+
+// src/interface/booking/campBooking.ts
+var import_zod15 = require("zod");
+
+// src/interface/tracking/index.ts
+var tracking_exports = {};
+__export(tracking_exports, {
+  AttendState: () => AttendState,
+  CampOption: () => CampOption,
+  zAttendance: () => zAttendance,
+  zCampTracker: () => zCampTracker,
+  zClassTracker: () => zClassTracker,
+  zGroupTracker: () => zGroupTracker,
+  zMAttendance: () => zMAttendance,
+  zMCampTracker: () => zMCampTracker,
+  zMClassTracker: () => zMClassTracker,
+  zMGroupTracker: () => zMGroupTracker,
+  zScheduleData: () => zScheduleData
+});
+
+// src/interface/tracking/attendState.ts
+var AttendState = /* @__PURE__ */ ((AttendState2) => {
+  AttendState2["ABSENT"] = "absent";
+  AttendState2["PRESENT"] = "present";
+  AttendState2["NONE"] = "none";
+  return AttendState2;
+})(AttendState || {});
+
+// src/interface/tracking/attendance.ts
+var import_zod7 = require("zod");
+
+// src/interface/payment/tuition.ts
+var import_zod6 = require("zod");
+var zTuition = import_zod6.z.object({
+  primary: import_zod6.z.number(),
+  textbook: import_zod6.z.boolean().optional(),
+  shipping: import_zod6.z.boolean().optional()
+});
+
+// src/interface/tracking/campOption.ts
+var CampOption = /* @__PURE__ */ ((CampOption2) => {
+  CampOption2["AM"] = "am";
+  CampOption2["PM"] = "pm";
+  CampOption2["FULL"] = "full";
+  return CampOption2;
+})(CampOption || {});
+
+// src/interface/tracking/attendance.ts
+var zAttendance = import_zod7.z.object({
+  student: import_zod7.z.string(),
+  states: import_zod7.z.array(import_zod7.z.nativeEnum(AttendState)),
+  tuition: zTuition,
+  paid: import_zod7.z.boolean().optional(),
+  campOption: import_zod7.z.nativeEnum(CampOption)
+});
+var zMAttendance = extendZodObjectForMongoose(zAttendance);
+
+// src/interface/tracking/campTracker.ts
+var import_zod8 = require("zod");
+var zCampTracker = import_zod8.z.object({
+  /**
+   * Mongoose object ID
+   */
+  course: import_zod8.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  teacher: import_zod8.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  semester: import_zod8.z.string(),
+  /**
+   * occurrences are tracked by week for camps
+   */
+  occurrences: import_zod8.z.array(import_zod8.z.string()),
+  /**
+   * attendances are tracked by week for camps
+   */
+  attendances: import_zod8.z.array(import_zod8.z.string()),
+  notes: import_zod8.z.string().optional()
+});
+var zMCampTracker = extendZodObjectForMongoose(zCampTracker);
+
+// src/interface/tracking/classTracker.ts
+var import_zod11 = require("zod");
+
+// src/interface/payment/index.ts
+var payment_exports = {};
+__export(payment_exports, {
+  PaymentMethod: () => PaymentMethod,
+  zDiscount: () => zDiscount,
+  zInvoice: () => zInvoice,
+  zInvoiceItem: () => zInvoiceItem,
+  zInvoicePackage: () => zInvoicePackage,
+  zMInvoice: () => zMInvoice,
+  zMTeacherPayment: () => zMTeacherPayment,
+  zTeacherPayment: () => zTeacherPayment,
+  zTeacherPaymentRow: () => zTeacherPaymentRow,
+  zTuition: () => zTuition
+});
+
+// src/interface/payment/invoice.ts
+var import_zod9 = require("zod");
+
+// src/interface/payment/paymentMethod.ts
+var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
+  PaymentMethod2["CASH"] = "Cash";
+  PaymentMethod2["CHECK"] = "Check";
+  PaymentMethod2["VENMO"] = "Venmo";
+  PaymentMethod2["ZELLE"] = "Zelle Transfer";
+  return PaymentMethod2;
+})(PaymentMethod || {});
+
+// src/interface/payment/invoice.ts
+var zDiscount = import_zod9.z.object({
+  desc: import_zod9.z.string(),
+  amount: import_zod9.z.number()
+});
+var zInvoiceItem = import_zod9.z.object({
+  /**
+   * Mongoose object ID
+   */
+  course: import_zod9.z.string(),
+  price: import_zod9.z.number(),
+  units: import_zod9.z.number()
+});
+var zInvoicePackage = import_zod9.z.object({
+  /**
+   * Mongoose object ID
+   */
+  student: import_zod9.z.string(),
+  items: import_zod9.z.array(zInvoiceItem)
+});
+var zInvoice = import_zod9.z.object({
+  billTo: import_zod9.z.string(),
+  packages: import_zod9.z.array(zInvoicePackage),
+  discounts: import_zod9.z.array(zDiscount),
+  textbook: import_zod9.z.number().optional(),
+  shipping: import_zod9.z.number().optional(),
+  paid: import_zod9.z.nativeEnum(PaymentMethod).optional(),
+  notes: import_zod9.z.string().optional(),
+  /**
+   * Mongoose object ID
+   */
+  createdBy: import_zod9.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  lastEditBy: import_zod9.z.string().optional()
+});
+var zMInvoice = extendZodObjectForMongoose(zInvoice);
+
+// src/interface/payment/teacherPayment.ts
+var import_zod10 = require("zod");
+var zTeacherPaymentRow = import_zod10.z.object({
+  course: import_zod10.z.string(),
+  length: import_zod10.z.number(),
+  count: import_zod10.z.number(),
+  wage: import_zod10.z.number()
+});
+var zTeacherPayment = import_zod10.z.object({
+  teacher: import_zod10.z.string(),
+  rows: import_zod10.z.array(zTeacherPaymentRow),
+  paid: import_zod10.z.boolean().optional()
+});
+var zMTeacherPayment = extendZodObjectForMongoose(zTeacherPayment);
+
+// src/interface/tracking/classTracker.ts
+var zClassTracker = import_zod11.z.object({
+  /**
+   * Mongoose object ID
+   */
+  course: import_zod11.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  teacher: import_zod11.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  semester: import_zod11.z.string(),
+  classTimes: import_zod11.z.array(import_zod11.z.coerce.date()),
+  completedList: import_zod11.z.array(import_zod11.z.boolean()),
+  /**
+   * Virtual mongoose field when all values in completedList is true
+   */
+  completed: import_zod11.z.boolean().optional(),
+  tuition: zTuition.optional(),
+  paid: import_zod11.z.boolean().optional(),
+  notes: import_zod11.z.string().optional()
+});
+var zMClassTracker = extendZodObjectForMongoose(zClassTracker);
+
+// src/interface/tracking/groupTracker.ts
+var import_zod14 = require("zod");
+
+// src/interface/tracking/scheduleData.ts
+var import_zod12 = require("zod");
+var zScheduleData = import_zod12.z.object({
+  startTime: import_zod12.z.string(),
+  // String in 24 hour "HH:mm" format
+  dayOfWeek: import_zod12.z.number().int().min(0).max(6)
+  // integeters in 0 - 6
+});
+
+// src/interface/course/index.ts
+var course_exports = {};
+__export(course_exports, {
+  AgeGroup: () => AgeGroup,
+  CourseCategory: () => CourseCategory,
+  NYIGSchool: () => NYIGSchool,
+  zCourse: () => zCourse,
+  zMCourse: () => zMCourse
+});
+
+// src/interface/course/ageGroup.ts
+var AgeGroup = /* @__PURE__ */ ((AgeGroup2) => {
+  AgeGroup2["ADULT"] = "Adult";
+  AgeGroup2["YOUTH"] = "Youth";
+  return AgeGroup2;
+})(AgeGroup || {});
+
+// src/interface/course/category.ts
+var CourseCategory = /* @__PURE__ */ ((CourseCategory2) => {
+  CourseCategory2["GROUP"] = "group";
+  CourseCategory2["PRIVATE"] = "private";
+  CourseCategory2["SEMIPRIVATE"] = "semiprivate";
+  CourseCategory2["CAMP"] = "camp";
+  return CourseCategory2;
+})(CourseCategory || {});
+
+// src/interface/course/school.ts
+var NYIGSchool = /* @__PURE__ */ ((NYIGSchool2) => {
+  NYIGSchool2["MANHATTAN"] = "Manhattan";
+  NYIGSchool2["LITTLENECK"] = "Little Neck";
+  NYIGSchool2["ONLINE"] = "Online";
+  return NYIGSchool2;
+})(NYIGSchool || {});
+
+// src/interface/course/course.ts
+var import_zod13 = require("zod");
+var zCourse = import_zod13.z.object({
+  name: import_zod13.z.string(),
+  category: import_zod13.z.nativeEnum(CourseCategory),
+  /**
+   * @unit SECONDS - Duration of the course in seconds
+   */
+  duration: import_zod13.z.number(),
+  /**
+   * @unit CENTS - Price of the course in cents
+   */
+  price: import_zod13.z.number(),
+  description: import_zod13.z.string().optional(),
+  /**
+   * NYIG School locations
+   */
+  nyigSchool: import_zod13.z.nativeEnum(NYIGSchool),
+  /**
+   * Recommended level before taking this course
+   */
+  recLevel: import_zod13.z.string(),
+  /**
+   * Camp tuition for half-day option
+   */
+  halfCampTuition: import_zod13.z.number(),
+  /**
+   * Camp tuition for full-day option
+   */
+  fullCampTuition: import_zod13.z.number()
+});
+var zMCourse = extendZodObjectForMongoose(zCourse);
+
+// src/interface/tracking/groupTracker.ts
+var zGroupTracker = import_zod14.z.object({
+  /**
+   * Mongoose object ID
+   */
+  course: import_zod14.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  teacher: import_zod14.z.string(),
+  /**
+   * Mongoose object ID
+   */
+  semester: import_zod14.z.string(),
+  scheduleData: zScheduleData,
+  /**
+   * occurrences are tracked by week for Groups
+   */
+  occurrences: import_zod14.z.array(import_zod14.z.coerce.date()),
+  /**
+   * attendances are tracked by week for Groups
+   */
+  attendances: import_zod14.z.array(import_zod14.z.string()),
+  /**
+   * ID of the course instance, e.g., 101
+   */
+  courseId: import_zod14.z.string().optional(),
+  /**
+   * Age group of the class instance, e.g. "adult", "youth"
+   */
+  ageGroup: import_zod14.z.nativeEnum(AgeGroup).optional(),
+  /**
+   * If true, the course is hidden from public view
+   */
+  isNonPublic: import_zod14.z.boolean().optional(),
+  notes: import_zod14.z.string().optional()
+});
+var zMGroupTracker = extendZodObjectForMongoose(zGroupTracker);
+
+// src/interface/booking/campBooking.ts
+var zCampBooking = import_zod15.z.object({
+  userId: import_zod15.z.string().optional(),
+  ctId: import_zod15.z.string().optional(),
+  isOnline: import_zod15.z.boolean(),
+  classDates: import_zod15.z.string(),
+  campOption: import_zod15.z.nativeEnum(CampOption),
+  shipping: import_zod15.z.boolean().optional()
+}).merge(zBUserInfo).merge(zBPaymentInfo);
+var zMCampBooking = extendZodObjectForMongoose(zCampBooking);
+
+// src/interface/public/index.ts
+var public_exports = {};
+__export(public_exports, {
+  zCourseTable: () => zCourseTable,
+  zImageDef: () => zImageDef,
+  zTeacherDisplay: () => zTeacherDisplay
+});
+
+// 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 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()
+});
+
+// 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()
+});
+
+// src/interface/reporting/index.ts
+var reporting_exports = {};
+__export(reporting_exports, {
+  zMReportTicket: () => zMReportTicket,
+  zReportTicket: () => zReportTicket
+});
+
+// src/interface/reporting/reportTicket.ts
+var import_zod18 = require("zod");
+var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
+  TicketStatus2["REQUESTED"] = "Requested";
+  TicketStatus2["IN_PROGRESS"] = "In-progress";
+  TicketStatus2["SIGN_OFF"] = "Sign-off";
+  TicketStatus2["COMPLETED"] = "Completed";
+  return TicketStatus2;
+})(TicketStatus || {});
+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 zMReportTicket = extendZodObjectForMongoose(zReportTicket);
+
+// src/interface/semester/index.ts
+var semester_exports = {};
+__export(semester_exports, {
+  Season: () => Season,
+  zMSemester: () => zMSemester,
+  zSemester: () => zSemester
+});
+
+// src/interface/semester/season.ts
+var Season = /* @__PURE__ */ ((Season2) => {
+  Season2["FALL"] = "fall";
+  Season2["SPRING"] = "spring";
+  Season2["SUMMER"] = "summer";
+  return 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(),
+  /**
+   * Format: start, end, start, end, ...
+   */
+  blackoutDates: import_zod19.z.array(import_zod19.z.coerce.date()),
+  /**
+   * List of names of some break: date range
+   */
+  importantDates: import_zod19.z.array(import_zod19.z.string())
+});
+var zMSemester = extendZodObjectForMongoose(zSemester);
+
+// src/interface/tournament/index.ts
+var tournament_exports = {};
+__export(tournament_exports, {
+  zDetailsTable: () => zDetailsTable,
+  zMTConfig: () => zMTConfig,
+  zMTReg: () => zMTReg,
+  zMTTicket: () => zMTTicket,
+  zScheduleTable: () => zScheduleTable,
+  zTConfig: () => zTConfig,
+  zTReg: () => zTReg,
+  zTTicket: () => zTTicket,
+  zTTicketReg: () => zTTicketReg
+});
+
+// src/interface/tournament/tConfig.ts
+var import_zod21 = 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),
+  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)
+});
+
+// src/interface/tournament/tConfig.ts
+var zTConfig = import_zod21.z.object({
+  /**
+   * Location of the event
+   */
+  location: import_zod21.z.string().optional(),
+  /**
+   * URL of the tournament on the official website
+   * Must be a valid URL link
+   */
+  url: import_zod21.z.string(),
+  /**
+   * Full name of the tournament
+   */
+  title: import_zod21.z.string(),
+  /**
+   * Abbreviated title of the tournament
+   */
+  shortTitle: import_zod21.z.string(),
+  /**
+   * Tournament start date and time
+   */
+  tStart: import_zod21.z.coerce.date(),
+  /**
+   * Tournament end date and time
+   */
+  tEnd: import_zod21.z.coerce.date(),
+  /**
+   * Short description for tournament card
+   */
+  shortDescription: import_zod21.z.string(),
+  /**
+   * Full description
+   */
+  description: import_zod21.z.string(),
+  /**
+   * Defines the tournament details table with 2 columns
+   * typically Time and Event
+   */
+  details: zDetailsTable,
+  /**
+   * Defines the tournament schedule.
+   * data is a map of tab title -> 2 column table rows.
+   */
+  schedule: zScheduleTable,
+  /**
+   * List of ticket object IDs for this tournament
+   */
+  tickets: import_zod21.z.array(import_zod21.z.string()),
+  /**
+   * If false, the tournament registration is closed
+   */
+  canRegister: import_zod21.z.boolean(),
+  /**
+   * If true, free form donation amounts are disabled.
+   */
+  donationsDisabled: import_zod21.z.boolean().optional(),
+  /**
+   * Defines URL, height, width of the image
+   */
+  image: zImageDef.optional()
+});
+var zMTConfig = extendZodObjectForMongoose(zTConfig);
+
+// src/interface/tournament/tReg.ts
+var import_zod23 = 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(),
+  /**
+   * integer minimum 1, otherwise no ticket is being bought
+   */
+  amount: import_zod22.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),
+  /**
+   * @units CENTS - Donation in cents
+   */
+  donation: import_zod23.z.number().optional(),
+  /**
+   * How the registration was created, namely through public endpoint or admin
+   */
+  createMethod: import_zod23.z.string().optional(),
+  /**
+   * Mongoose ID of the admin that edited the registration
+   */
+  edited: import_zod23.z.string().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(),
+  /**
+   * Price in cents
+   */
+  price: import_zod24.z.number(),
+  /**
+   * @optional description of the ticket
+   */
+  description: import_zod24.z.string().optional(),
+  /**
+   *  @optional The ticket cannot be purchased if true
+   */
+  isNotBuyable: import_zod24.z.boolean().optional(),
+  /**
+   *  @optional If date is provided and in the past, ticket cannot be purchased
+   */
+  lastBuytableDate: import_zod24.z.coerce.date().optional()
+});
+var zMTTicket = extendZodObjectForMongoose(zTTicket);
+
+// src/interface/user/index.ts
+var user_exports = {};
+__export(user_exports, {
+  GoRank: () => GoRank,
+  zMStudent: () => zMStudent,
+  zMTeacher: () => zMTeacher,
+  zMUser: () => zMUser,
+  zStudent: () => zStudent,
+  zTeacher: () => zTeacher,
+  zUser: () => zUser,
+  zUserRoles: () => zUserRoles
+});
+
+// src/interface/user/goRank.ts
+var GoRank = /* @__PURE__ */ ((GoRank2) => {
+  GoRank2["KYU1"] = "1k";
+  GoRank2["KYU2"] = "2k";
+  GoRank2["KYU3"] = "3k";
+  GoRank2["KYU4"] = "4k";
+  GoRank2["KYU5"] = "5k";
+  GoRank2["KYU6"] = "6k";
+  GoRank2["KYU7"] = "7k";
+  GoRank2["KYU8"] = "8k";
+  GoRank2["KYU9"] = "9k";
+  GoRank2["KYU10"] = "10k";
+  GoRank2["KYU11"] = "11k";
+  GoRank2["KYU12"] = "12k";
+  GoRank2["KYU13"] = "13k";
+  GoRank2["KYU14"] = "14k";
+  GoRank2["KYU15"] = "15k";
+  GoRank2["KYU16"] = "16k";
+  GoRank2["KYU17"] = "17k";
+  GoRank2["KYU18"] = "18k";
+  GoRank2["KYU19"] = "19k";
+  GoRank2["KYU20"] = "20k";
+  GoRank2["KYU21"] = "21k";
+  GoRank2["KYU22"] = "22k";
+  GoRank2["KYU23"] = "23k";
+  GoRank2["KYU24"] = "24k";
+  GoRank2["KYU25"] = "25k";
+  GoRank2["DAN1"] = "1d";
+  GoRank2["DAN2"] = "2d";
+  GoRank2["DAN3"] = "3d";
+  GoRank2["DAN4"] = "4d";
+  GoRank2["DAN5"] = "5d";
+  GoRank2["DAN6"] = "6d";
+  GoRank2["DAN7"] = "7d";
+  GoRank2["PRO1"] = "1p";
+  GoRank2["PRO2"] = "2p";
+  GoRank2["PRO3"] = "3p";
+  GoRank2["PRO4"] = "4p";
+  GoRank2["PRO5"] = "5p";
+  GoRank2["PRO6"] = "6p";
+  GoRank2["PRO7"] = "7p";
+  GoRank2["PRO8"] = "8p";
+  GoRank2["PRO9"] = "9p";
+  return GoRank2;
+})(GoRank || {});
+
+// src/interface/user/user.ts
+var import_zod26 = 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()
+});
+
+// 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(),
+  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()
+});
+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()
+});
+var zMStudent = extendZodObjectForMongoose(zStudent);
+var zTeacher = zUser.extend({
+  rank: import_zod26.z.nativeEnum(GoRank),
+  /**
+   * Inactive teachers are not shown on public endpoints
+   */
+  isInactive: import_zod26.z.boolean().optional(),
+  /**
+   * Teacher's position, e.g., instructor, president
+   */
+  title: import_zod26.z.string().optional(),
+  /**
+   * Teacher's bio text describing experience
+   * new lines will be rendered as paragraphs
+   */
+  bio: import_zod26.z.string().optional(),
+  /** Format is illustrated below, where teacher is available
+   * Mon 9-12am 3-6pm & Tue 10-12am 6-10pm
+   * [
+   *  [[9, 12], [15, 18]],
+   *  [[10, 12], [18, 20]],
+   *  [],
+   *  [],
+   *  [],
+   *  [],
+   *  [],
+   * ]
+   */
+  available: import_zod26.z.array(import_zod26.z.array(import_zod26.z.array(import_zod26.z.number()))).optional()
 });
+var zMTeacher = extendZodObjectForMongoose(zTeacher);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  zStudent
+  booking,
+  course,
+  payment,
+  pub,
+  reporting,
+  semester,
+  tournament,
+  tracking,
+  user
 });