@api-client/core 0.18.21 → 0.18.22

package/src/modeling/templates/verticals/education-training/education-domain.ts

@@ -0,0 +1,922 @@
+/**
+ * Education Data Domain Example
+ *
+ * This file demonstrates how to create a comprehensive education data domain
+ * using the API Client Core modeling system. It follows the business-first approach
+ * and demonstrates proper use of namespaces, models, entities, properties,
+ * associations, and semantic annotations.
+ *
+ * The example includes:
+ * - Student Management with student records, enrollment, and academic history
+ * - Course Management with courses, curriculum, assignments, and grades
+ * - Faculty Management with teachers, staff, departments, and roles
+ * - Campus Operations with facilities, events, and resources
+ * - Learning Analytics with progress tracking, assessments, and performance
+ * - Administrative features with admissions, financial aid, and scheduling
+ *
+ * @example
+ * ```typescript
+ * import { createEducationDomain } from './education-domain.js'
+ *
+ * const domain = createEducationDomain()
+ * console.log('Education domain created with', domain.graph.nodeCount(), 'nodes')
+ * ```
+ */
+
+import { DataDomain } from '../../../DataDomain.js'
+import {
+  addIdField,
+  addNameField,
+  addDescriptionField,
+  addEmailField,
+  addFirstNameField,
+  addLastNameField,
+  addPhoneField,
+  addCustomStatusField,
+  addCreatedAtField,
+  addUpdatedAtField,
+  addCurrencyAmountField,
+} from '../../../helpers/Intelisense.js'
+import type { CreateTemplateOptions } from '../../types.js'
+
+function createDomain(): DataDomain {
+  return new DataDomain({
+    info: {
+      name: 'Education Management Platform',
+      displayName: 'Education Management Platform',
+      description:
+        'A comprehensive education management platform with student management, course management, ' +
+        'faculty management, campus operations, and learning analytics',
+    },
+  })
+}
+
+/**
+ * Creates a comprehensive education data domain following domain-driven design principles.
+ *
+ * This function demonstrates the proper hierarchy and organization for an education platform:
+ * 1. Creates the root DataDomain for the education platform
+ * 2. Organizes functionality into logical namespaces (Student Management, Course Management, etc.)
+ * 3. Groups related entities into models within each namespace
+ * 4. Defines entities with proper semantic annotations for educational workflows
+ * 5. Establishes associations with appropriate cardinality for student-course relationships
+ *
+ * @returns A fully configured DataDomain with all education entities and relationships
+ */
+export default function createEducationDomain(options: CreateTemplateOptions = {}): DataDomain {
+  // Ensure the root data domain
+  const domain = options.domain ?? createDomain()
+
+  //
+  // 1. STUDENT MANAGEMENT NAMESPACE
+  //
+  const studentManagement = domain.addNamespace({
+    info: {
+      name: 'StudentManagement',
+      displayName: 'Student Management',
+      description: 'Student records, enrollment, and academic history',
+    },
+  })
+
+  // Student Model
+  const studentModel = studentManagement.addModel({
+    info: {
+      name: 'Students',
+      displayName: 'Student Management',
+      description: 'Student records and information',
+    },
+  })
+
+  // Student Entity
+  const studentEntity = studentModel.addEntity({
+    info: {
+      name: 'student',
+      displayName: 'Student',
+      description: 'Student record with academic information',
+    },
+  })
+
+  addIdField(studentEntity, { displayName: 'Student ID', description: 'Unique identifier for the student' })
+
+  studentEntity.addProperty({
+    info: { name: 'student_number', displayName: 'Student Number', description: 'Student identification number' },
+    type: 'string',
+    required: true,
+    unique: true,
+  })
+
+  addFirstNameField(studentEntity, { description: 'Student first name' })
+  addLastNameField(studentEntity, { description: 'Student last name' })
+
+  studentEntity.addProperty({
+    info: { name: 'date_of_birth', displayName: 'Date of Birth', description: 'Student date of birth' },
+    type: 'date',
+    required: true,
+  })
+
+  addEmailField(studentEntity, { description: 'Student email address' })
+  addPhoneField(studentEntity, { description: 'Student phone number' })
+
+  studentEntity.addProperty({
+    info: { name: 'address', displayName: 'Address', description: 'Student residential address' },
+    type: 'string',
+    required: true,
+  })
+
+  studentEntity.addProperty({
+    info: {
+      name: 'emergency_contact_name',
+      displayName: 'Emergency Contact Name',
+      description: 'Emergency contact name',
+    },
+    type: 'string',
+  })
+
+  addPhoneField(studentEntity, {
+    name: 'emergency_contact_phone',
+    displayName: 'Emergency Contact Phone',
+    description: 'Emergency contact phone number',
+  })
+
+  addCustomStatusField(studentEntity, ['active', 'inactive', 'graduated', 'withdrawn', 'suspended'], {
+    displayName: 'Student Status',
+    description: 'Current status of the student',
+  })
+
+  studentEntity.addProperty({
+    info: {
+      name: 'academic_level',
+      displayName: 'Academic Level',
+      description: 'Current academic level of the student',
+    },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['freshman', 'sophomore', 'junior', 'senior', 'graduate'],
+    },
+  })
+
+  addCreatedAtField(studentEntity, { description: 'When the student record was created' })
+  addUpdatedAtField(studentEntity, { description: 'When the student record was last updated' })
+
+  // Enrollment Entity
+  const enrollmentEntity = studentModel.addEntity({
+    info: {
+      name: 'enrollment',
+      displayName: 'Enrollment',
+      description: 'Student course enrollment records',
+    },
+  })
+
+  addIdField(enrollmentEntity, { displayName: 'Enrollment ID', description: 'Unique identifier for the enrollment' })
+
+  enrollmentEntity.addProperty({
+    info: { name: 'enrollment_date', displayName: 'Enrollment Date', description: 'Date when student enrolled' },
+    type: 'date',
+    required: true,
+  })
+
+  addCustomStatusField(enrollmentEntity, ['enrolled', 'dropped', 'completed', 'incomplete'], {
+    displayName: 'Enrollment Status',
+    description: 'Current status of the enrollment',
+  })
+
+  addCreatedAtField(enrollmentEntity, { description: 'When the enrollment was created' })
+
+  // Enrollment-Student Association (Many-to-One)
+  enrollmentEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this enrollment' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Academic History Entity
+  const academicHistoryEntity = studentModel.addEntity({
+    info: {
+      name: 'academic_history',
+      displayName: 'Academic History',
+      description: 'Student academic history and records',
+    },
+  })
+
+  addIdField(academicHistoryEntity, {
+    displayName: 'History ID',
+    description: 'Unique identifier for the academic history',
+  })
+
+  academicHistoryEntity.addProperty({
+    info: { name: 'gpa', displayName: 'GPA', description: 'Grade Point Average' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+      maximum: 4,
+    },
+  })
+
+  academicHistoryEntity.addProperty({
+    info: { name: 'credits_earned', displayName: 'Credits Earned', description: 'Total credits earned' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+    },
+  })
+
+  academicHistoryEntity.addProperty({
+    info: { name: 'academic_year', displayName: 'Academic Year', description: 'Academic year' },
+    type: 'string',
+    required: true,
+  })
+
+  addDescriptionField(academicHistoryEntity, { description: 'Academic history notes and achievements' })
+
+  addCreatedAtField(academicHistoryEntity, { description: 'When the academic history was created' })
+
+  // AcademicHistory-Student Association (Many-to-One)
+  academicHistoryEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this academic history' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 2. COURSE MANAGEMENT NAMESPACE
+  //
+  const courseManagement = domain.addNamespace({
+    info: {
+      name: 'CourseManagement',
+      displayName: 'Course Management',
+      description: 'Courses, curriculum, assignments, and grades',
+    },
+  })
+
+  // Course Model
+  const courseModel = courseManagement.addModel({
+    info: {
+      name: 'Courses',
+      displayName: 'Course Management',
+      description: 'Course information and curriculum',
+    },
+  })
+
+  // Course Entity
+  const courseEntity = courseModel.addEntity({
+    info: {
+      name: 'course',
+      displayName: 'Course',
+      description: 'Academic course information',
+    },
+  })
+
+  addIdField(courseEntity, { displayName: 'Course ID', description: 'Unique identifier for the course' })
+
+  courseEntity.addProperty({
+    info: { name: 'course_code', displayName: 'Course Code', description: 'Course identification code' },
+    type: 'string',
+    required: true,
+    unique: true,
+  })
+
+  addNameField(courseEntity, { displayName: 'Course Name', description: 'Name of the course' })
+
+  addDescriptionField(courseEntity, { description: 'Course description and objectives' })
+
+  courseEntity.addProperty({
+    info: { name: 'credits', displayName: 'Credits', description: 'Number of credits for the course' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 1,
+      maximum: 6,
+    },
+  })
+
+  addCustomStatusField(courseEntity, ['active', 'inactive', 'archived'], {
+    displayName: 'Course Status',
+    description: 'Current status of the course',
+  })
+
+  addCreatedAtField(courseEntity, { description: 'When the course was created' })
+  addUpdatedAtField(courseEntity, { description: 'When the course was last updated' })
+
+  // Course Section Entity
+  const courseSectionEntity = courseModel.addEntity({
+    info: {
+      name: 'course_section',
+      displayName: 'Course Section',
+      description: 'Specific section of a course',
+    },
+  })
+
+  addIdField(courseSectionEntity, { displayName: 'Section ID', description: 'Unique identifier for the section' })
+
+  courseSectionEntity.addProperty({
+    info: { name: 'section_number', displayName: 'Section Number', description: 'Section number' },
+    type: 'string',
+    required: true,
+  })
+
+  courseSectionEntity.addProperty({
+    info: { name: 'capacity', displayName: 'Capacity', description: 'Maximum number of students' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 1,
+    },
+  })
+
+  courseSectionEntity.addProperty({
+    info: { name: 'enrolled_count', displayName: 'Enrolled Count', description: 'Number of enrolled students' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+    },
+  })
+
+  addCustomStatusField(courseSectionEntity, ['open', 'full', 'closed', 'cancelled'], {
+    displayName: 'Section Status',
+    description: 'Current status of the section',
+  })
+
+  addCreatedAtField(courseSectionEntity, { description: 'When the section was created' })
+
+  // CourseSection-Course Association (Many-to-One)
+  courseSectionEntity.addAssociation(
+    { key: courseEntity.key },
+    {
+      info: { name: 'course', displayName: 'Course', description: 'Course for this section' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Assignment Entity
+  const assignmentEntity = courseModel.addEntity({
+    info: {
+      name: 'assignment',
+      displayName: 'Assignment',
+      description: 'Course assignments and assessments',
+    },
+  })
+
+  addIdField(assignmentEntity, { displayName: 'Assignment ID', description: 'Unique identifier for the assignment' })
+
+  addNameField(assignmentEntity, { displayName: 'Assignment Name', description: 'Name of the assignment' })
+
+  addDescriptionField(assignmentEntity, { description: 'Assignment description and requirements' })
+
+  assignmentEntity.addProperty({
+    info: { name: 'due_date', displayName: 'Due Date', description: 'Assignment due date' },
+    type: 'date',
+    required: true,
+  })
+
+  assignmentEntity.addProperty({
+    info: { name: 'total_points', displayName: 'Total Points', description: 'Total possible points' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 1,
+    },
+  })
+
+  addCustomStatusField(assignmentEntity, ['draft', 'published', 'submitted', 'graded'], {
+    displayName: 'Assignment Status',
+    description: 'Current status of the assignment',
+  })
+
+  addCreatedAtField(assignmentEntity, { description: 'When the assignment was created' })
+
+  // Assignment-CourseSection Association (Many-to-One)
+  assignmentEntity.addAssociation(
+    { key: courseSectionEntity.key },
+    {
+      info: {
+        name: 'course_section',
+        displayName: 'Course Section',
+        description: 'Course section for this assignment',
+      },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Grade Entity
+  const gradeEntity = courseModel.addEntity({
+    info: {
+      name: 'grade',
+      displayName: 'Grade',
+      description: 'Student grades and assessments',
+    },
+  })
+
+  addIdField(gradeEntity, { displayName: 'Grade ID', description: 'Unique identifier for the grade' })
+
+  gradeEntity.addProperty({
+    info: { name: 'score', displayName: 'Score', description: 'Numerical score earned' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+    },
+  })
+
+  gradeEntity.addProperty({
+    info: { name: 'letter_grade', displayName: 'Letter Grade', description: 'Letter grade (A, B, C, D, F)' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['A', 'A-', 'B+', 'B', 'B-', 'C+', 'C', 'C-', 'D+', 'D', 'F'],
+    },
+  })
+
+  addDescriptionField(gradeEntity, { description: 'Grade comments and feedback' })
+
+  addCreatedAtField(gradeEntity, { description: 'When the grade was created' })
+
+  // Grade-Student Association (Many-to-One)
+  gradeEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this grade' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Grade-Assignment Association (Many-to-One)
+  gradeEntity.addAssociation(
+    { key: assignmentEntity.key },
+    {
+      info: { name: 'assignment', displayName: 'Assignment', description: 'Assignment for this grade' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Enrollment-CourseSection Association (Many-to-One)
+  enrollmentEntity.addAssociation(
+    { key: courseSectionEntity.key },
+    {
+      info: {
+        name: 'course_section',
+        displayName: 'Course Section',
+        description: 'Course section for this enrollment',
+      },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 3. FACULTY MANAGEMENT NAMESPACE
+  //
+  const facultyManagement = domain.addNamespace({
+    info: {
+      name: 'FacultyManagement',
+      displayName: 'Faculty Management',
+      description: 'Teachers, staff, departments, and roles',
+    },
+  })
+
+  // Faculty Model
+  const facultyModel = facultyManagement.addModel({
+    info: {
+      name: 'Faculty',
+      displayName: 'Faculty Management',
+      description: 'Faculty and staff information',
+    },
+  })
+
+  // Faculty Entity
+  const facultyEntity = facultyModel.addEntity({
+    info: {
+      name: 'faculty',
+      displayName: 'Faculty Member',
+      description: 'Faculty member or staff',
+    },
+  })
+
+  addIdField(facultyEntity, { displayName: 'Faculty ID', description: 'Unique identifier for the faculty member' })
+
+  addFirstNameField(facultyEntity, { description: 'Faculty first name' })
+  addLastNameField(facultyEntity, { description: 'Faculty last name' })
+
+  addEmailField(facultyEntity, { description: 'Faculty email address' })
+  addPhoneField(facultyEntity, { description: 'Faculty phone number' })
+
+  addCustomStatusField(facultyEntity, ['active', 'inactive', 'on_leave', 'retired'], {
+    displayName: 'Faculty Status',
+    description: 'Current status of the faculty member',
+  })
+
+  facultyEntity.addProperty({
+    info: {
+      name: 'faculty_rank',
+      displayName: 'Faculty Rank',
+      description: 'Academic rank of the faculty member',
+    },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['professor', 'associate_professor', 'assistant_professor', 'lecturer', 'instructor'],
+    },
+  })
+
+  addCreatedAtField(facultyEntity, { description: 'When the faculty record was created' })
+  addUpdatedAtField(facultyEntity, { description: 'When the faculty record was last updated' })
+
+  // Department Entity
+  const departmentEntity = facultyModel.addEntity({
+    info: {
+      name: 'department',
+      displayName: 'Department',
+      description: 'Academic department',
+    },
+  })
+
+  addIdField(departmentEntity, { displayName: 'Department ID', description: 'Unique identifier for the department' })
+
+  addNameField(departmentEntity, { displayName: 'Department Name', description: 'Name of the department' })
+
+  addDescriptionField(departmentEntity, { description: 'Department description and mission' })
+
+  addCustomStatusField(departmentEntity, ['active', 'inactive', 'merged'], {
+    displayName: 'Department Status',
+    description: 'Current status of the department',
+  })
+
+  addCreatedAtField(departmentEntity, { description: 'When the department was created' })
+
+  // Faculty-Department Association (Many-to-One)
+  facultyEntity.addAssociation(
+    { key: departmentEntity.key },
+    {
+      info: { name: 'department', displayName: 'Department', description: 'Department for this faculty member' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // CourseSection-Faculty Association (Many-to-One)
+  courseSectionEntity.addAssociation(
+    { key: facultyEntity.key },
+    {
+      info: { name: 'instructor', displayName: 'Instructor', description: 'Faculty instructor for this section' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 4. CAMPUS OPERATIONS NAMESPACE
+  //
+  const campusOperations = domain.addNamespace({
+    info: {
+      name: 'CampusOperations',
+      displayName: 'Campus Operations',
+      description: 'Facilities, events, and resources',
+    },
+  })
+
+  // Campus Model
+  const campusModel = campusOperations.addModel({
+    info: {
+      name: 'Campus',
+      displayName: 'Campus Management',
+      description: 'Campus facilities and operations',
+    },
+  })
+
+  // Facility Entity
+  const facilityEntity = campusModel.addEntity({
+    info: {
+      name: 'facility',
+      displayName: 'Facility',
+      description: 'Campus facilities and buildings',
+    },
+  })
+
+  addIdField(facilityEntity, { displayName: 'Facility ID', description: 'Unique identifier for the facility' })
+
+  addNameField(facilityEntity, { displayName: 'Facility Name', description: 'Name of the facility' })
+
+  addDescriptionField(facilityEntity, { description: 'Facility description and features' })
+
+  facilityEntity.addProperty({
+    info: {
+      name: 'facility_type',
+      displayName: 'Facility Type',
+      description: 'Type of campus facility',
+    },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['classroom', 'laboratory', 'office', 'library', 'gymnasium', 'auditorium'],
+    },
+  })
+
+  addCustomStatusField(facilityEntity, ['active', 'maintenance', 'closed'], {
+    displayName: 'Facility Status',
+    description: 'Current status of the facility',
+  })
+
+  addCreatedAtField(facilityEntity, { description: 'When the facility was created' })
+
+  // Event Entity
+  const eventEntity = campusModel.addEntity({
+    info: {
+      name: 'event',
+      displayName: 'Event',
+      description: 'Campus events and activities',
+    },
+  })
+
+  addIdField(eventEntity, { displayName: 'Event ID', description: 'Unique identifier for the event' })
+
+  addNameField(eventEntity, { displayName: 'Event Name', description: 'Name of the event' })
+
+  addDescriptionField(eventEntity, { description: 'Event description and details' })
+
+  eventEntity.addProperty({
+    info: { name: 'start_date', displayName: 'Start Date', description: 'Event start date and time' },
+    type: 'datetime',
+    required: true,
+  })
+
+  eventEntity.addProperty({
+    info: { name: 'end_date', displayName: 'End Date', description: 'Event end date and time' },
+    type: 'datetime',
+    required: true,
+  })
+
+  addCustomStatusField(eventEntity, ['scheduled', 'in_progress', 'completed', 'cancelled'], {
+    displayName: 'Event Status',
+    description: 'Current status of the event',
+  })
+
+  addCreatedAtField(eventEntity, { description: 'When the event was created' })
+
+  // Event-Facility Association (Many-to-One)
+  eventEntity.addAssociation(
+    { key: facilityEntity.key },
+    {
+      info: { name: 'facility', displayName: 'Facility', description: 'Facility for this event' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 5. LEARNING ANALYTICS NAMESPACE
+  //
+  const learningAnalytics = domain.addNamespace({
+    info: {
+      name: 'LearningAnalytics',
+      displayName: 'Learning Analytics',
+      description: 'Progress tracking, assessments, and performance',
+    },
+  })
+
+  // Analytics Model
+  const analyticsModel = learningAnalytics.addModel({
+    info: {
+      name: 'Analytics',
+      displayName: 'Learning Analytics',
+      description: 'Student performance and learning analytics',
+    },
+  })
+
+  // Assessment Entity
+  const assessmentEntity = analyticsModel.addEntity({
+    info: {
+      name: 'assessment',
+      displayName: 'Assessment',
+      description: 'Student assessments and evaluations',
+    },
+  })
+
+  addIdField(assessmentEntity, { displayName: 'Assessment ID', description: 'Unique identifier for the assessment' })
+
+  addNameField(assessmentEntity, { displayName: 'Assessment Name', description: 'Name of the assessment' })
+
+  addDescriptionField(assessmentEntity, { description: 'Assessment description and criteria' })
+
+  assessmentEntity.addProperty({
+    info: {
+      name: 'assessment_date',
+      displayName: 'Assessment Date',
+      description: 'Date when assessment was conducted',
+    },
+    type: 'date',
+    required: true,
+  })
+
+  assessmentEntity.addProperty({
+    info: { name: 'score', displayName: 'Score', description: 'Assessment score' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+      maximum: 100,
+    },
+  })
+
+  addCustomStatusField(assessmentEntity, ['excellent', 'good', 'satisfactory', 'needs_improvement', 'unsatisfactory'], {
+    displayName: 'Assessment Level',
+    description: 'Performance level of the assessment',
+  })
+
+  addCreatedAtField(assessmentEntity, { description: 'When the assessment was created' })
+
+  // Assessment-Student Association (Many-to-One)
+  assessmentEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this assessment' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Progress Tracking Entity
+  const progressTrackingEntity = analyticsModel.addEntity({
+    info: {
+      name: 'progress_tracking',
+      displayName: 'Progress Tracking',
+      description: 'Student progress tracking and milestones',
+    },
+  })
+
+  addIdField(progressTrackingEntity, {
+    displayName: 'Progress ID',
+    description: 'Unique identifier for the progress record',
+  })
+
+  progressTrackingEntity.addProperty({
+    info: { name: 'tracking_date', displayName: 'Tracking Date', description: 'Date of progress tracking' },
+    type: 'date',
+    required: true,
+  })
+
+  progressTrackingEntity.addProperty({
+    info: {
+      name: 'completion_percentage',
+      displayName: 'Completion Percentage',
+      description: 'Percentage of course completed',
+    },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+      maximum: 100,
+    },
+  })
+
+  addCustomStatusField(progressTrackingEntity, ['on_track', 'ahead', 'behind', 'at_risk'], {
+    displayName: 'Progress Status',
+    description: 'Current progress status',
+  })
+
+  addDescriptionField(progressTrackingEntity, { description: 'Progress notes and observations' })
+
+  addCreatedAtField(progressTrackingEntity, { description: 'When the progress record was created' })
+
+  // ProgressTracking-Student Association (Many-to-One)
+  progressTrackingEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this progress tracking' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // ProgressTracking-CourseSection Association (Many-to-One)
+  progressTrackingEntity.addAssociation(
+    { key: courseSectionEntity.key },
+    {
+      info: { name: 'course_section', displayName: 'Course Section', description: 'Course section for this progress' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 6. ADMINISTRATIVE NAMESPACE
+  //
+  const administrative = domain.addNamespace({
+    info: {
+      name: 'Administrative',
+      displayName: 'Administrative',
+      description: 'Admissions, financial aid, and scheduling',
+    },
+  })
+
+  // Administrative Model
+  const administrativeModel = administrative.addModel({
+    info: {
+      name: 'Administrative',
+      displayName: 'Administrative Management',
+      description: 'Administrative processes and records',
+    },
+  })
+
+  // Admission Entity
+  const admissionEntity = administrativeModel.addEntity({
+    info: {
+      name: 'admission',
+      displayName: 'Admission',
+      description: 'Student admission records',
+    },
+  })
+
+  addIdField(admissionEntity, { displayName: 'Admission ID', description: 'Unique identifier for the admission' })
+
+  admissionEntity.addProperty({
+    info: {
+      name: 'application_date',
+      displayName: 'Application Date',
+      description: 'Date when application was submitted',
+    },
+    type: 'date',
+    required: true,
+  })
+
+  addCustomStatusField(admissionEntity, ['pending', 'under_review', 'accepted', 'rejected', 'waitlisted'], {
+    displayName: 'Admission Status',
+    description: 'Current status of the admission',
+  })
+
+  addDescriptionField(admissionEntity, { description: 'Admission notes and decisions' })
+
+  addCreatedAtField(admissionEntity, { description: 'When the admission was created' })
+
+  // Admission-Student Association (Many-to-One)
+  admissionEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this admission' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Financial Aid Entity
+  const financialAidEntity = administrativeModel.addEntity({
+    info: {
+      name: 'financial_aid',
+      displayName: 'Financial Aid',
+      description: 'Student financial aid and scholarships',
+    },
+  })
+
+  addIdField(financialAidEntity, {
+    displayName: 'Financial Aid ID',
+    description: 'Unique identifier for the financial aid',
+  })
+
+  financialAidEntity.addProperty({
+    info: {
+      name: 'aid_type',
+      displayName: 'Aid Type',
+      description: 'Type of financial aid',
+    },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['scholarship', 'grant', 'loan', 'work_study'],
+    },
+  })
+
+  addCurrencyAmountField(financialAidEntity, 'amount', 'Aid Amount', {
+    description: 'Amount of financial aid awarded',
+  })
+
+  addCustomStatusField(financialAidEntity, ['pending', 'approved', 'disbursed', 'cancelled'], {
+    displayName: 'Aid Status',
+    description: 'Current status of the financial aid',
+  })
+
+  addCreatedAtField(financialAidEntity, { description: 'When the financial aid was created' })
+
+  // FinancialAid-Student Association (Many-to-One)
+  financialAidEntity.addAssociation(
+    { key: studentEntity.key },
+    {
+      info: { name: 'student', displayName: 'Student', description: 'Student for this financial aid' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  return domain
+}