@brite-future-schools-contracts/contracts 1.0.8 → 2.0.3

package/dist/contracts/index.cjs

@@ -0,0 +1,592 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contracts/index.ts
+var contracts_exports = {};
+__export(contracts_exports, {
+  authContract: () => authContract,
+  bulkUploadStudentsContract: () => bulkUploadStudentsContract,
+  changePasswordContract: () => changePasswordContract,
+  createDepartmentContract: () => createDepartmentContract,
+  createStaffContract: () => createStaffContract,
+  createStudentContract: () => createStudentContract,
+  getMeContract: () => getMeContract,
+  getStaffByIdContract: () => getStaffByIdContract,
+  getStudentByIdContract: () => getStudentByIdContract,
+  hrContract: () => hrContract,
+  linkGuardianContract: () => linkGuardianContract,
+  listClassesContract: () => listClassesContract,
+  listDepartmentsContract: () => listDepartmentsContract,
+  listStaffContract: () => listStaffContract,
+  listStudentsContract: () => listStudentsContract,
+  loginContract: () => loginContract,
+  logoutContract: () => logoutContract,
+  refreshTokenContract: () => refreshTokenContract,
+  requestPasswordResetContract: () => requestPasswordResetContract,
+  resetPasswordContract: () => resetPasswordContract,
+  studentsContract: () => studentsContract,
+  switchBranchContract: () => switchBranchContract,
+  updateStaffStatusContract: () => updateStaffStatusContract
+});
+module.exports = __toCommonJS(contracts_exports);
+
+// src/contracts/auth.ts
+var import_contract = require("@orpc/contract");
+var z3 = __toESM(require("zod"), 1);
+
+// src/schemas/auth.ts
+var z2 = __toESM(require("zod"), 1);
+
+// src/schemas/base.ts
+var z = __toESM(require("zod"), 1);
+var CuidSchema = z.string().regex(/^[a-z][a-z0-9]{24}$/, "Invalid cuid2 identifier").meta({ description: "cuid2 \u2014 prefixed, collision-resistant identifier" });
+var UuidSchema = z.uuidv4().meta({ description: "RFC-4122 UUID v4" });
+var IsoDatetime = z.iso.datetime();
+var TimestampsSchema = z.object({
+  createdAt: IsoDatetime.meta({ description: "ISO-8601 creation time (UTC)" }),
+  updatedAt: IsoDatetime.meta({ description: "ISO-8601 last update time (UTC)" })
+});
+var SoftDeleteSchema = z.object({
+  deletedAt: IsoDatetime.nullable().meta({
+    description: "Set when the record is soft-deleted; null if active"
+  })
+});
+var PaginationInputSchema = z.object({
+  cursor: CuidSchema.optional().meta({
+    description: "Opaque cursor from the previous page response"
+  }),
+  limit: z.int().min(1).max(100).default(20).meta({ description: "Number of items to return (1\u2013100, default 20)" })
+});
+var BranchRefSchema = z.object({
+  branchId: CuidSchema.meta({ description: "The branch this record belongs to" })
+});
+
+// src/schemas/auth.ts
+var SessionUserRoleSchema = z2.object({
+  id: CuidSchema,
+  name: z2.string().meta({ description: "Role name, e.g. PRINCIPAL" }),
+  branchId: CuidSchema,
+  isPrimary: z2.boolean()
+});
+var SessionUserSubRoleSchema = z2.object({
+  id: CuidSchema,
+  name: z2.string().meta({ description: "Sub-role name, e.g. HEAD_PREFECT" }),
+  branchId: CuidSchema
+});
+var SessionUserOutputSchema = z2.object({
+  id: CuidSchema,
+  email: z2.email(),
+  firstName: z2.string(),
+  lastName: z2.string(),
+  activeBranchId: CuidSchema,
+  roles: z2.array(SessionUserRoleSchema),
+  subRoles: z2.array(SessionUserSubRoleSchema),
+  isActive: z2.boolean(),
+  mustChangePassword: z2.boolean()
+});
+var LoginInputSchema = z2.object({
+  email: z2.email().meta({ description: "User email address" }),
+  password: z2.string().min(1).meta({ description: "Plain-text password (sent over TLS)" }),
+  branchId: CuidSchema.optional().meta({
+    description: "Branch to activate on login; defaults to user primary branch"
+  })
+});
+var LoginOutputSchema = z2.object({
+  accessToken: z2.string().meta({ description: "Short-lived JWT (15 min)" }),
+  refreshToken: z2.string().meta({ description: "Long-lived opaque refresh token (7 days)" }),
+  expiresIn: z2.int().positive().meta({ description: "Access token TTL in seconds" }),
+  user: SessionUserOutputSchema
+});
+var RefreshTokenInputSchema = z2.object({
+  refreshToken: z2.string().min(1)
+});
+var RefreshTokenOutputSchema = z2.object({
+  accessToken: z2.string(),
+  expiresIn: z2.int().positive()
+});
+var LogoutInputSchema = z2.object({
+  refreshToken: z2.string().min(1).meta({
+    description: "The refresh token to revoke; also invalidated server-side"
+  })
+});
+var ChangePasswordInputSchema = z2.object({
+  currentPassword: z2.string().min(1),
+  newPassword: z2.string().min(8, { error: "Password must be at least 8 characters" }),
+  confirmPassword: z2.string().min(1)
+}).refine((v) => v.newPassword === v.confirmPassword, {
+  error: "Passwords do not match",
+  path: ["confirmPassword"]
+});
+var RequestPasswordResetInputSchema = z2.object({
+  email: z2.email()
+});
+var ResetPasswordInputSchema = z2.object({
+  token: z2.string().min(1).meta({ description: "One-time reset token from email link" }),
+  newPassword: z2.string().min(8, { error: "Password must be at least 8 characters" }),
+  confirmPassword: z2.string().min(1)
+}).refine((v) => v.newPassword === v.confirmPassword, {
+  error: "Passwords do not match",
+  path: ["confirmPassword"]
+});
+var SwitchBranchInputSchema = z2.object({
+  branchId: CuidSchema.meta({ description: "Branch to switch the active session to" })
+});
+
+// src/contracts/auth.ts
+var EmptyOutputSchema = z3.object({}).meta({ description: "Empty success response" });
+var loginContract = import_contract.oc.route({ method: "POST", path: "/auth/login" }).input(LoginInputSchema).output(LoginOutputSchema);
+var refreshTokenContract = import_contract.oc.route({ method: "POST", path: "/auth/refresh" }).input(RefreshTokenInputSchema).output(RefreshTokenOutputSchema);
+var logoutContract = import_contract.oc.route({ method: "POST", path: "/auth/logout" }).input(LogoutInputSchema).output(EmptyOutputSchema);
+var getMeContract = import_contract.oc.route({ method: "GET", path: "/auth/me" }).output(SessionUserOutputSchema);
+var changePasswordContract = import_contract.oc.route({ method: "POST", path: "/auth/change-password" }).input(ChangePasswordInputSchema).output(EmptyOutputSchema);
+var requestPasswordResetContract = import_contract.oc.route({ method: "POST", path: "/auth/request-password-reset" }).input(RequestPasswordResetInputSchema).output(EmptyOutputSchema);
+var resetPasswordContract = import_contract.oc.route({ method: "POST", path: "/auth/reset-password" }).input(ResetPasswordInputSchema).output(EmptyOutputSchema);
+var switchBranchContract = import_contract.oc.route({ method: "POST", path: "/auth/switch-branch" }).input(SwitchBranchInputSchema).output(SessionUserOutputSchema);
+var authContract = {
+  login: loginContract,
+  refreshToken: refreshTokenContract,
+  logout: logoutContract,
+  me: getMeContract,
+  changePassword: changePasswordContract,
+  requestPasswordReset: requestPasswordResetContract,
+  resetPassword: resetPasswordContract,
+  switchBranch: switchBranchContract
+};
+
+// src/contracts/hr.ts
+var import_contract2 = require("@orpc/contract");
+var z5 = __toESM(require("zod"), 1);
+
+// src/schemas/hr.ts
+var z4 = __toESM(require("zod"), 1);
+var EmploymentTypeSchema = z4.enum([
+  "permanent",
+  "contract",
+  "temporary",
+  "intern"
+]);
+var RoleNameSchema = z4.enum([
+  "PROPRIETOR",
+  "DIRECTOR",
+  "SYSTEM_ADMIN",
+  "PRINCIPAL",
+  "DEPUTY_PRINCIPAL",
+  "HOD",
+  "CLASS_TEACHER",
+  "SUBJECT_TEACHER",
+  "BURSAR",
+  "HR_ADMIN",
+  "SCHOOL_NURSE",
+  "LIBRARIAN",
+  "LAB_TECHNICIAN",
+  "SPORTS_COACH",
+  "COUNSELLOR",
+  "CARETAKER",
+  "SECURITY",
+  "KITCHEN_STAFF",
+  "KITCHEN_MANAGER",
+  "DRIVER",
+  "IT_ADMIN",
+  "BOARDING_MASTER",
+  "PREFECT",
+  "STUDENT",
+  "PARENT",
+  "ORG_SPONSOR",
+  "INDIVIDUAL_SPONSOR"
+]);
+var CreateStaffInputSchema = z4.object({
+  // Personal details
+  firstName: z4.string().min(1).max(100),
+  middleName: z4.string().max(100).optional(),
+  lastName: z4.string().min(1).max(100),
+  email: z4.email(),
+  phone: z4.string().min(9).max(30),
+  nationalId: z4.string().min(1).max(20),
+  // Role assignment
+  roleName: RoleNameSchema.meta({
+    description: "System role to assign \u2014 determines dashboard access and permissions"
+  }),
+  isPrimaryRole: z4.boolean().default(true),
+  // Employment details
+  departmentId: UuidSchema.optional(),
+  designation: z4.string().min(1).max(100).meta({
+    description: 'Job title, e.g. "Mathematics Teacher", "Head of Finance"'
+  }),
+  employmentType: EmploymentTypeSchema,
+  contractStart: z4.iso.date().meta({ description: "ISO date, e.g. 2026-01-15" }),
+  contractEnd: z4.iso.date().optional(),
+  // Payroll
+  basicSalary: z4.number().positive(),
+  houseAllowance: z4.number().nonnegative().default(0),
+  transportAllowance: z4.number().nonnegative().default(0),
+  helbDeduction: z4.number().nonnegative().default(0),
+  saccoDeduction: z4.number().nonnegative().default(0),
+  // Banking
+  bankName: z4.string().max(100).optional(),
+  bankAccount: z4.string().max(30).optional(),
+  bankBranch: z4.string().max(100).optional(),
+  // Statutory
+  tscNumber: z4.string().max(30).optional(),
+  kraPin: z4.string().max(20).optional(),
+  nhifNo: z4.string().max(20).optional(),
+  nssfNo: z4.string().max(20).optional()
+});
+var StaffProfileSchema = z4.object({
+  // Staff record
+  id: UuidSchema,
+  userId: UuidSchema,
+  branchId: UuidSchema,
+  firstName: z4.string(),
+  middleName: z4.string().nullable(),
+  lastName: z4.string(),
+  phone: z4.string(),
+  nationalId: z4.string(),
+  tscNumber: z4.string().nullable(),
+  kraPin: z4.string().nullable(),
+  nhifNo: z4.string().nullable(),
+  nssfNo: z4.string().nullable(),
+  designation: z4.string(),
+  employmentType: EmploymentTypeSchema,
+  contractStart: z4.string(),
+  contractEnd: z4.string().nullable(),
+  basicSalary: z4.string(),
+  houseAllowance: z4.string(),
+  transportAllowance: z4.string(),
+  helbDeduction: z4.string().nullable(),
+  saccoDeduction: z4.string().nullable(),
+  bankName: z4.string().nullable(),
+  bankAccount: z4.string().nullable(),
+  bankBranch: z4.string().nullable(),
+  status: z4.string(),
+  createdAt: z4.string(),
+  // From users join
+  email: z4.string(),
+  mustChangePassword: z4.boolean(),
+  // Department (nullable — not all staff are in a department)
+  departmentId: UuidSchema.nullable(),
+  departmentName: z4.string().nullable(),
+  // Primary role
+  roleName: RoleNameSchema.nullable(),
+  roleId: UuidSchema.nullable()
+});
+var StaffListItemSchema = z4.object({
+  id: UuidSchema,
+  userId: UuidSchema,
+  firstName: z4.string(),
+  middleName: z4.string().nullable(),
+  lastName: z4.string(),
+  email: z4.string(),
+  phone: z4.string(),
+  designation: z4.string(),
+  employmentType: EmploymentTypeSchema,
+  status: z4.string(),
+  departmentName: z4.string().nullable(),
+  roleName: RoleNameSchema.nullable(),
+  createdAt: z4.string()
+});
+var ListStaffInputSchema = PaginationInputSchema.extend({
+  search: z4.string().optional().meta({
+    description: "Search by name or email"
+  }),
+  departmentId: UuidSchema.optional(),
+  roleName: RoleNameSchema.optional(),
+  status: z4.enum(["active", "inactive"]).optional()
+});
+var CreateStaffOutputSchema = z4.object({
+  staffId: UuidSchema,
+  userId: UuidSchema,
+  email: z4.string(),
+  /** Temp password was emailed — not returned in response for security */
+  emailSent: z4.boolean()
+});
+var DepartmentSchema = z4.object({
+  id: UuidSchema,
+  branchId: UuidSchema,
+  name: z4.string(),
+  hodId: UuidSchema.nullable()
+});
+var CreateDepartmentInputSchema = z4.object({
+  name: z4.string().min(1).max(100),
+  hodId: UuidSchema.optional()
+});
+
+// src/contracts/hr.ts
+var EmptyOutput = z5.object({});
+var createStaffContract = import_contract2.oc.route({ method: "POST", path: "/hr/staff" }).input(CreateStaffInputSchema).output(CreateStaffOutputSchema);
+var listStaffContract = import_contract2.oc.route({ method: "GET", path: "/hr/staff" }).input(ListStaffInputSchema).output(z5.object({
+  items: z5.array(StaffListItemSchema),
+  total: z5.number(),
+  nextCursor: UuidSchema.nullable()
+}));
+var getStaffByIdContract = import_contract2.oc.route({ method: "GET", path: "/hr/staff/{id}" }).input(z5.object({ id: UuidSchema })).output(StaffProfileSchema);
+var updateStaffStatusContract = import_contract2.oc.route({ method: "PATCH", path: "/hr/staff/{id}/status" }).input(z5.object({
+  id: UuidSchema,
+  status: z5.enum(["active", "inactive", "suspended"])
+})).output(EmptyOutput);
+var listDepartmentsContract = import_contract2.oc.route({ method: "GET", path: "/hr/departments" }).input(z5.object({ branchId: UuidSchema.optional() })).output(z5.array(DepartmentSchema));
+var createDepartmentContract = import_contract2.oc.route({ method: "POST", path: "/hr/departments" }).input(CreateDepartmentInputSchema).output(DepartmentSchema);
+var hrContract = {
+  createStaff: createStaffContract,
+  listStaff: listStaffContract,
+  getStaffById: getStaffByIdContract,
+  updateStaffStatus: updateStaffStatusContract,
+  listDepartments: listDepartmentsContract,
+  createDepartment: createDepartmentContract
+};
+
+// src/contracts/students.ts
+var import_contract3 = require("@orpc/contract");
+var z7 = __toESM(require("zod"), 1);
+
+// src/schemas/students.ts
+var z6 = __toESM(require("zod"), 1);
+var GenderSchema = z6.enum(["male", "female"]);
+var StudentStatusSchema = z6.enum([
+  "active",
+  "transferred",
+  "graduated",
+  "suspended",
+  "withdrawn"
+]);
+var GradeLevelSchema = z6.enum([
+  "PP1",
+  "PP2",
+  "G1",
+  "G2",
+  "G3",
+  "G4",
+  "G5",
+  "G6",
+  "G7",
+  "G8",
+  "G9"
+]);
+var CreateStudentInputSchema = z6.object({
+  // Identity
+  firstName: z6.string().min(1).max(100),
+  middleName: z6.string().max(100).optional(),
+  lastName: z6.string().min(1).max(100),
+  dateOfBirth: z6.iso.date().meta({ description: "ISO date, e.g. 2015-03-22" }),
+  gender: GenderSchema,
+  admissionNo: z6.string().min(1).max(50).meta({
+    description: "School-assigned admission number \u2014 must be unique per branch"
+  }),
+  nemisNo: z6.string().max(50).optional(),
+  admissionDate: z6.iso.date(),
+  bloodGroup: z6.string().max(10).optional(),
+  medicalNotes: z6.string().optional(),
+  // Class placement (optional at creation — can be enrolled later)
+  classId: UuidSchema.optional().meta({
+    description: "Class to enrol student in for the current term"
+  }),
+  termId: UuidSchema.optional().meta({
+    description: "Term for class enrolment \u2014 required if classId is provided"
+  }),
+  // Guardian (optional at creation — can be linked later)
+  guardian: z6.object({
+    firstName: z6.string().min(1).max(100),
+    middleName: z6.string().max(100).optional(),
+    lastName: z6.string().min(1).max(100),
+    relationship: z6.string().min(1).max(50).meta({
+      description: "e.g. mother, father, uncle, guardian"
+    }),
+    phone: z6.string().min(9).max(30),
+    email: z6.email().optional(),
+    nationalId: z6.string().max(20).optional(),
+    occupation: z6.string().max(100).optional()
+  }).optional()
+});
+var StudentProfileSchema = z6.object({
+  id: UuidSchema,
+  branchId: UuidSchema,
+  admissionNo: z6.string(),
+  nemisNo: z6.string().nullable(),
+  firstName: z6.string(),
+  middleName: z6.string().nullable(),
+  lastName: z6.string(),
+  dateOfBirth: z6.string(),
+  gender: GenderSchema,
+  photoUrl: z6.string().nullable(),
+  bloodGroup: z6.string().nullable(),
+  medicalNotes: z6.string().nullable(),
+  admissionDate: z6.string(),
+  status: StudentStatusSchema,
+  createdAt: z6.string(),
+  // Current class (from latest enrollment)
+  currentClass: z6.object({
+    classId: UuidSchema,
+    className: z6.string(),
+    gradeLevel: GradeLevelSchema,
+    termId: UuidSchema,
+    termName: z6.string()
+  }).nullable(),
+  // Guardians
+  guardians: z6.array(z6.object({
+    id: UuidSchema,
+    firstName: z6.string(),
+    middleName: z6.string().nullable(),
+    lastName: z6.string(),
+    relationship: z6.string(),
+    phone: z6.string(),
+    email: z6.string().nullable(),
+    isPrimary: z6.boolean()
+  }))
+});
+var StudentListItemSchema = z6.object({
+  id: UuidSchema,
+  admissionNo: z6.string(),
+  firstName: z6.string(),
+  middleName: z6.string().nullable(),
+  lastName: z6.string(),
+  gender: GenderSchema,
+  status: StudentStatusSchema,
+  className: z6.string().nullable(),
+  gradeLevel: GradeLevelSchema.nullable(),
+  primaryGuardianName: z6.string().nullable(),
+  primaryGuardianPhone: z6.string().nullable(),
+  createdAt: z6.string()
+});
+var ListStudentsInputSchema = PaginationInputSchema.extend({
+  search: z6.string().optional().meta({
+    description: "Search by name or admission number"
+  }),
+  classId: UuidSchema.optional(),
+  gradeLevel: GradeLevelSchema.optional(),
+  status: StudentStatusSchema.optional(),
+  termId: UuidSchema.optional()
+});
+var BulkUploadStudentRowSchema = z6.object({
+  firstName: z6.string().min(1),
+  middleName: z6.string().optional(),
+  lastName: z6.string().min(1),
+  dateOfBirth: z6.string().min(1).meta({ description: "Any parseable date string" }),
+  gender: z6.string().min(1).meta({ description: "male | female (case-insensitive)" }),
+  admissionNo: z6.string().min(1),
+  nemisNo: z6.string().optional(),
+  admissionDate: z6.string().optional(),
+  bloodGroup: z6.string().optional(),
+  // Guardian columns (all optional in CSV)
+  guardianFirstName: z6.string().optional(),
+  guardianLastName: z6.string().optional(),
+  guardianRelationship: z6.string().optional(),
+  guardianPhone: z6.string().optional(),
+  guardianEmail: z6.string().optional()
+});
+var BulkUploadStudentsInputSchema = z6.object({
+  classId: UuidSchema.meta({
+    description: "Class to enrol all uploaded students into"
+  }),
+  termId: UuidSchema,
+  rows: z6.array(BulkUploadStudentRowSchema).min(1).max(500)
+});
+var BulkUploadStudentsOutputSchema = z6.object({
+  created: z6.int().nonnegative(),
+  skipped: z6.int().nonnegative(),
+  errors: z6.array(z6.object({
+    row: z6.int().positive(),
+    admissionNo: z6.string().optional(),
+    reason: z6.string()
+  }))
+});
+var CreateStudentOutputSchema = z6.object({
+  studentId: UuidSchema,
+  admissionNo: z6.string()
+});
+var LinkGuardianInputSchema = z6.object({
+  studentId: UuidSchema,
+  firstName: z6.string().min(1).max(100),
+  middleName: z6.string().max(100).optional(),
+  lastName: z6.string().min(1).max(100),
+  relationship: z6.string().min(1).max(50),
+  phone: z6.string().min(9).max(30),
+  email: z6.email().optional(),
+  nationalId: z6.string().max(20).optional(),
+  occupation: z6.string().max(100).optional(),
+  isPrimary: z6.boolean().default(false)
+});
+var ClassSummarySchema = z6.object({
+  id: UuidSchema,
+  name: z6.string(),
+  gradeLevel: GradeLevelSchema,
+  gradeName: z6.string(),
+  capacity: z6.number().nullable(),
+  enrolledCount: z6.number(),
+  classTeacherId: UuidSchema.nullable()
+});
+
+// src/contracts/students.ts
+var EmptyOutput2 = z7.object({});
+var createStudentContract = import_contract3.oc.route({ method: "POST", path: "/students" }).input(CreateStudentInputSchema).output(CreateStudentOutputSchema);
+var bulkUploadStudentsContract = import_contract3.oc.route({ method: "POST", path: "/students/bulk" }).input(BulkUploadStudentsInputSchema).output(BulkUploadStudentsOutputSchema);
+var listStudentsContract = import_contract3.oc.route({ method: "GET", path: "/students" }).input(ListStudentsInputSchema).output(z7.object({
+  items: z7.array(StudentListItemSchema),
+  total: z7.number(),
+  nextCursor: UuidSchema.nullable()
+}));
+var getStudentByIdContract = import_contract3.oc.route({ method: "GET", path: "/students/{id}" }).input(z7.object({ id: UuidSchema })).output(StudentProfileSchema);
+var linkGuardianContract = import_contract3.oc.route({ method: "POST", path: "/students/guardians" }).input(LinkGuardianInputSchema).output(z7.object({ guardianId: UuidSchema }));
+var listClassesContract = import_contract3.oc.route({ method: "GET", path: "/students/classes" }).input(z7.object({
+  termId: UuidSchema.optional(),
+  gradeLevel: z7.string().optional()
+})).output(z7.array(ClassSummarySchema));
+var studentsContract = {
+  create: createStudentContract,
+  bulkUpload: bulkUploadStudentsContract,
+  list: listStudentsContract,
+  getById: getStudentByIdContract,
+  linkGuardian: linkGuardianContract,
+  listClasses: listClassesContract
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authContract,
+  bulkUploadStudentsContract,
+  changePasswordContract,
+  createDepartmentContract,
+  createStaffContract,
+  createStudentContract,
+  getMeContract,
+  getStaffByIdContract,
+  getStudentByIdContract,
+  hrContract,
+  linkGuardianContract,
+  listClassesContract,
+  listDepartmentsContract,
+  listStaffContract,
+  listStudentsContract,
+  loginContract,
+  logoutContract,
+  refreshTokenContract,
+  requestPasswordResetContract,
+  resetPasswordContract,
+  studentsContract,
+  switchBranchContract,
+  updateStaffStatusContract
+});
+//# sourceMappingURL=index.cjs.map