cloud-ide-model-schema 1.1.103 → 1.1.105

package/lib/schema/admission/admission_document_uploads.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CAdmissionDocumentUploads: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+export { CAdmissionDocumentUploads };

package/lib/schema/admission/admission_document_uploads.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAdmissionDocumentUploads = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var admission_document_uploads = new mongoose_1.Schema({
+    // FOREIGN KEY TO MAIN APPLICATION
+    addu_application_id_admap: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "admission_application_main",
+        required: true,
+        comment: "Foreign key to admission_application_main"
+    },
+    // DOCUMENT DETAILS
+    addu_document_type: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true,
+        enum: [
+            "Transcript",
+            "Report Card",
+            "Birth Certificate",
+            "Passport",
+            "Identity Document",
+            "Letter of Recommendation 1",
+            "Letter of Recommendation 2",
+            "Teacher Recommendation",
+            "Portfolio",
+            "Personal Statement",
+            "Immunization Record",
+            "Medical Clearance",
+            "Custody Document",
+            "Residency Proof",
+            "Financial Aid Document",
+            "Scholarship Application",
+            "Other"
+        ],
+        comment: "Type of document"
+    },
+    addu_document_name: {
+        type: String,
+        required: true,
+        maxlength: 255,
+        trim: true,
+        comment: "Name/description of the document"
+    },
+    addu_file_id_cyfm: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_file_manager",
+        required: true,
+        comment: "File manager ID for the uploaded document"
+    },
+    addu_file_name: {
+        type: String,
+        required: true,
+        maxlength: 255,
+        trim: true,
+        comment: "Original file name"
+    },
+    addu_file_size: {
+        type: Number,
+        required: true,
+        min: 0,
+        comment: "File size in bytes"
+    },
+    addu_file_type: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        comment: "File MIME type (e.g., application/pdf, image/jpeg)"
+    },
+    addu_file_path: {
+        type: String,
+        required: true,
+        maxlength: 500,
+        trim: true,
+        comment: "File storage path"
+    },
+    addu_upload_date: {
+        type: Date,
+        required: true,
+        default: Date.now,
+        comment: "Date when document was uploaded"
+    },
+    addu_uploaded_by_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst",
+        comment: "User who uploaded the document"
+    },
+    // DOCUMENT VERIFICATION
+    addu_verification_status: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        enum: ["Pending", "Verified", "Rejected", "Under Review"],
+        default: "Pending",
+        comment: "Verification status of the document"
+    },
+    addu_verification_date: {
+        type: Date,
+        comment: "Date when document was verified"
+    },
+    addu_verified_by_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst",
+        comment: "User who verified the document"
+    },
+    addu_verification_notes: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Verification notes"
+    },
+    addu_rejection_reason: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Reason for rejection (if applicable)"
+    },
+    // DOCUMENT SPECIFIC FIELDS
+    addu_document_issue_date: {
+        type: Date,
+        comment: "Issue date of the document (if applicable)"
+    },
+    addu_document_expiry_date: {
+        type: Date,
+        comment: "Expiry date of the document (if applicable)"
+    },
+    addu_document_number: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Document number (e.g., passport number, certificate number)"
+    },
+    addu_issuing_authority: {
+        type: String,
+        maxlength: 255,
+        trim: true,
+        comment: "Issuing authority (e.g., school name, government agency)"
+    },
+    addu_recommender_name: {
+        type: String,
+        maxlength: 255,
+        trim: true,
+        comment: "Recommender name (for recommendation letters)"
+    },
+    addu_recommender_type: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        enum: ["Teacher", "Principal", "Counselor", "Employer", "Other"],
+        comment: "Recommender type (for recommendation letters)"
+    },
+    addu_recommender_email: {
+        type: String,
+        maxlength: 255,
+        trim: true,
+        lowercase: true,
+        comment: "Recommender email (for recommendation letters)"
+    },
+    addu_year: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Year (for report cards, transcripts)"
+    },
+    addu_grade_level: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Grade level (for report cards, transcripts)"
+    },
+    // METADATA
+    addu_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Additional notes about the document"
+    },
+    addu_is_required: {
+        type: Boolean,
+        default: true,
+        comment: "Whether this document is required"
+    },
+    addu_is_optional: {
+        type: Boolean,
+        default: false,
+        comment: "Whether this document is optional"
+    },
+    addu_created_date: {
+        type: Date,
+        default: Date.now
+    },
+    addu_modified_date: {
+        type: Date,
+        default: Date.now
+    },
+    addu_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, {
+    collection: 'admission_document_uploads',
+    timestamps: true
+});
+// Indexes for performance
+admission_document_uploads.index({ addu_application_id_admap: 1 });
+admission_document_uploads.index({ addu_document_type: 1 });
+admission_document_uploads.index({ addu_verification_status: 1 });
+admission_document_uploads.index({ addu_file_id_cyfm: 1 });
+admission_document_uploads.index({ addu_upload_date: -1 });
+var CAdmissionDocumentUploads = mongoose_1.default.model("admission_document_uploads", admission_document_uploads);
+exports.CAdmissionDocumentUploads = CAdmissionDocumentUploads;

