cloud-ide-model-schema 1.1.103 → 1.1.105

package/lib/schema/core/core_board_exam_pattern.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCoreBoardExamPattern = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var core_board_exam_pattern = new mongoose_1.Schema({
+    cbept_board_id_edbrd: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_education_board",
+        required: true,
+        comment: "Education Board ID"
+    },
+    cbept_academic_year_id_acayr: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "aca_academic_year",
+        required: true,
+        comment: "Academic Year ID - Exam pattern for this academic year"
+    },
+    cbept_pattern_name: {
+        type: String,
+        required: true,
+        maxlength: 200,
+        trim: true,
+        comment: "Exam pattern name (e.g., 'CCE', 'Annual', 'Semester', 'Continuous Assessment')"
+    },
+    cbept_pattern_code: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        uppercase: true,
+        comment: "Exam pattern code (e.g., 'CCE', 'ANNUAL', 'SEMESTER', 'CONTINUOUS')"
+    },
+    cbept_pattern_type_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        required: true,
+        comment: "Exam pattern type (Annual, Semester, CCE, Continuous, etc.) - Reference to core_general_master with type 'EXAM_PATTERN_TYPE'"
+    },
+    cbept_description: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Description of the exam pattern"
+    },
+    cbept_active_from_date: {
+        type: Date,
+        required: true,
+        comment: "Date from which this exam pattern is active"
+    },
+    cbept_active_to_date: {
+        type: Date,
+        comment: "Date until which this exam pattern is active (NULL if currently active)"
+    },
+    cbept_is_current: {
+        type: Boolean,
+        default: true,
+        comment: "Is this the current active exam pattern for the board"
+    },
+    cbept_number_of_exams: {
+        type: Number,
+        min: 1,
+        max: 12,
+        comment: "Number of exams/assessments in this pattern (e.g., 2 for Annual, 4 for Semester)"
+    },
+    cbept_exam_structure: {
+        type: Object,
+        default: {},
+        comment: "Exam structure details (e.g., { exams: ['Unit Test 1', 'Unit Test 2', 'Mid Term', 'Final'], weights: [10, 10, 30, 50] })"
+    },
+    cbept_assessment_methods: {
+        type: [String],
+        default: [],
+        comment: "Assessment methods used (e.g., ['Written Exam', 'Practical', 'Project', 'Assignment'])"
+    },
+    cbept_grading_system_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        comment: "Grading system used in this pattern (Percentage, CGPA, Letter Grade) - Reference to core_general_master with type 'EDUCATION_BOARD_GRADING_SYSTEM'"
+    },
+    cbept_pass_percentage: {
+        type: Number,
+        min: 0,
+        max: 100,
+        comment: "Minimum pass percentage for this pattern"
+    },
+    cbept_max_marks: {
+        type: Number,
+        min: 0,
+        comment: "Maximum marks for this exam pattern"
+    },
+    cbept_subject_wise_pattern: {
+        type: Object,
+        default: {},
+        comment: "Subject-wise exam pattern (e.g., { 'Mathematics': { theory: 80, practical: 20 }, 'Science': { theory: 60, practical: 40 } })"
+    },
+    cbept_stream_specific: {
+        type: Boolean,
+        default: false,
+        comment: "Is this pattern specific to a stream (Science, Commerce, Arts)"
+    },
+    cbept_streams: {
+        type: [String],
+        default: [],
+        comment: "Streams this pattern applies to (e.g., ['Science', 'Commerce', 'Arts'])"
+    },
+    cbept_level_specific: {
+        type: Boolean,
+        default: false,
+        comment: "Is this pattern specific to a level (Primary, Secondary, Higher Secondary)"
+    },
+    cbept_levels: {
+        type: [String],
+        default: [],
+        comment: "Levels this pattern applies to (e.g., ['Primary', 'Secondary', 'Higher Secondary'])"
+    },
+    cbept_configuration: {
+        type: Object,
+        default: {},
+        comment: "Additional configuration for this exam pattern (flexible JSON structure)"
+    },
+    cbept_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Additional notes about this exam pattern"
+    },
+    cbept_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Exam pattern active status"
+    }
+}, {
+    collection: 'core_board_exam_pattern',
+    timestamps: true
+});
+// Indexes for performance
+core_board_exam_pattern.index({ cbept_board_id_edbrd: 1 });
+core_board_exam_pattern.index({ cbept_academic_year_id_acayr: 1 });
+core_board_exam_pattern.index({ cbept_board_id_edbrd: 1, cbept_academic_year_id_acayr: 1 });
+core_board_exam_pattern.index({ cbept_is_current: 1 });
+core_board_exam_pattern.index({ cbept_active_from_date: 1 });
+core_board_exam_pattern.index({ cbept_active_to_date: 1 });
+core_board_exam_pattern.index({ cbept_pattern_code: 1 });
+core_board_exam_pattern.index({ cbept_isactive: 1 });
+// Compound index for finding current active pattern
+core_board_exam_pattern.index({
+    cbept_board_id_edbrd: 1,
+    cbept_is_current: 1,
+    cbept_isactive: 1
+});
+var CCoreBoardExamPattern = mongoose_1.default.model("core_board_exam_pattern", core_board_exam_pattern);
+exports.CCoreBoardExamPattern = CCoreBoardExamPattern;

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

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CCoreBoardGradeSystem: 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 { CCoreBoardGradeSystem };

