/**
 * 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';
function createDomain() {
    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 = {}) {
    // 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;
}
//# sourceMappingURL=education-domain.js.map