@brite-future-schools-contracts/contracts 1.0.0

package/dist/index.js

@@ -0,0 +1,1229 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  academicsContract: () => academicsContract,
+  adminContract: () => adminContract,
+  appContract: () => appContract,
+  assessmentScoreInputSchema: () => assessmentScoreInputSchema,
+  assessmentTypeEnum: () => assessmentTypeEnum,
+  assetCategoryEnum: () => assetCategoryEnum,
+  assetConditionEnum: () => assetConditionEnum,
+  assetsContract: () => assetsContract,
+  authContract: () => authContract,
+  borrowingStatusEnum: () => borrowingStatusEnum,
+  branchSchema: () => branchSchema,
+  branchesContract: () => branchesContract,
+  busRegisterEntrySchema: () => busRegisterEntrySchema,
+  busRegisterStatusEnum: () => busRegisterStatusEnum,
+  changePasswordInputSchema: () => changePasswordInputSchema,
+  commsContract: () => commsContract,
+  createBranchInputSchema: () => createBranchInputSchema,
+  createStudentInputSchema: () => createStudentInputSchema,
+  dateRangeSchema: () => dateRangeSchema,
+  disciplineContract: () => disciplineContract,
+  disciplineRulingEnum: () => disciplineRulingEnum,
+  employmentTypeEnum: () => employmentTypeEnum,
+  feeItemCategoryEnum: () => feeItemCategoryEnum,
+  feeItemSchema: () => feeItemSchema,
+  financeContract: () => financeContract,
+  genderEnum: () => genderEnum,
+  gradeLevelEnum: () => gradeLevelEnum,
+  guardianSchema: () => guardianSchema,
+  hrContract: () => hrContract,
+  incidentSeverityEnum: () => incidentSeverityEnum,
+  incidentStatusEnum: () => incidentStatusEnum,
+  invoiceStatusEnum: () => invoiceStatusEnum,
+  leaveRequestInputSchema: () => leaveRequestInputSchema,
+  leaveStatusEnum: () => leaveStatusEnum,
+  libraryContract: () => libraryContract,
+  listStudentsInputSchema: () => listStudentsInputSchema,
+  loginInputSchema: () => loginInputSchema,
+  loginOutputSchema: () => loginOutputSchema,
+  maintenanceTicketStatusEnum: () => maintenanceTicketStatusEnum,
+  mfaVerifyInputSchema: () => mfaVerifyInputSchema,
+  notificationTypeEnum: () => notificationTypeEnum,
+  paginationSchema: () => paginationSchema,
+  paymentMethodEnum: () => paymentMethodEnum,
+  payrollContract: () => payrollContract,
+  payrollRunStatusEnum: () => payrollRunStatusEnum,
+  recordPaymentInputSchema: () => recordPaymentInputSchema,
+  refreshInputSchema: () => refreshInputSchema,
+  refreshTokenOutputSchema: () => refreshTokenOutputSchema,
+  reportCardStatusEnum: () => reportCardStatusEnum,
+  rubricBandEnum: () => rubricBandEnum,
+  sendBulkSmsInputSchema: () => sendBulkSmsInputSchema,
+  sponsorSchema: () => sponsorSchema,
+  sponsorTypeEnum: () => sponsorTypeEnum,
+  staffSchema: () => staffSchema,
+  storageContract: () => storageContract,
+  studentSchema: () => studentSchema,
+  studentStatusEnum: () => studentStatusEnum,
+  studentsContract: () => studentsContract,
+  subjectSchema: () => subjectSchema,
+  systemRoleEnum: () => systemRoleEnum,
+  transportContract: () => transportContract,
+  tripLogInputSchema: () => tripLogInputSchema,
+  userSchema: () => userSchema,
+  userStatusEnum: () => userStatusEnum,
+  uuidSchema: () => uuidSchema,
+  vehicleOwnershipEnum: () => vehicleOwnershipEnum,
+  vehicleTypeEnum: () => vehicleTypeEnum
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/schemas/index.ts
+var import_zod = require("zod");
+var uuidSchema = import_zod.z.string().uuid();
+var paginationSchema = import_zod.z.object({
+  page: import_zod.z.number().int().min(1).default(1),
+  limit: import_zod.z.number().int().min(1).max(100).default(20)
+});
+var dateRangeSchema = import_zod.z.object({
+  from: import_zod.z.string().datetime().optional(),
+  to: import_zod.z.string().datetime().optional()
+});
+var genderEnum = import_zod.z.enum(["male", "female"]);
+var userStatusEnum = import_zod.z.enum(["active", "inactive", "suspended"]);
+var systemRoleEnum = import_zod.z.enum([
+  "DIRECTOR",
+  "PRINCIPAL",
+  "DEPUTY_PRINCIPAL",
+  "HOD",
+  "CLASS_TEACHER",
+  "SUBJECT_TEACHER",
+  "BURSAR",
+  "HR_ADMIN",
+  "SCHOOL_NURSE",
+  "LIBRARIAN",
+  "LAB_TECHNICIAN",
+  "SPORTS_COACH",
+  "COUNSELLOR",
+  "CARETAKER",
+  "SECURITY",
+  "KITCHEN_STAFF",
+  "DRIVER",
+  "IT_ADMIN",
+  "STUDENT",
+  "PARENT",
+  "ORG_SPONSOR",
+  "INDIVIDUAL_SPONSOR"
+]);
+var loginInputSchema = import_zod.z.object({
+  email: import_zod.z.string().email(),
+  password: import_zod.z.string().min(8),
+  deviceFingerprint: import_zod.z.string().optional()
+});
+var loginOutputSchema = import_zod.z.object({
+  accessToken: import_zod.z.string(),
+  refreshToken: import_zod.z.string().optional(),
+  user: import_zod.z.object({
+    id: uuidSchema,
+    firstName: import_zod.z.string(),
+    middleName: import_zod.z.string().nullable(),
+    lastName: import_zod.z.string(),
+    email: import_zod.z.string().email(),
+    avatarUrl: import_zod.z.string().nullable(),
+    roles: import_zod.z.array(
+      import_zod.z.object({
+        id: uuidSchema,
+        name: import_zod.z.string(),
+        branchId: uuidSchema.nullable()
+      })
+    ),
+    activeBranchId: uuidSchema.nullable(),
+    isMfaEnabled: import_zod.z.boolean()
+  })
+});
+var refreshTokenOutputSchema = import_zod.z.object({
+  accessToken: import_zod.z.string()
+});
+var refreshInputSchema = import_zod.z.object({
+  refreshToken: import_zod.z.string().optional()
+});
+var mfaVerifyInputSchema = import_zod.z.object({
+  totp: import_zod.z.string().length(6)
+});
+var changePasswordInputSchema = import_zod.z.object({
+  currentPassword: import_zod.z.string().min(8),
+  newPassword: import_zod.z.string().min(8)
+});
+var userSchema = import_zod.z.object({
+  id: uuidSchema,
+  firstName: import_zod.z.string(),
+  middleName: import_zod.z.string().nullable(),
+  lastName: import_zod.z.string(),
+  email: import_zod.z.string().email(),
+  phone: import_zod.z.string().nullable(),
+  avatarUrl: import_zod.z.string().nullable(),
+  isActive: import_zod.z.boolean(),
+  isMfaEnabled: import_zod.z.boolean(),
+  lastLoginAt: import_zod.z.string().datetime().nullable(),
+  createdAt: import_zod.z.string().datetime()
+});
+var branchSchema = import_zod.z.object({
+  id: uuidSchema,
+  name: import_zod.z.string(),
+  code: import_zod.z.string(),
+  address: import_zod.z.string(),
+  county: import_zod.z.string(),
+  phone: import_zod.z.string().nullable(),
+  email: import_zod.z.string().email().nullable(),
+  logoUrl: import_zod.z.string().nullable(),
+  motto: import_zod.z.string().nullable(),
+  principalId: uuidSchema.nullable(),
+  mpesaPaybill: import_zod.z.string().nullable(),
+  featureFlags: import_zod.z.record(import_zod.z.boolean()),
+  createdAt: import_zod.z.string().datetime()
+});
+var createBranchInputSchema = import_zod.z.object({
+  name: import_zod.z.string().min(2).max(100),
+  code: import_zod.z.string().min(2).max(20),
+  address: import_zod.z.string(),
+  county: import_zod.z.string(),
+  phone: import_zod.z.string().optional(),
+  email: import_zod.z.string().email().optional(),
+  motto: import_zod.z.string().optional()
+});
+var studentStatusEnum = import_zod.z.enum([
+  "active",
+  "transferred",
+  "graduated",
+  "suspended",
+  "withdrawn"
+]);
+var studentSchema = import_zod.z.object({
+  id: uuidSchema,
+  branchId: uuidSchema,
+  admissionNo: import_zod.z.string(),
+  nemisNo: import_zod.z.string().nullable(),
+  firstName: import_zod.z.string(),
+  middleName: import_zod.z.string().nullable(),
+  lastName: import_zod.z.string(),
+  dateOfBirth: import_zod.z.string(),
+  gender: genderEnum,
+  photoUrl: import_zod.z.string().nullable(),
+  bloodGroup: import_zod.z.string().nullable(),
+  admissionDate: import_zod.z.string(),
+  status: studentStatusEnum,
+  currentClassId: uuidSchema.nullable(),
+  createdAt: import_zod.z.string().datetime()
+});
+var createStudentInputSchema = import_zod.z.object({
+  admissionNo: import_zod.z.string().min(1),
+  nemisNo: import_zod.z.string().optional(),
+  firstName: import_zod.z.string().min(1).max(100),
+  middleName: import_zod.z.string().max(100).optional(),
+  lastName: import_zod.z.string().min(1).max(100),
+  dateOfBirth: import_zod.z.string(),
+  gender: genderEnum,
+  admissionDate: import_zod.z.string(),
+  guardianId: uuidSchema.optional()
+});
+var listStudentsInputSchema = paginationSchema.extend({
+  branchId: uuidSchema.optional(),
+  classId: uuidSchema.optional(),
+  search: import_zod.z.string().optional(),
+  status: studentStatusEnum.optional(),
+  termId: uuidSchema.optional()
+});
+var guardianSchema = import_zod.z.object({
+  id: uuidSchema,
+  userId: uuidSchema,
+  firstName: import_zod.z.string(),
+  middleName: import_zod.z.string().nullable(),
+  lastName: import_zod.z.string(),
+  relationship: import_zod.z.string(),
+  phone: import_zod.z.string(),
+  email: import_zod.z.string().email().nullable(),
+  nationalId: import_zod.z.string().nullable(),
+  occupation: import_zod.z.string().nullable(),
+  address: import_zod.z.string().nullable()
+});
+var sponsorTypeEnum = import_zod.z.enum(["organisation", "individual"]);
+var sponsorSchema = import_zod.z.object({
+  id: uuidSchema,
+  branchId: uuidSchema,
+  type: sponsorTypeEnum,
+  organisationName: import_zod.z.string().nullable(),
+  firstName: import_zod.z.string().nullable(),
+  middleName: import_zod.z.string().nullable(),
+  lastName: import_zod.z.string().nullable(),
+  contactUserId: uuidSchema.nullable(),
+  phone: import_zod.z.string(),
+  email: import_zod.z.string().email().nullable(),
+  address: import_zod.z.string().nullable()
+});
+var gradeLevelEnum = import_zod.z.enum([
+  "PP1",
+  "PP2",
+  "G1",
+  "G2",
+  "G3",
+  "G4",
+  "G5",
+  "G6",
+  "G7",
+  "G8",
+  "G9"
+]);
+var assessmentTypeEnum = import_zod.z.enum([
+  "formative",
+  "summative",
+  "knec_national",
+  "informal"
+]);
+var rubricBandEnum = import_zod.z.enum(["EE", "ME", "AE", "BE"]);
+var subjectSchema = import_zod.z.object({
+  id: uuidSchema,
+  branchId: uuidSchema,
+  name: import_zod.z.string(),
+  code: import_zod.z.string(),
+  gradeLevel: gradeLevelEnum,
+  departmentId: uuidSchema.nullable()
+});
+var assessmentScoreInputSchema = import_zod.z.object({
+  assessmentId: uuidSchema,
+  studentId: uuidSchema,
+  subStrandId: uuidSchema,
+  numericScore: import_zod.z.number().min(0).max(100),
+  comments: import_zod.z.string().optional()
+});
+var reportCardStatusEnum = import_zod.z.enum([
+  "draft",
+  "hod_review",
+  "principal_review",
+  "released",
+  "blocked"
+]);
+var feeItemCategoryEnum = import_zod.z.enum([
+  "compulsory",
+  "class_specific",
+  "additive"
+]);
+var paymentMethodEnum = import_zod.z.enum([
+  "mpesa",
+  "bank",
+  "card",
+  "cash",
+  "cheque"
+]);
+var invoiceStatusEnum = import_zod.z.enum([
+  "draft",
+  "sent",
+  "partial",
+  "paid",
+  "overdue",
+  "cancelled"
+]);
+var feeItemSchema = import_zod.z.object({
+  id: uuidSchema,
+  branchId: uuidSchema,
+  name: import_zod.z.string(),
+  category: feeItemCategoryEnum,
+  defaultAmount: import_zod.z.number(),
+  applicableGrades: import_zod.z.array(gradeLevelEnum),
+  isActive: import_zod.z.boolean()
+});
+var recordPaymentInputSchema = import_zod.z.object({
+  studentId: uuidSchema,
+  invoiceId: uuidSchema,
+  amount: import_zod.z.number().positive(),
+  method: paymentMethodEnum,
+  reference: import_zod.z.string().optional(),
+  mpesaReceipt: import_zod.z.string().optional(),
+  paymentDate: import_zod.z.string()
+});
+var employmentTypeEnum = import_zod.z.enum([
+  "permanent",
+  "contract",
+  "temporary",
+  "intern"
+]);
+var staffSchema = import_zod.z.object({
+  id: uuidSchema,
+  branchId: uuidSchema,
+  userId: uuidSchema,
+  firstName: import_zod.z.string(),
+  middleName: import_zod.z.string().nullable(),
+  lastName: import_zod.z.string(),
+  tscNumber: import_zod.z.string().nullable(),
+  nationalId: import_zod.z.string(),
+  kraPin: import_zod.z.string().nullable(),
+  nhifNo: import_zod.z.string().nullable(),
+  nssfNo: import_zod.z.string().nullable(),
+  phone: import_zod.z.string(),
+  departmentId: uuidSchema.nullable(),
+  designation: import_zod.z.string(),
+  employmentType: employmentTypeEnum,
+  contractStart: import_zod.z.string(),
+  contractEnd: import_zod.z.string().nullable(),
+  basicSalary: import_zod.z.number(),
+  houseAllowance: import_zod.z.number().default(0),
+  transportAllowance: import_zod.z.number().default(0),
+  bankName: import_zod.z.string().nullable(),
+  bankAccount: import_zod.z.string().nullable(),
+  status: userStatusEnum
+});
+var leaveStatusEnum = import_zod.z.enum([
+  "pending",
+  "approved",
+  "rejected",
+  "cancelled"
+]);
+var leaveRequestInputSchema = import_zod.z.object({
+  leaveTypeId: uuidSchema,
+  startDate: import_zod.z.string(),
+  endDate: import_zod.z.string(),
+  reason: import_zod.z.string().min(10)
+});
+var vehicleOwnershipEnum = import_zod.z.enum(["owned", "contracted"]);
+var vehicleTypeEnum = import_zod.z.enum(["bus", "van", "pickup", "other"]);
+var busRegisterStatusEnum = import_zod.z.enum(["boarded", "alighted", "absent"]);
+var tripLogInputSchema = import_zod.z.object({
+  vehicleId: uuidSchema,
+  routeId: uuidSchema,
+  departureTime: import_zod.z.string().datetime(),
+  tripType: import_zod.z.enum(["morning", "evening", "errand"])
+});
+var busRegisterEntrySchema = import_zod.z.object({
+  studentId: uuidSchema,
+  status: busRegisterStatusEnum
+});
+var assetCategoryEnum = import_zod.z.enum([
+  "furniture",
+  "lab_equipment",
+  "ict_device",
+  "vehicle",
+  "sports_equipment",
+  "kitchen_equipment",
+  "musical_instrument",
+  "classroom_supply",
+  "library_book",
+  "other"
+]);
+var assetConditionEnum = import_zod.z.enum([
+  "excellent",
+  "good",
+  "fair",
+  "poor",
+  "condemned"
+]);
+var maintenanceTicketStatusEnum = import_zod.z.enum([
+  "open",
+  "in_progress",
+  "resolved",
+  "closed"
+]);
+var borrowingStatusEnum = import_zod.z.enum([
+  "active",
+  "returned",
+  "overdue",
+  "lost"
+]);
+var incidentSeverityEnum = import_zod.z.enum([
+  "minor",
+  "moderate",
+  "serious",
+  "critical"
+]);
+var incidentStatusEnum = import_zod.z.enum([
+  "open",
+  "counsellor_review",
+  "hod_review",
+  "principal_ruling",
+  "resolved"
+]);
+var disciplineRulingEnum = import_zod.z.enum([
+  "verbal_warning",
+  "written_warning",
+  "suspension",
+  "expulsion",
+  "dismissed"
+]);
+var payrollRunStatusEnum = import_zod.z.enum(["draft", "approved", "paid"]);
+var notificationTypeEnum = import_zod.z.enum([
+  "report_card",
+  "fee_invoice",
+  "fee_reminder",
+  "fee_block",
+  "attendance_absent",
+  "bus_departed",
+  "bus_arrived",
+  "discipline_incident",
+  "assignment",
+  "notice",
+  "leave",
+  "payslip"
+]);
+var sendBulkSmsInputSchema = import_zod.z.object({
+  branchId: uuidSchema,
+  message: import_zod.z.string().min(1).max(160),
+  recipientType: import_zod.z.enum(["class", "grade", "whole_school", "custom"]),
+  recipientIds: import_zod.z.array(uuidSchema).optional(),
+  scheduleAt: import_zod.z.string().datetime().optional()
+});
+
+// src/contracts/index.ts
+var import_contract = require("@orpc/contract");
+var import_zod2 = require("zod");
+var authContract = {
+  login: import_contract.oc.input(loginInputSchema).output(loginOutputSchema),
+  refresh: import_contract.oc.input(refreshInputSchema).output(refreshTokenOutputSchema),
+  logout: import_contract.oc.output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+  me: import_contract.oc.output(
+    userSchema.extend({
+      roles: import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          name: import_zod2.z.string(),
+          branchId: uuidSchema.nullable()
+        })
+      )
+    })
+  ),
+  verifyMfa: import_contract.oc.input(mfaVerifyInputSchema).output(import_zod2.z.object({ verified: import_zod2.z.boolean() })),
+  changePassword: import_contract.oc.input(changePasswordInputSchema).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+  switchBranch: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema })).output(import_zod2.z.object({ accessToken: import_zod2.z.string() }))
+};
+var branchesContract = {
+  list: import_contract.oc.output(import_zod2.z.array(branchSchema)),
+  get: import_contract.oc.input(import_zod2.z.object({ id: uuidSchema })).output(branchSchema),
+  create: import_contract.oc.input(createBranchInputSchema).output(branchSchema),
+  update: import_contract.oc.input(createBranchInputSchema.partial().extend({ id: uuidSchema })).output(branchSchema),
+  updateFeatureFlags: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema, flags: import_zod2.z.record(import_zod2.z.boolean()) })).output(branchSchema)
+};
+var studentWithGuardians = studentSchema.extend({
+  guardians: import_zod2.z.array(guardianSchema),
+  sponsors: import_zod2.z.array(sponsorSchema),
+  currentClass: import_zod2.z.object({ id: uuidSchema, name: import_zod2.z.string(), grade: import_zod2.z.string() }).nullable()
+});
+var studentsContract = {
+  list: import_contract.oc.input(listStudentsInputSchema).output(
+    import_zod2.z.object({
+      data: import_zod2.z.array(studentSchema),
+      total: import_zod2.z.number(),
+      page: import_zod2.z.number(),
+      limit: import_zod2.z.number()
+    })
+  ),
+  get: import_contract.oc.input(import_zod2.z.object({ id: uuidSchema })).output(studentWithGuardians),
+  create: import_contract.oc.input(createStudentInputSchema).output(studentSchema),
+  update: import_contract.oc.input(createStudentInputSchema.partial().extend({ id: uuidSchema })).output(studentSchema),
+  enroll: import_contract.oc.input(
+    import_zod2.z.object({
+      studentId: uuidSchema,
+      classId: uuidSchema,
+      termId: uuidSchema
+    })
+  ).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+  transfer: import_contract.oc.input(
+    import_zod2.z.object({
+      studentId: uuidSchema,
+      toBranchId: uuidSchema,
+      reason: import_zod2.z.string()
+    })
+  ).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+  linkGuardian: import_contract.oc.input(
+    import_zod2.z.object({
+      studentId: uuidSchema,
+      guardianId: uuidSchema,
+      isPrimary: import_zod2.z.boolean()
+    })
+  ).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+  linkSponsor: import_contract.oc.input(
+    import_zod2.z.object({
+      studentId: uuidSchema,
+      sponsorId: uuidSchema,
+      termId: uuidSchema,
+      feeItemIds: import_zod2.z.array(uuidSchema)
+    })
+  ).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+};
+var academicsContract = {
+  subjects: {
+    list: import_contract.oc.input(
+      import_zod2.z.object({
+        branchId: uuidSchema,
+        gradeLevel: gradeLevelEnum.optional()
+      })
+    ).output(import_zod2.z.array(subjectSchema)),
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        name: import_zod2.z.string(),
+        code: import_zod2.z.string(),
+        gradeLevel: gradeLevelEnum,
+        departmentId: uuidSchema.optional()
+      })
+    ).output(subjectSchema)
+  },
+  timetable: {
+    get: import_contract.oc.input(import_zod2.z.object({ classId: uuidSchema, termId: uuidSchema })).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          dayOfWeek: import_zod2.z.number().min(1).max(5),
+          periodNo: import_zod2.z.number(),
+          subject: subjectSchema,
+          teacherName: import_zod2.z.string(),
+          room: import_zod2.z.string().nullable(),
+          startTime: import_zod2.z.string(),
+          endTime: import_zod2.z.string()
+        })
+      )
+    ),
+    upsert: import_contract.oc.input(
+      import_zod2.z.object({
+        classId: uuidSchema,
+        termId: uuidSchema,
+        slots: import_zod2.z.array(
+          import_zod2.z.object({
+            dayOfWeek: import_zod2.z.number().min(1).max(5),
+            periodNo: import_zod2.z.number(),
+            subjectId: uuidSchema,
+            teacherId: uuidSchema,
+            room: import_zod2.z.string().optional(),
+            startTime: import_zod2.z.string(),
+            endTime: import_zod2.z.string()
+          })
+        )
+      })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  },
+  assessments: {
+    list: import_contract.oc.input(
+      import_zod2.z.object({
+        classId: uuidSchema,
+        termId: uuidSchema,
+        type: assessmentTypeEnum.optional()
+      })
+    ).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          title: import_zod2.z.string(),
+          type: assessmentTypeEnum,
+          date: import_zod2.z.string(),
+          maxScore: import_zod2.z.number(),
+          subjectId: uuidSchema
+        })
+      )
+    ),
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        title: import_zod2.z.string(),
+        type: assessmentTypeEnum,
+        classId: uuidSchema,
+        subjectId: uuidSchema,
+        termId: uuidSchema,
+        date: import_zod2.z.string(),
+        maxScore: import_zod2.z.number()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema })),
+    enterScores: import_contract.oc.input(import_zod2.z.object({ scores: import_zod2.z.array(assessmentScoreInputSchema) })).output(import_zod2.z.object({ saved: import_zod2.z.number() }))
+  },
+  reportCards: {
+    list: import_contract.oc.input(
+      import_zod2.z.object({
+        branchId: uuidSchema,
+        termId: uuidSchema,
+        classId: uuidSchema.optional(),
+        status: reportCardStatusEnum.optional()
+      })
+    ).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          studentId: uuidSchema,
+          studentName: import_zod2.z.string(),
+          status: reportCardStatusEnum,
+          generatedAt: import_zod2.z.string().datetime().nullable()
+        })
+      )
+    ),
+    get: import_contract.oc.input(import_zod2.z.object({ studentId: uuidSchema, termId: uuidSchema })).output(
+      import_zod2.z.object({
+        id: uuidSchema,
+        studentId: uuidSchema,
+        termId: uuidSchema,
+        status: reportCardStatusEnum,
+        scores: import_zod2.z.array(import_zod2.z.any()),
+        teacherComments: import_zod2.z.string().nullable(),
+        generatedAt: import_zod2.z.string().datetime().nullable()
+      })
+    ),
+    updateStatus: import_contract.oc.input(
+      import_zod2.z.object({
+        id: uuidSchema,
+        status: reportCardStatusEnum,
+        comments: import_zod2.z.string().optional()
+      })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  },
+  attendance: {
+    markClass: import_contract.oc.input(
+      import_zod2.z.object({
+        classId: uuidSchema,
+        date: import_zod2.z.string(),
+        subjectId: uuidSchema,
+        records: import_zod2.z.array(
+          import_zod2.z.object({
+            studentId: uuidSchema,
+            present: import_zod2.z.boolean(),
+            note: import_zod2.z.string().optional()
+          })
+        )
+      })
+    ).output(import_zod2.z.object({ saved: import_zod2.z.number() })),
+    getClassAttendance: import_contract.oc.input(
+      import_zod2.z.object({ classId: uuidSchema, from: import_zod2.z.string(), to: import_zod2.z.string() })
+    ).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          studentId: uuidSchema,
+          studentName: import_zod2.z.string(),
+          presentDays: import_zod2.z.number(),
+          absentDays: import_zod2.z.number(),
+          percentage: import_zod2.z.number()
+        })
+      )
+    )
+  }
+};
+var financeContract = {
+  feeItems: {
+    list: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema })).output(import_zod2.z.array(feeItemSchema)),
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        name: import_zod2.z.string(),
+        category: import_zod2.z.any(),
+        defaultAmount: import_zod2.z.number(),
+        applicableGrades: import_zod2.z.array(gradeLevelEnum)
+      })
+    ).output(feeItemSchema)
+  },
+  invoices: {
+    listForStudent: import_contract.oc.input(import_zod2.z.object({ studentId: uuidSchema, termId: uuidSchema.optional() })).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          termId: uuidSchema,
+          payerType: import_zod2.z.string(),
+          totalAmount: import_zod2.z.number(),
+          paidAmount: import_zod2.z.number(),
+          balance: import_zod2.z.number(),
+          status: invoiceStatusEnum,
+          dueDate: import_zod2.z.string().nullable()
+        })
+      )
+    ),
+    generate: import_contract.oc.input(
+      import_zod2.z.object({
+        branchId: uuidSchema,
+        termId: uuidSchema,
+        studentIds: import_zod2.z.array(uuidSchema).optional()
+      })
+    ).output(import_zod2.z.object({ generated: import_zod2.z.number() }))
+  },
+  payments: {
+    record: import_contract.oc.input(recordPaymentInputSchema).output(import_zod2.z.object({ id: uuidSchema, receipt: import_zod2.z.string() })),
+    listForStudent: import_contract.oc.input(import_zod2.z.object({ studentId: uuidSchema })).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          amount: import_zod2.z.number(),
+          method: import_zod2.z.string(),
+          reference: import_zod2.z.string().nullable(),
+          paymentDate: import_zod2.z.string(),
+          createdAt: import_zod2.z.string()
+        })
+      )
+    )
+  },
+  blocks: {
+    list: import_contract.oc.input(
+      import_zod2.z.object({
+        branchId: uuidSchema,
+        termId: uuidSchema,
+        active: import_zod2.z.boolean().optional()
+      })
+    ).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          studentId: uuidSchema,
+          studentName: import_zod2.z.string(),
+          blockType: import_zod2.z.string(),
+          isActive: import_zod2.z.boolean(),
+          balanceAtBlock: import_zod2.z.number()
+        })
+      )
+    ),
+    lift: import_contract.oc.input(import_zod2.z.object({ blockId: uuidSchema, reason: import_zod2.z.string() })).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  },
+  reports: {
+    termCollection: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema, termId: uuidSchema })).output(
+      import_zod2.z.object({
+        totalExpected: import_zod2.z.number(),
+        totalCollected: import_zod2.z.number(),
+        totalOutstanding: import_zod2.z.number(),
+        collectionRate: import_zod2.z.number(),
+        byPaymentMethod: import_zod2.z.record(import_zod2.z.number())
+      })
+    )
+  }
+};
+var hrContract = {
+  staff: {
+    list: import_contract.oc.input(
+      paginationSchema.extend({
+        branchId: uuidSchema,
+        search: import_zod2.z.string().optional(),
+        departmentId: uuidSchema.optional()
+      })
+    ).output(import_zod2.z.object({ data: import_zod2.z.array(staffSchema), total: import_zod2.z.number() })),
+    get: import_contract.oc.input(import_zod2.z.object({ id: uuidSchema })).output(staffSchema),
+    create: import_contract.oc.input(
+      staffSchema.omit({ id: true }).partial({
+        contractEnd: true,
+        tscNumber: true,
+        kraPin: true,
+        nhifNo: true,
+        nssfNo: true,
+        bankName: true,
+        bankAccount: true,
+        departmentId: true
+      })
+    ).output(staffSchema)
+  },
+  leave: {
+    request: import_contract.oc.input(leaveRequestInputSchema).output(import_zod2.z.object({ id: uuidSchema })),
+    list: import_contract.oc.input(
+      import_zod2.z.object({
+        branchId: uuidSchema,
+        staffId: uuidSchema.optional(),
+        status: leaveStatusEnum.optional()
+      })
+    ).output(import_zod2.z.array(import_zod2.z.any())),
+    approve: import_contract.oc.input(
+      import_zod2.z.object({
+        id: uuidSchema,
+        approved: import_zod2.z.boolean(),
+        comment: import_zod2.z.string().optional()
+      })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  },
+  attendance: {
+    mark: import_contract.oc.input(
+      import_zod2.z.object({
+        staffId: uuidSchema,
+        date: import_zod2.z.string(),
+        checkIn: import_zod2.z.string().optional(),
+        checkOut: import_zod2.z.string().optional(),
+        status: import_zod2.z.enum(["present", "absent", "late", "half_day"])
+      })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+    getSummary: import_contract.oc.input(
+      import_zod2.z.object({ staffId: uuidSchema, month: import_zod2.z.number(), year: import_zod2.z.number() })
+    ).output(
+      import_zod2.z.object({
+        presentDays: import_zod2.z.number(),
+        absentDays: import_zod2.z.number(),
+        lateDays: import_zod2.z.number()
+      })
+    )
+  }
+};
+var payrollContract = {
+  runs: {
+    list: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema, year: import_zod2.z.number().optional() })).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          month: import_zod2.z.number(),
+          year: import_zod2.z.number(),
+          status: payrollRunStatusEnum,
+          netTotal: import_zod2.z.number()
+        })
+      )
+    ),
+    initiate: import_contract.oc.input(
+      import_zod2.z.object({ branchId: uuidSchema, month: import_zod2.z.number(), year: import_zod2.z.number() })
+    ).output(import_zod2.z.object({ id: uuidSchema, preview: import_zod2.z.array(import_zod2.z.any()) })),
+    approve: import_contract.oc.input(import_zod2.z.object({ id: uuidSchema })).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+    getPayslip: import_contract.oc.input(import_zod2.z.object({ payrollRunId: uuidSchema, staffId: uuidSchema })).output(import_zod2.z.object({ url: import_zod2.z.string() }))
+  }
+};
+var transportContract = {
+  vehicles: {
+    list: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema })).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          plateNo: import_zod2.z.string(),
+          type: import_zod2.z.string(),
+          status: import_zod2.z.string(),
+          currentTrip: import_zod2.z.any().nullable()
+        })
+      )
+    )
+  },
+  trips: {
+    start: import_contract.oc.input(tripLogInputSchema).output(import_zod2.z.object({ id: uuidSchema })),
+    recordBoardings: import_contract.oc.input(
+      import_zod2.z.object({
+        tripId: uuidSchema,
+        entries: import_zod2.z.array(busRegisterEntrySchema)
+      })
+    ).output(import_zod2.z.object({ saved: import_zod2.z.number() })),
+    complete: import_contract.oc.input(
+      import_zod2.z.object({ tripId: uuidSchema, arrivalTime: import_zod2.z.string().datetime() })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+    reportIncident: import_contract.oc.input(
+      import_zod2.z.object({
+        tripId: uuidSchema,
+        description: import_zod2.z.string(),
+        severity: incidentSeverityEnum,
+        location: import_zod2.z.string().optional()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema }))
+  },
+  maintenance: {
+    log: import_contract.oc.input(
+      import_zod2.z.object({
+        vehicleId: uuidSchema,
+        issue: import_zod2.z.string(),
+        severity: import_zod2.z.enum(["routine", "urgent", "critical"])
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema })),
+    list: import_contract.oc.input(import_zod2.z.object({ vehicleId: uuidSchema })).output(import_zod2.z.array(import_zod2.z.any()))
+  }
+};
+var assetsContract = {
+  list: import_contract.oc.input(
+    paginationSchema.extend({
+      branchId: uuidSchema,
+      category: assetCategoryEnum.optional(),
+      search: import_zod2.z.string().optional()
+    })
+  ).output(import_zod2.z.object({ data: import_zod2.z.array(import_zod2.z.any()), total: import_zod2.z.number() })),
+  create: import_contract.oc.input(
+    import_zod2.z.object({
+      name: import_zod2.z.string(),
+      category: assetCategoryEnum,
+      serialNo: import_zod2.z.string().optional(),
+      purchaseDate: import_zod2.z.string(),
+      purchaseCost: import_zod2.z.number(),
+      supplier: import_zod2.z.string().optional(),
+      warrantyExpiry: import_zod2.z.string().optional(),
+      condition: assetConditionEnum,
+      depreciationRate: import_zod2.z.number().min(0).max(100)
+    })
+  ).output(import_zod2.z.object({ id: uuidSchema })),
+  assign: import_contract.oc.input(
+    import_zod2.z.object({
+      assetId: uuidSchema,
+      staffId: uuidSchema.optional(),
+      room: import_zod2.z.string().optional()
+    })
+  ).output(import_zod2.z.object({ success: import_zod2.z.boolean() })),
+  ticket: {
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        assetId: uuidSchema,
+        description: import_zod2.z.string(),
+        severity: import_zod2.z.string()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema })),
+    update: import_contract.oc.input(
+      import_zod2.z.object({
+        ticketId: uuidSchema,
+        status: maintenanceTicketStatusEnum,
+        notes: import_zod2.z.string().optional(),
+        cost: import_zod2.z.number().optional()
+      })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  }
+};
+var libraryContract = {
+  books: {
+    list: import_contract.oc.input(
+      paginationSchema.extend({
+        branchId: uuidSchema,
+        search: import_zod2.z.string().optional(),
+        available: import_zod2.z.boolean().optional()
+      })
+    ).output(import_zod2.z.object({ data: import_zod2.z.array(import_zod2.z.any()), total: import_zod2.z.number() })),
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        isbn: import_zod2.z.string(),
+        title: import_zod2.z.string(),
+        author: import_zod2.z.string(),
+        publisher: import_zod2.z.string().optional(),
+        year: import_zod2.z.number().optional(),
+        subjectArea: import_zod2.z.string().optional(),
+        copiesTotal: import_zod2.z.number().min(1),
+        shelfLocation: import_zod2.z.string().optional()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema }))
+  },
+  borrowings: {
+    checkout: import_contract.oc.input(
+      import_zod2.z.object({
+        bookId: uuidSchema,
+        borrowerType: import_zod2.z.enum(["student", "staff"]),
+        borrowerId: uuidSchema,
+        dueDate: import_zod2.z.string()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema })),
+    return: import_contract.oc.input(
+      import_zod2.z.object({ borrowingId: uuidSchema, condition: import_zod2.z.string().optional() })
+    ).output(import_zod2.z.object({ fine: import_zod2.z.number() })),
+    listOverdue: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema })).output(import_zod2.z.array(import_zod2.z.any()))
+  }
+};
+var disciplineContract = {
+  incidents: {
+    log: import_contract.oc.input(
+      import_zod2.z.object({
+        studentId: uuidSchema,
+        incidentType: import_zod2.z.string(),
+        description: import_zod2.z.string(),
+        severity: incidentSeverityEnum,
+        incidentDate: import_zod2.z.string(),
+        requiresCounsellor: import_zod2.z.boolean().default(false)
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema })),
+    list: import_contract.oc.input(
+      paginationSchema.extend({
+        branchId: uuidSchema,
+        studentId: uuidSchema.optional(),
+        status: incidentStatusEnum.optional()
+      })
+    ).output(import_zod2.z.object({ data: import_zod2.z.array(import_zod2.z.any()), total: import_zod2.z.number() })),
+    rule: import_contract.oc.input(
+      import_zod2.z.object({
+        incidentId: uuidSchema,
+        ruling: disciplineRulingEnum,
+        suspensionDays: import_zod2.z.number().optional(),
+        notes: import_zod2.z.string()
+      })
+    ).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  }
+};
+var commsContract = {
+  notifications: {
+    list: import_contract.oc.input(paginationSchema.extend({ unreadOnly: import_zod2.z.boolean().optional() })).output(import_zod2.z.object({ data: import_zod2.z.array(import_zod2.z.any()), unreadCount: import_zod2.z.number() })),
+    markRead: import_contract.oc.input(import_zod2.z.object({ ids: import_zod2.z.array(uuidSchema) })).output(import_zod2.z.object({ updated: import_zod2.z.number() }))
+  },
+  messages: {
+    list: import_contract.oc.input(paginationSchema).output(import_zod2.z.array(import_zod2.z.any())),
+    send: import_contract.oc.input(
+      import_zod2.z.object({
+        recipientId: uuidSchema,
+        subject: import_zod2.z.string(),
+        body: import_zod2.z.string(),
+        parentId: uuidSchema.optional()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema }))
+  },
+  sms: {
+    send: import_contract.oc.input(sendBulkSmsInputSchema).output(import_zod2.z.object({ queued: import_zod2.z.number() }))
+  },
+  notices: {
+    list: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema, active: import_zod2.z.boolean().optional() })).output(import_zod2.z.array(import_zod2.z.any())),
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        title: import_zod2.z.string(),
+        body: import_zod2.z.string(),
+        audienceType: import_zod2.z.string(),
+        audienceIds: import_zod2.z.array(uuidSchema).optional(),
+        publishAt: import_zod2.z.string().optional(),
+        expiresAt: import_zod2.z.string().optional()
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema }))
+  }
+};
+var adminContract = {
+  auditLogs: {
+    list: import_contract.oc.input(
+      paginationSchema.extend({
+        branchId: uuidSchema.optional(),
+        userId: uuidSchema.optional(),
+        action: import_zod2.z.string().optional(),
+        from: import_zod2.z.string().optional(),
+        to: import_zod2.z.string().optional()
+      })
+    ).output(import_zod2.z.object({ data: import_zod2.z.array(import_zod2.z.any()), total: import_zod2.z.number() }))
+  },
+  users: {
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        firstName: import_zod2.z.string(),
+        middleName: import_zod2.z.string().optional(),
+        lastName: import_zod2.z.string(),
+        email: import_zod2.z.string().email(),
+        phone: import_zod2.z.string().optional(),
+        roleId: uuidSchema,
+        branchId: uuidSchema,
+        temporaryPassword: import_zod2.z.string().min(8)
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema })),
+    suspend: import_contract.oc.input(import_zod2.z.object({ userId: uuidSchema, reason: import_zod2.z.string() })).output(import_zod2.z.object({ success: import_zod2.z.boolean() }))
+  },
+  roles: {
+    list: import_contract.oc.input(import_zod2.z.object({ branchId: uuidSchema })).output(
+      import_zod2.z.array(
+        import_zod2.z.object({
+          id: uuidSchema,
+          name: import_zod2.z.string(),
+          isSystem: import_zod2.z.boolean(),
+          permissionCount: import_zod2.z.number()
+        })
+      )
+    ),
+    create: import_contract.oc.input(
+      import_zod2.z.object({
+        name: import_zod2.z.string(),
+        description: import_zod2.z.string().optional(),
+        permissionIds: import_zod2.z.array(uuidSchema)
+      })
+    ).output(import_zod2.z.object({ id: uuidSchema }))
+  }
+};
+var storageContract = {
+  presignUpload: import_contract.oc.input(
+    import_zod2.z.object({
+      fileName: import_zod2.z.string(),
+      mimeType: import_zod2.z.string(),
+      category: import_zod2.z.enum([
+        "student_photo",
+        "staff_photo",
+        "document",
+        "payslip",
+        "report_card",
+        "asset_photo",
+        "notice_attachment"
+      ]),
+      resourceId: uuidSchema.optional()
+    })
+  ).output(
+    import_zod2.z.object({
+      uploadUrl: import_zod2.z.string(),
+      fileKey: import_zod2.z.string(),
+      expiresIn: import_zod2.z.number()
+    })
+  ),
+  confirmUpload: import_contract.oc.input(
+    import_zod2.z.object({
+      fileKey: import_zod2.z.string(),
+      resourceId: uuidSchema,
+      resourceType: import_zod2.z.string()
+    })
+  ).output(import_zod2.z.object({ publicUrl: import_zod2.z.string() }))
+};
+var appContract = {
+  auth: authContract,
+  branches: branchesContract,
+  students: studentsContract,
+  academics: academicsContract,
+  finance: financeContract,
+  hr: hrContract,
+  payroll: payrollContract,
+  transport: transportContract,
+  assets: assetsContract,
+  library: libraryContract,
+  discipline: disciplineContract,
+  comms: commsContract,
+  admin: adminContract,
+  storage: storageContract
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  academicsContract,
+  adminContract,
+  appContract,
+  assessmentScoreInputSchema,
+  assessmentTypeEnum,
+  assetCategoryEnum,
+  assetConditionEnum,
+  assetsContract,
+  authContract,
+  borrowingStatusEnum,
+  branchSchema,
+  branchesContract,
+  busRegisterEntrySchema,
+  busRegisterStatusEnum,
+  changePasswordInputSchema,
+  commsContract,
+  createBranchInputSchema,
+  createStudentInputSchema,
+  dateRangeSchema,
+  disciplineContract,
+  disciplineRulingEnum,
+  employmentTypeEnum,
+  feeItemCategoryEnum,
+  feeItemSchema,
+  financeContract,
+  genderEnum,
+  gradeLevelEnum,
+  guardianSchema,
+  hrContract,
+  incidentSeverityEnum,
+  incidentStatusEnum,
+  invoiceStatusEnum,
+  leaveRequestInputSchema,
+  leaveStatusEnum,
+  libraryContract,
+  listStudentsInputSchema,
+  loginInputSchema,
+  loginOutputSchema,
+  maintenanceTicketStatusEnum,
+  mfaVerifyInputSchema,
+  notificationTypeEnum,
+  paginationSchema,
+  paymentMethodEnum,
+  payrollContract,
+  payrollRunStatusEnum,
+  recordPaymentInputSchema,
+  refreshInputSchema,
+  refreshTokenOutputSchema,
+  reportCardStatusEnum,
+  rubricBandEnum,
+  sendBulkSmsInputSchema,
+  sponsorSchema,
+  sponsorTypeEnum,
+  staffSchema,
+  storageContract,
+  studentSchema,
+  studentStatusEnum,
+  studentsContract,
+  subjectSchema,
+  systemRoleEnum,
+  transportContract,
+  tripLogInputSchema,
+  userSchema,
+  userStatusEnum,
+  uuidSchema,
+  vehicleOwnershipEnum,
+  vehicleTypeEnum
+});
+//# sourceMappingURL=index.js.map