package/lib/schema/core/core_board_grade_system.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCoreBoardGradeSystem = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var core_board_grade_system = new mongoose_1.Schema({
+    cbgs_board_id_edbrd: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_education_board",
+        required: true,
+        comment: "Education Board ID"
+    },
+    cbgs_academic_year_id_acayr: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "aca_academic_year",
+        required: true,
+        comment: "Academic Year ID - Grade system for this academic year"
+    },
+    cbgs_grade_system_name: {
+        type: String,
+        required: true,
+        maxlength: 200,
+        trim: true,
+        comment: "Grade system name (e.g., 'Percentage System', 'CGPA System', 'Letter Grade System', '9-Point Scale')"
+    },
+    cbgs_grade_system_code: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        uppercase: true,
+        comment: "Grade system code (e.g., 'PERCENTAGE', 'CGPA', 'LETTER_GRADE', '9_POINT_SCALE')"
+    },
+    cbgs_grade_system_type_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        required: true,
+        comment: "Grade system type (Percentage, CGPA, Letter Grade, Both) - Reference to core_general_master with type 'EDUCATION_BOARD_GRADING_SYSTEM'"
+    },
+    cbgs_description: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Description of the grade system"
+    },
+    cbgs_active_from_date: {
+        type: Date,
+        required: true,
+        comment: "Date from which this grade system is active"
+    },
+    cbgs_active_to_date: {
+        type: Date,
+        comment: "Date until which this grade system is active (NULL if currently active)"
+    },
+    cbgs_is_current: {
+        type: Boolean,
+        default: true,
+        comment: "Is this the current active grade system for the board"
+    },
+    cbgs_grade_scale: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        comment: "Grade scale (e.g., '0-100', '0-10', 'A1-E', 'A-F', '1-9')"
+    },
+    cbgs_min_score: {
+        type: Number,
+        min: 0,
+        comment: "Minimum score in the grade system (e.g., 0 for percentage, 0 for CGPA)"
+    },
+    cbgs_max_score: {
+        type: Number,
+        required: true,
+        min: 0,
+        comment: "Maximum score in the grade system (e.g., 100 for percentage, 10 for CGPA, 9 for 9-point scale)"
+    },
+    cbgs_pass_score: {
+        type: Number,
+        min: 0,
+        comment: "Minimum pass score (e.g., 33 for percentage, 4.0 for CGPA)"
+    },
+    cbgs_grade_ranges: {
+        type: [{
+                grade: {
+                    type: String,
+                    required: true,
+                    maxlength: 10,
+                    trim: true,
+                    comment: "Grade value (e.g., 'A1', 'A', 'B', 'C', '90-100', '9')"
+                },
+                grade_name: {
+                    type: String,
+                    maxlength: 100,
+                    trim: true,
+                    comment: "Grade name (e.g., 'Excellent', 'Very Good', 'Good', 'Pass')"
+                },
+                min_score: {
+                    type: Number,
+                    required: true,
+                    min: 0,
+                    comment: "Minimum score for this grade"
+                },
+                max_score: {
+                    type: Number,
+                    required: true,
+                    min: 0,
+                    comment: "Maximum score for this grade"
+                },
+                grade_point: {
+                    type: Number,
+                    min: 0,
+                    comment: "Grade point value (for CGPA systems, e.g., 10, 9, 8)"
+                },
+                is_pass: {
+                    type: Boolean,
+                    default: true,
+                    comment: "Is this grade a passing grade"
+                },
+                description: {
+                    type: String,
+                    maxlength: 200,
+                    trim: true,
+                    comment: "Description of this grade"
+                }
+            }],
+        default: [],
+        comment: "Grade ranges with min/max scores, grade points, and pass status"
+    },
+    cbgs_percentage_to_cgpa_formula: {
+        type: Object,
+        default: {},
+        comment: "Formula to convert percentage to CGPA (e.g., { formula: 'percentage/10', reverse: 'cgpa*10' })"
+    },
+    cbgs_cgpa_to_percentage_formula: {
+        type: Object,
+        default: {},
+        comment: "Formula to convert CGPA to percentage (e.g., { formula: 'cgpa*9.5', reverse: 'percentage/9.5' })"
+    },
+    cbgs_letter_grade_mapping: {
+        type: Object,
+        default: {},
+        comment: "Mapping of letter grades to scores (e.g., { 'A1': { min: 91, max: 100, points: 10 }, 'A2': { min: 81, max: 90, points: 9 } })"
+    },
+    cbgs_stream_specific: {
+        type: Boolean,
+        default: false,
+        comment: "Is this grade system specific to a stream (Science, Commerce, Arts)"
+    },
+    cbgs_streams: {
+        type: [String],
+        default: [],
+        comment: "Streams this grade system applies to (e.g., ['Science', 'Commerce', 'Arts'])"
+    },
+    cbgs_level_specific: {
+        type: Boolean,
+        default: false,
+        comment: "Is this grade system specific to a level (Primary, Secondary, Higher Secondary)"
+    },
+    cbgs_levels: {
+        type: [String],
+        default: [],
+        comment: "Levels this grade system applies to (e.g., ['Primary', 'Secondary', 'Higher Secondary'])"
+    },
+    cbgs_subject_wise_grading: {
+        type: Boolean,
+        default: false,
+        comment: "Does this grade system support subject-wise grading"
+    },
+    cbgs_subject_grade_config: {
+        type: Object,
+        default: {},
+        comment: "Subject-wise grade configuration (e.g., { 'Mathematics': { max_marks: 100, pass_marks: 33 }, 'Science': { max_marks: 100, pass_marks: 33 } })"
+    },
+    cbgs_configuration: {
+        type: Object,
+        default: {},
+        comment: "Additional configuration for this grade system (flexible JSON structure)"
+    },
+    cbgs_notes: {
+        type: String,
+        maxlength: 1000,
+        trim: true,
+        comment: "Additional notes about this grade system"
+    },
+    cbgs_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Grade system active status"
+    }
+}, {
+    collection: 'core_board_grade_system',
+    timestamps: true
+});
+// Indexes for performance
+core_board_grade_system.index({ cbgs_board_id_edbrd: 1 });
+core_board_grade_system.index({ cbgs_academic_year_id_acayr: 1 });
+core_board_grade_system.index({ cbgs_board_id_edbrd: 1, cbgs_academic_year_id_acayr: 1 });
+core_board_grade_system.index({ cbgs_is_current: 1 });
+core_board_grade_system.index({ cbgs_active_from_date: 1 });
+core_board_grade_system.index({ cbgs_active_to_date: 1 });
+core_board_grade_system.index({ cbgs_grade_system_code: 1 });
+core_board_grade_system.index({ cbgs_isactive: 1 });
+// Compound index for finding current active grade system
+core_board_grade_system.index({
+    cbgs_board_id_edbrd: 1,
+    cbgs_is_current: 1,
+    cbgs_isactive: 1
+});
+var CCoreBoardGradeSystem = mongoose_1.default.model("core_board_grade_system", core_board_grade_system);
+exports.CCoreBoardGradeSystem = CCoreBoardGradeSystem;

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

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CCoreEducationBoard: 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 { CCoreEducationBoard };