package/lib/schema/admission/admission_elective_detail.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CAdmissionElectiveDetail: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+export { CAdmissionElectiveDetail };

package/lib/schema/admission/admission_elective_detail.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAdmissionElectiveDetail = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var admission_elective_detail = new mongoose_1.Schema({
+    // FOREIGN KEY TO MAIN APPLICATION
+    adme_application_id_admap: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "admission_application_main",
+        required: true,
+        comment: "Foreign key to admission_application_main"
+    },
+    // ELECTIVE SELECTION DETAILS
+    adme_priority: {
+        type: Number,
+        required: true,
+        min: 1,
+        max: 20,
+        comment: "Priority order (1st choice, 2nd choice, etc.)"
+    },
+    adme_subject_code: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        comment: "Unique identifier for the selected course/subject"
+    },
+    adme_subject_name: {
+        type: String,
+        required: true,
+        maxlength: 200,
+        trim: true,
+        comment: "Name of the selected course/subject"
+    },
+    adme_subject_type: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true,
+        enum: ["Elective", "Advanced Placement", "Honors", "Major Core", "Major Elective", "General Education", "Core", "Other"],
+        comment: "Type of subject/course"
+    },
+    adme_credits: {
+        type: Number,
+        min: 0,
+        max: 10,
+        default: 0,
+        comment: "Number of credits for the course"
+    },
+    adme_status: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        enum: ["Pending", "Approved", "Rejected", "Waitlisted", "Alternative"],
+        default: "Pending",
+        comment: "Status of elective selection"
+    },
+    adme_approval_date: {
+        type: Date,
+        comment: "Date when elective was approved"
+    },
+    adme_approved_by_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst",
+        comment: "User who approved the elective selection"
+    },
+    adme_rejection_reason: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Reason for rejection (if applicable)"
+    },
+    adme_prerequisites_met: {
+        type: Boolean,
+        default: false,
+        comment: "Whether prerequisites are met"
+    },
+    adme_prerequisites_notes: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Notes about prerequisites"
+    },
+    adme_alternative_subject_code: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Alternative subject code if primary is not available"
+    },
+    adme_alternative_subject_name: {
+        type: String,
+        maxlength: 200,
+        trim: true,
+        comment: "Alternative subject name if primary is not available"
+    },
+    adme_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Additional notes about the elective selection"
+    },
+    // METADATA
+    adme_created_date: {
+        type: Date,
+        default: Date.now
+    },
+    adme_modified_date: {
+        type: Date,
+        default: Date.now
+    },
+    adme_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, {
+    collection: 'admission_elective_detail',
+    timestamps: true
+});
+// Indexes for performance
+admission_elective_detail.index({ adme_application_id_admap: 1 });
+admission_elective_detail.index({ adme_priority: 1 });
+admission_elective_detail.index({ adme_subject_code: 1 });
+admission_elective_detail.index({ adme_status: 1 });
+var CAdmissionElectiveDetail = mongoose_1.default.model("admission_elective_detail", admission_elective_detail);
+exports.CAdmissionElectiveDetail = CAdmissionElectiveDetail;