package/lib/schema/core/core_education_board.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCoreEducationBoard = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var core_education_board = new mongoose_1.Schema({
+    edbrd_code: {
+        type: String,
+        required: true,
+        unique: true,
+        maxlength: 50,
+        trim: true,
+        uppercase: true,
+        comment: "Board code (e.g., CBSE, ICSE, MAH-SSC, KAR-SSC, etc.)"
+    },
+    edbrd_name: {
+        type: String,
+        required: true,
+        maxlength: 200,
+        trim: true,
+        comment: "Board name (e.g., Central Board of Secondary Education)"
+    },
+    edbrd_short_name: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        comment: "Short name (e.g., CBSE, ICSE, State Board)"
+    },
+    edbrd_type_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        required: true,
+        comment: "Board type (National, State, International, Higher Education, Other) - Reference to core_general_master with type 'EDUCATION_BOARD_TYPE'"
+    },
+    edbrd_category_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        required: true,
+        comment: "Board category (School, Higher Education, Both) - Reference to core_general_master with type 'EDUCATION_BOARD_CATEGORY'"
+    },
+    edbrd_state: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "State name (for state boards, e.g., Maharashtra, Karnataka)"
+    },
+    edbrd_country_id_syctr: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_system_country",
+        comment: "Country ID (default: India)"
+    },
+    edbrd_website: {
+        type: String,
+        maxlength: 255,
+        trim: true,
+        comment: "Board official website"
+    },
+    edbrd_contact_email: {
+        type: String,
+        maxlength: 255,
+        trim: true,
+        lowercase: true,
+        comment: "Board contact email"
+    },
+    edbrd_contact_phone: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Board contact phone"
+    },
+    edbrd_address: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Board address"
+    },
+    edbrd_udise_format: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "UDISE code format indicator (e.g., '11-digit' for boards that use UDISE, 'Not Applicable' for international boards). Note: UDISE is school-specific, not board-specific, but this field helps identify which boards typically use UDISE"
+    },
+    edbrd_affiliation_format: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Affiliation number format (e.g., '10-digit' for CBSE, '12-digit' for State boards, 'ALPHA-NUMERIC' for ICSE). Used for validation, generation, and formatting of board affiliation numbers"
+    },
+    edbrd_roll_number_format: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Roll number format pattern (e.g., 'YYYY-SCHOOL-XXX' for CBSE, 'SCHOOL-YYYY-XXX' for State boards, '6-digit' for ICSE). Used for validation, generation, and formatting of student roll numbers in board examinations"
+    },
+    edbrd_registration_number_format: {
+        type: String,
+        maxlength: 100,
+        trim: true,
+        comment: "Registration number format pattern (e.g., 'YYYY-REG-XXX' for CBSE, 'REG-YYYY-XXX' for State boards, '10-digit' for ICSE). Used for validation, generation, and formatting of student registration numbers with the board"
+    },
+    edbrd_grading_system_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        comment: "Grading system (Percentage, CGPA, Letter Grade, Both) - Reference to core_general_master with type 'EDUCATION_BOARD_GRADING_SYSTEM'"
+    },
+    edbrd_grade_scale: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        comment: "Grade scale (e.g., 0-100, 0-10, A1-E, A-F)"
+    },
+    edbrd_configuration: {
+        type: Object,
+        default: {},
+        comment: "Board-specific configuration (subjects, streams, etc.) - Note: Exam patterns are managed in core_board_exam_pattern table"
+    },
+    edbrd_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "Board active status"
+    }
+}, { collection: 'core_education_board' });
+// Indexes for performance
+core_education_board.index({ edbrd_code: 1 });
+core_education_board.index({ edbrd_type_sygms: 1 });
+core_education_board.index({ edbrd_category_sygms: 1 });
+core_education_board.index({ edbrd_state: 1 });
+core_education_board.index({ edbrd_isactive: 1 });
+var CCoreEducationBoard = mongoose_1.default.model("core_education_board", core_education_board);
+exports.CCoreEducationBoard = CCoreEducationBoard;

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

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+declare const CCoreEntityUdise: 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 { CCoreEntityUdise };