package/lib/schema/admission/admission_status_history.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CAdmissionStatusHistory: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+export { CAdmissionStatusHistory };

package/lib/schema/admission/admission_status_history.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAdmissionStatusHistory = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var admission_status_history = new mongoose_1.Schema({
+    // FOREIGN KEY TO MAIN APPLICATION
+    adsh_application_id_admap: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "admission_application_main",
+        required: true,
+        comment: "Foreign key to admission_application_main"
+    },
+    // STATUS CHANGE DETAILS
+    adsh_status_from: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Previous status"
+    },
+    adsh_status_to: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        enum: ["Draft", "Submitted", "Under Review", "Interview Scheduled", "Accepted", "Waitlisted", "Rejected", "Withdrawn"],
+        comment: "New status"
+    },
+    adsh_status_change_date: {
+        type: Date,
+        required: true,
+        default: Date.now,
+        comment: "Date when status was changed"
+    },
+    adsh_status_change_reason: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Reason for status change"
+    },
+    adsh_status_change_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Additional notes about the status change"
+    },
+    adsh_changed_by_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst",
+        required: true,
+        comment: "User who changed the status"
+    },
+    adsh_notification_sent: {
+        type: Boolean,
+        default: false,
+        comment: "Whether notification was sent for this status change"
+    },
+    adsh_notification_sent_date: {
+        type: Date,
+        comment: "Date when notification was sent"
+    },
+    adsh_email_sent: {
+        type: Boolean,
+        default: false,
+        comment: "Whether email was sent for this status change"
+    },
+    adsh_sms_sent: {
+        type: Boolean,
+        default: false,
+        comment: "Whether SMS was sent for this status change"
+    },
+    // INTERVIEW SPECIFIC FIELDS
+    adsh_interview_scheduled_date: {
+        type: Date,
+        comment: "Interview scheduled date (if status is Interview Scheduled)"
+    },
+    adsh_interview_completed_date: {
+        type: Date,
+        comment: "Interview completed date"
+    },
+    adsh_interview_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Interview notes"
+    },
+    adsh_interviewer_user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst",
+        comment: "User who conducted the interview"
+    },
+    // DECISION SPECIFIC FIELDS
+    adsh_decision_date: {
+        type: Date,
+        comment: "Decision date (if status is Accepted/Rejected/Waitlisted)"
+    },
+    adsh_decision_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Decision notes"
+    },
+    adsh_waitlist_position: {
+        type: Number,
+        min: 0,
+        comment: "Waitlist position (if status is Waitlisted)"
+    },
+    adsh_rejection_reason: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Rejection reason (if status is Rejected)"
+    },
+    // METADATA
+    adsh_created_date: {
+        type: Date,
+        default: Date.now
+    },
+    adsh_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, {
+    collection: 'admission_status_history',
+    timestamps: true
+});
+// Indexes for performance
+admission_status_history.index({ adsh_application_id_admap: 1 });
+admission_status_history.index({ adsh_status_to: 1 });
+admission_status_history.index({ adsh_status_change_date: -1 });
+admission_status_history.index({ adsh_changed_by_user: 1 });
+var CAdmissionStatusHistory = mongoose_1.default.model("admission_status_history", admission_status_history);
+exports.CAdmissionStatusHistory = CAdmissionStatusHistory;

package/lib/schema/admission/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./admission_application_main";
+export * from "./admission_elective_detail";
+export * from "./admission_status_history";
+export * from "./admission_document_uploads";

package/lib/schema/admission/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./admission_application_main"), exports);
+__exportStar(require("./admission_elective_detail"), exports);
+__exportStar(require("./admission_status_history"), exports);
+__exportStar(require("./admission_document_uploads"), exports);

package/lib/schema/core/core_board_exam_pattern.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CCoreBoardExamPattern: mongoose.Model<{
+    [x: string]: unknown;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    [x: string]: unknown;
+}, {}> & {
+    [x: string]: unknown;
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: string]: unknown;
+}>, {}> & mongoose.FlatRecord<{
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>>;
+export { CCoreBoardExamPattern };