package/lib/schema/core/core_entity_udise.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CCoreEntityUdise = void 0;
+var mongoose_1 = require("mongoose");
+/* SCHEMA START */
+var core_entity_udise = new mongoose_1.Schema({
+    syudise_entity_id_syen: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_system_entity",
+        required: true,
+        unique: true,
+        comment: "School/Entity ID - One UDISE record per entity"
+    },
+    syudise_code: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        unique: true,
+        sparse: true,
+        comment: "11-digit UDISE code (Unified District Information System for Education)"
+    },
+    syudise_verified: {
+        type: Boolean,
+        default: false,
+        comment: "UDISE code verification status"
+    },
+    syudise_verification_date: {
+        type: Date,
+        comment: "UDISE verification date"
+    },
+    syudise_verification_source_sygms: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_general_master",
+        comment: "UDISE verification source (UDISE Portal, Manual, API, Other) - Reference to core_general_master with type 'UDISE_VERIFICATION_SOURCE'"
+    },
+    syudise_verification_notes: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Notes about UDISE verification"
+    },
+    syudise_state_code: {
+        type: String,
+        maxlength: 10,
+        trim: true,
+        comment: "State code extracted from UDISE (positions 1-2)"
+    },
+    syudise_district_code: {
+        type: String,
+        maxlength: 10,
+        trim: true,
+        comment: "District code extracted from UDISE (positions 3-4)"
+    },
+    syudise_block_code: {
+        type: String,
+        maxlength: 10,
+        trim: true,
+        comment: "Block code extracted from UDISE (positions 5-6)"
+    },
+    syudise_school_code: {
+        type: String,
+        maxlength: 10,
+        trim: true,
+        comment: "School code extracted from UDISE (positions 7-9)"
+    },
+    syudise_check_digits: {
+        type: String,
+        maxlength: 10,
+        trim: true,
+        comment: "Check digits extracted from UDISE (positions 10-11)"
+    },
+    syudise_last_synced_date: {
+        type: Date,
+        comment: "Last date when UDISE data was synced from UDISE portal"
+    },
+    syudise_sync_status: {
+        type: String,
+        maxlength: 50,
+        trim: true,
+        enum: ["Not Synced", "Synced", "Sync Failed", "Pending"],
+        default: "Not Synced",
+        comment: "UDISE data sync status"
+    },
+    syudise_sync_error: {
+        type: String,
+        maxlength: 500,
+        trim: true,
+        comment: "Error message if UDISE sync failed"
+    },
+    syudise_metadata: {
+        type: Object,
+        default: {},
+        comment: "Additional UDISE metadata from UDISE portal (school type, management, etc.)"
+    },
+    syudise_isactive: {
+        type: Boolean,
+        default: true,
+        comment: "UDISE record active status"
+    }
+}, {
+    collection: 'core_entity_udise',
+    timestamps: true
+});
+// Indexes for performance
+core_entity_udise.index({ syudise_entity_id_syen: 1 });
+core_entity_udise.index({ syudise_code: 1 });
+core_entity_udise.index({ syudise_verified: 1 });
+core_entity_udise.index({ syudise_state_code: 1 });
+core_entity_udise.index({ syudise_district_code: 1 });
+core_entity_udise.index({ syudise_sync_status: 1 });
+core_entity_udise.index({ syudise_isactive: 1 });
+var CCoreEntityUdise = mongoose_1.default.model("core_entity_udise", core_entity_udise);
+exports.CCoreEntityUdise = CCoreEntityUdise;