@rusaint/react-native 0.13.6 → 0.14.1

package/src/generated/rusaint.ts

@@ -70,6 +70,80 @@ const uniffiIsDebug =
   false;
 // Public interface members begin here.
 
+/**
+ * 대체 과목 정보
+ */
+export type AlternativeLecture = {
+  /**
+   * 구분
+   */
+  kind: string;
+  /**
+   * 과목번호
+   */
+  code: string;
+  /**
+   * 과목명
+   */
+  name: string;
+};
+
+/**
+ * Generated factory for {@link AlternativeLecture} record objects.
+ */
+export const AlternativeLecture = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<AlternativeLecture, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link AlternativeLecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link AlternativeLecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<AlternativeLecture>,
+  });
+})();
+
+const FfiConverterTypeAlternativeLecture = (() => {
+  type TypeName = AlternativeLecture;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        kind: FfiConverterString.read(from),
+        code: FfiConverterString.read(from),
+        name: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.kind, into);
+      FfiConverterString.write(value.code, into);
+      FfiConverterString.write(value.name, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.kind) +
+        FfiConverterString.allocationSize(value.code) +
+        FfiConverterString.allocationSize(value.name)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * 채플 결석신청 정보
  */
@@ -458,6 +532,122 @@ const FfiConverterTypeClassGrade = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * 이수구분별 개별 과목 성적
+ */
+export type ClassGradeItem = {
+  /**
+   * 이수구분 (e.g., "교양필수", "전공선택")
+   */
+  classification: string;
+  /**
+   * 학년도
+   */
+  year: string;
+  /**
+   * 학기
+   */
+  semester: string;
+  /**
+   * 과목코드
+   */
+  courseCode: string;
+  /**
+   * 과목명
+   */
+  courseName: string;
+  /**
+   * 학점
+   */
+  credits: string;
+  /**
+   * 성적 점수 (e.g., "100")
+   */
+  score: string;
+  /**
+   * 성적 등급 (e.g., "A+")
+   */
+  grade: string;
+  /**
+   * 비고
+   */
+  note: string;
+};
+
+/**
+ * Generated factory for {@link ClassGradeItem} record objects.
+ */
+export const ClassGradeItem = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ClassGradeItem, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ClassGradeItem}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ClassGradeItem}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<ClassGradeItem>,
+  });
+})();
+
+const FfiConverterTypeClassGradeItem = (() => {
+  type TypeName = ClassGradeItem;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        classification: FfiConverterString.read(from),
+        year: FfiConverterString.read(from),
+        semester: FfiConverterString.read(from),
+        courseCode: FfiConverterString.read(from),
+        courseName: FfiConverterString.read(from),
+        credits: FfiConverterString.read(from),
+        score: FfiConverterString.read(from),
+        grade: FfiConverterString.read(from),
+        note: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.classification, into);
+      FfiConverterString.write(value.year, into);
+      FfiConverterString.write(value.semester, into);
+      FfiConverterString.write(value.courseCode, into);
+      FfiConverterString.write(value.courseName, into);
+      FfiConverterString.write(value.credits, into);
+      FfiConverterString.write(value.score, into);
+      FfiConverterString.write(value.grade, into);
+      FfiConverterString.write(value.note, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.classification) +
+        FfiConverterString.allocationSize(value.year) +
+        FfiConverterString.allocationSize(value.semester) +
+        FfiConverterString.allocationSize(value.courseCode) +
+        FfiConverterString.allocationSize(value.courseName) +
+        FfiConverterString.allocationSize(value.credits) +
+        FfiConverterString.allocationSize(value.score) +
+        FfiConverterString.allocationSize(value.grade) +
+        FfiConverterString.allocationSize(value.note)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * 강의의 시간표 정보입니다.
  */
@@ -529,6 +719,80 @@ const FfiConverterTypeCourseScheduleInformation = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * 강의 검색 결과와 상세 정보, 강의계획서를 함께 담는 구조체
+ */
+export type DetailedLecture = {
+  /**
+   * 강의 기본 정보
+   */
+  lecture: Lecture;
+  /**
+   * 강의 상세 정보 (상세 정보 링크가 없는 경우 `None`)
+   */
+  detail: LectureDetail | undefined;
+  /**
+   * 강의계획서 (조회하지 않았거나 강의계획서가 없는 강의의 경우 `None`)
+   */
+  syllabus: LectureSyllabus | undefined;
+};
+
+/**
+ * Generated factory for {@link DetailedLecture} record objects.
+ */
+export const DetailedLecture = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<DetailedLecture, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link DetailedLecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link DetailedLecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<DetailedLecture>,
+  });
+})();
+
+const FfiConverterTypeDetailedLecture = (() => {
+  type TypeName = DetailedLecture;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        lecture: FfiConverterTypeLecture.read(from),
+        detail: FfiConverterOptionalTypeLectureDetail.read(from),
+        syllabus: FfiConverterOptionalTypeLectureSyllabus.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeLecture.write(value.lecture, into);
+      FfiConverterOptionalTypeLectureDetail.write(value.detail, into);
+      FfiConverterOptionalTypeLectureSyllabus.write(value.syllabus, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeLecture.allocationSize(value.lecture) +
+        FfiConverterOptionalTypeLectureDetail.allocationSize(value.detail) +
+        FfiConverterOptionalTypeLectureSyllabus.allocationSize(value.syllabus)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * 채플 기본 정보(좌석번호, 결석현황, 성적결과)
  */
@@ -711,6 +975,117 @@ const FfiConverterTypeGradeSummary = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * 이수구분별 성적 조회 결과
+ */
+export type GradesByClassification = {
+  /**
+   * 학번
+   */
+  studentNumber: string;
+  /**
+   * 이름
+   */
+  studentName: string;
+  /**
+   * 학년
+   */
+  yearLevel: string;
+  /**
+   * 대학
+   */
+  college: string;
+  /**
+   * 학부(과)
+   */
+  department: string;
+  /**
+   * 전공
+   */
+  major: string;
+  /**
+   * 조회일
+   */
+  auditDate: string;
+  /**
+   * 이수구분별 과목 성적 목록
+   */
+  grades: Array<ClassGradeItem>;
+};
+
+/**
+ * Generated factory for {@link GradesByClassification} record objects.
+ */
+export const GradesByClassification = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      GradesByClassification,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link GradesByClassification}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link GradesByClassification}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<GradesByClassification>,
+  });
+})();
+
+const FfiConverterTypeGradesByClassification = (() => {
+  type TypeName = GradesByClassification;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        studentNumber: FfiConverterString.read(from),
+        studentName: FfiConverterString.read(from),
+        yearLevel: FfiConverterString.read(from),
+        college: FfiConverterString.read(from),
+        department: FfiConverterString.read(from),
+        major: FfiConverterString.read(from),
+        auditDate: FfiConverterString.read(from),
+        grades: FfiConverterArrayTypeClassGradeItem.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.studentNumber, into);
+      FfiConverterString.write(value.studentName, into);
+      FfiConverterString.write(value.yearLevel, into);
+      FfiConverterString.write(value.college, into);
+      FfiConverterString.write(value.department, into);
+      FfiConverterString.write(value.major, into);
+      FfiConverterString.write(value.auditDate, into);
+      FfiConverterArrayTypeClassGradeItem.write(value.grades, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.studentNumber) +
+        FfiConverterString.allocationSize(value.studentName) +
+        FfiConverterString.allocationSize(value.yearLevel) +
+        FfiConverterString.allocationSize(value.college) +
+        FfiConverterString.allocationSize(value.department) +
+        FfiConverterString.allocationSize(value.major) +
+        FfiConverterString.allocationSize(value.auditDate) +
+        FfiConverterArrayTypeClassGradeItem.allocationSize(value.grades)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * 졸업 요건
  */
@@ -1214,32 +1589,593 @@ const FfiConverterTypeLectureAssessmentResult = (() => {
 })();
 
 /**
- * 개인의 수업 시간표 정보를 조회합니다.
+ * 강의 변경 이력
  */
-export type PersonalCourseSchedule = {
-  schedule: Map<Weekday, Array<CourseScheduleInformation>>;
+export type LectureChangeHistory = {
+  /**
+   * 시작일자
+   */
+  startDate: string;
+  /**
+   * 종료일자
+   */
+  endDate: string;
+  /**
+   * 과목명
+   */
+  name: string;
+};
+
+/**
+ * Generated factory for {@link LectureChangeHistory} record objects.
+ */
+export const LectureChangeHistory = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      LectureChangeHistory,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LectureChangeHistory}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LectureChangeHistory}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<LectureChangeHistory>,
+  });
+})();
+
+const FfiConverterTypeLectureChangeHistory = (() => {
+  type TypeName = LectureChangeHistory;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        startDate: FfiConverterString.read(from),
+        endDate: FfiConverterString.read(from),
+        name: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.startDate, into);
+      FfiConverterString.write(value.endDate, into);
+      FfiConverterString.write(value.name, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.startDate) +
+        FfiConverterString.allocationSize(value.endDate) +
+        FfiConverterString.allocationSize(value.name)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 강의 상세 정보
+ */
+export type LectureDetail = {
+  /**
+   * 강의 변경 이력 목록
+   */
+  changesHistory: Array<LectureChangeHistory>;
+  /**
+   * 대체 과목 목록
+   */
+  alternativeLectures: Array<AlternativeLecture>;
+  /**
+   * 과목 분류 목록
+   */
+  categories: Array<string>;
+  /**
+   * 선수 과목 목록
+   */
+  prerequisites: Array<PrerequisiteLecture>;
+};
+
+/**
+ * Generated factory for {@link LectureDetail} record objects.
+ */
+export const LectureDetail = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<LectureDetail, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LectureDetail}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LectureDetail}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<LectureDetail>,
+  });
+})();
+
+const FfiConverterTypeLectureDetail = (() => {
+  type TypeName = LectureDetail;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        changesHistory: FfiConverterArrayTypeLectureChangeHistory.read(from),
+        alternativeLectures: FfiConverterArrayTypeAlternativeLecture.read(from),
+        categories: FfiConverterArrayString.read(from),
+        prerequisites: FfiConverterArrayTypePrerequisiteLecture.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeLectureChangeHistory.write(
+        value.changesHistory,
+        into
+      );
+      FfiConverterArrayTypeAlternativeLecture.write(
+        value.alternativeLectures,
+        into
+      );
+      FfiConverterArrayString.write(value.categories, into);
+      FfiConverterArrayTypePrerequisiteLecture.write(value.prerequisites, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterArrayTypeLectureChangeHistory.allocationSize(
+          value.changesHistory
+        ) +
+        FfiConverterArrayTypeAlternativeLecture.allocationSize(
+          value.alternativeLectures
+        ) +
+        FfiConverterArrayString.allocationSize(value.categories) +
+        FfiConverterArrayTypePrerequisiteLecture.allocationSize(
+          value.prerequisites
+        )
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 강의계획서 - Full lecture syllabus information
+ */
+export type LectureSyllabus = {
+  /**
+   * 교과목명
+   */
+  courseName: string;
+  /**
+   * 담당교수
+   */
+  professor: string;
+  /**
+   * 과목코드
+   */
+  courseCode: string;
+  /**
+   * 학년도
+   */
+  year: string;
+  /**
+   * 학기
+   */
+  semester: string;
+  /**
+   * 학점
+   */
+  credits: string;
+  /**
+   * 강의개요
+   */
+  abstractText: string;
+  /**
+   * 수업방법
+   */
+  teachingMethod: string;
+  /**
+   * 주교재
+   */
+  mainTextbook: string;
+  /**
+   * 부교재
+   */
+  subTextbook: string;
+  /**
+   * 교수 전화번호
+   */
+  professorPhone: string;
+  /**
+   * 교수 이메일
+   */
+  professorEmail: string;
+  /**
+   * 상담시간
+   */
+  officeHours: string;
+  /**
+   * 수강대상
+   */
+  targetStudents: string;
+  /**
+   * 이수구분
+   */
+  designation: string;
+  /**
+   * 결석처리
+   */
+  absencePolicy: string;
+  /**
+   * 성적평가 항목
+   */
+  gradingItems: Array<SyllabusGradingItem>;
+  /**
+   * 학습목표
+   */
+  learningObjectives: Array<string>;
+  /**
+   * 주차별 수업계획
+   */
+  weeklySchedule: Array<SyllabusWeeklyPlan>;
+  /**
+   * 핵심역량
+   */
+  competencies: Array<SyllabusCompetency>;
+};
+
+/**
+ * Generated factory for {@link LectureSyllabus} record objects.
+ */
+export const LectureSyllabus = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<LectureSyllabus, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LectureSyllabus}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LectureSyllabus}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<LectureSyllabus>,
+  });
+})();
+
+const FfiConverterTypeLectureSyllabus = (() => {
+  type TypeName = LectureSyllabus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        courseName: FfiConverterString.read(from),
+        professor: FfiConverterString.read(from),
+        courseCode: FfiConverterString.read(from),
+        year: FfiConverterString.read(from),
+        semester: FfiConverterString.read(from),
+        credits: FfiConverterString.read(from),
+        abstractText: FfiConverterString.read(from),
+        teachingMethod: FfiConverterString.read(from),
+        mainTextbook: FfiConverterString.read(from),
+        subTextbook: FfiConverterString.read(from),
+        professorPhone: FfiConverterString.read(from),
+        professorEmail: FfiConverterString.read(from),
+        officeHours: FfiConverterString.read(from),
+        targetStudents: FfiConverterString.read(from),
+        designation: FfiConverterString.read(from),
+        absencePolicy: FfiConverterString.read(from),
+        gradingItems: FfiConverterArrayTypeSyllabusGradingItem.read(from),
+        learningObjectives: FfiConverterArrayString.read(from),
+        weeklySchedule: FfiConverterArrayTypeSyllabusWeeklyPlan.read(from),
+        competencies: FfiConverterArrayTypeSyllabusCompetency.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.courseName, into);
+      FfiConverterString.write(value.professor, into);
+      FfiConverterString.write(value.courseCode, into);
+      FfiConverterString.write(value.year, into);
+      FfiConverterString.write(value.semester, into);
+      FfiConverterString.write(value.credits, into);
+      FfiConverterString.write(value.abstractText, into);
+      FfiConverterString.write(value.teachingMethod, into);
+      FfiConverterString.write(value.mainTextbook, into);
+      FfiConverterString.write(value.subTextbook, into);
+      FfiConverterString.write(value.professorPhone, into);
+      FfiConverterString.write(value.professorEmail, into);
+      FfiConverterString.write(value.officeHours, into);
+      FfiConverterString.write(value.targetStudents, into);
+      FfiConverterString.write(value.designation, into);
+      FfiConverterString.write(value.absencePolicy, into);
+      FfiConverterArrayTypeSyllabusGradingItem.write(value.gradingItems, into);
+      FfiConverterArrayString.write(value.learningObjectives, into);
+      FfiConverterArrayTypeSyllabusWeeklyPlan.write(value.weeklySchedule, into);
+      FfiConverterArrayTypeSyllabusCompetency.write(value.competencies, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.courseName) +
+        FfiConverterString.allocationSize(value.professor) +
+        FfiConverterString.allocationSize(value.courseCode) +
+        FfiConverterString.allocationSize(value.year) +
+        FfiConverterString.allocationSize(value.semester) +
+        FfiConverterString.allocationSize(value.credits) +
+        FfiConverterString.allocationSize(value.abstractText) +
+        FfiConverterString.allocationSize(value.teachingMethod) +
+        FfiConverterString.allocationSize(value.mainTextbook) +
+        FfiConverterString.allocationSize(value.subTextbook) +
+        FfiConverterString.allocationSize(value.professorPhone) +
+        FfiConverterString.allocationSize(value.professorEmail) +
+        FfiConverterString.allocationSize(value.officeHours) +
+        FfiConverterString.allocationSize(value.targetStudents) +
+        FfiConverterString.allocationSize(value.designation) +
+        FfiConverterString.allocationSize(value.absencePolicy) +
+        FfiConverterArrayTypeSyllabusGradingItem.allocationSize(
+          value.gradingItems
+        ) +
+        FfiConverterArrayString.allocationSize(value.learningObjectives) +
+        FfiConverterArrayTypeSyllabusWeeklyPlan.allocationSize(
+          value.weeklySchedule
+        ) +
+        FfiConverterArrayTypeSyllabusCompetency.allocationSize(
+          value.competencies
+        )
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 개인의 수업 시간표 정보를 조회합니다.
+ */
+export type PersonalCourseSchedule = {
+  schedule: Map<Weekday, Array<CourseScheduleInformation>>;
+};
+
+/**
+ * Generated factory for {@link PersonalCourseSchedule} record objects.
+ */
+export const PersonalCourseSchedule = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      PersonalCourseSchedule,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PersonalCourseSchedule}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PersonalCourseSchedule}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<PersonalCourseSchedule>,
+  });
+})();
+
+const FfiConverterTypePersonalCourseSchedule = (() => {
+  type TypeName = PersonalCourseSchedule;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        schedule:
+          FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation.read(
+            from
+          ),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation.write(
+        value.schedule,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation.allocationSize(
+        value.schedule
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 선수 과목 정보
+ */
+export type PrerequisiteLecture = {
+  /**
+   * 과목번호
+   */
+  code: string;
+  /**
+   * 과목명
+   */
+  name: string;
+};
+
+/**
+ * Generated factory for {@link PrerequisiteLecture} record objects.
+ */
+export const PrerequisiteLecture = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<PrerequisiteLecture, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PrerequisiteLecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PrerequisiteLecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<PrerequisiteLecture>,
+  });
+})();
+
+const FfiConverterTypePrerequisiteLecture = (() => {
+  type TypeName = PrerequisiteLecture;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        code: FfiConverterString.read(from),
+        name: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.code, into);
+      FfiConverterString.write(value.name, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.code) +
+        FfiConverterString.allocationSize(value.name)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 수강신청한 과목 정보
+ */
+export type RegisteredLecture = {
+  /**
+   * 계획
+   */
+  syllabus: string | undefined;
+  /**
+   * 이수구분(주전공)
+   */
+  category: string;
+  /**
+   * 이수구분(다전공)
+   */
+  subCategory: string | undefined;
+  /**
+   * 공학인증
+   */
+  abeekInfo: string | undefined;
+  /**
+   * 교과영역
+   */
+  field: string | undefined;
+  /**
+   * 과목번호
+   */
+  code: string;
+  /**
+   * 과목명
+   */
+  name: string;
+  /**
+   * 분반
+   */
+  division: string | undefined;
+  /**
+   * 교수명
+   */
+  professor: string;
+  /**
+   * 개설학과
+   */
+  department: string;
+  /**
+   * 시간/학점(설계)
+   */
+  timePoints: string;
+  /**
+   * 수강인원
+   */
+  personeel: string;
+  /**
+   * 여석
+   */
+  remainingSeats: string;
+  /**
+   * 강의시간(강의실)
+   */
+  scheduleRoom: string;
+  /**
+   * 수강대상
+   */
+  target: string;
+  /**
+   * 비고
+   */
+  remarks: string;
 };
 
 /**
- * Generated factory for {@link PersonalCourseSchedule} record objects.
+ * Generated factory for {@link RegisteredLecture} record objects.
  */
-export const PersonalCourseSchedule = (() => {
+export const RegisteredLecture = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<
-      PersonalCourseSchedule,
-      ReturnType<typeof defaults>
-    >(defaults);
+    return uniffiCreateRecord<RegisteredLecture, ReturnType<typeof defaults>>(
+      defaults
+    );
   })();
   return Object.freeze({
     /**
-     * Create a frozen instance of {@link PersonalCourseSchedule}, with defaults specified
+     * Create a frozen instance of {@link RegisteredLecture}, with defaults specified
      * in Rust, in the {@link rusaint} crate.
      */
     create,
 
     /**
-     * Create a frozen instance of {@link PersonalCourseSchedule}, with defaults specified
+     * Create a frozen instance of {@link RegisteredLecture}, with defaults specified
      * in Rust, in the {@link rusaint} crate.
      */
     new: create,
@@ -1247,31 +2183,69 @@ export const PersonalCourseSchedule = (() => {
     /**
      * Defaults specified in the {@link rusaint} crate.
      */
-    defaults: () =>
-      Object.freeze(defaults()) as Partial<PersonalCourseSchedule>,
+    defaults: () => Object.freeze(defaults()) as Partial<RegisteredLecture>,
   });
 })();
 
-const FfiConverterTypePersonalCourseSchedule = (() => {
-  type TypeName = PersonalCourseSchedule;
+const FfiConverterTypeRegisteredLecture = (() => {
+  type TypeName = RegisteredLecture;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        schedule:
-          FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation.read(
-            from
-          ),
+        syllabus: FfiConverterOptionalString.read(from),
+        category: FfiConverterString.read(from),
+        subCategory: FfiConverterOptionalString.read(from),
+        abeekInfo: FfiConverterOptionalString.read(from),
+        field: FfiConverterOptionalString.read(from),
+        code: FfiConverterString.read(from),
+        name: FfiConverterString.read(from),
+        division: FfiConverterOptionalString.read(from),
+        professor: FfiConverterString.read(from),
+        department: FfiConverterString.read(from),
+        timePoints: FfiConverterString.read(from),
+        personeel: FfiConverterString.read(from),
+        remainingSeats: FfiConverterString.read(from),
+        scheduleRoom: FfiConverterString.read(from),
+        target: FfiConverterString.read(from),
+        remarks: FfiConverterString.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation.write(
-        value.schedule,
-        into
-      );
+      FfiConverterOptionalString.write(value.syllabus, into);
+      FfiConverterString.write(value.category, into);
+      FfiConverterOptionalString.write(value.subCategory, into);
+      FfiConverterOptionalString.write(value.abeekInfo, into);
+      FfiConverterOptionalString.write(value.field, into);
+      FfiConverterString.write(value.code, into);
+      FfiConverterString.write(value.name, into);
+      FfiConverterOptionalString.write(value.division, into);
+      FfiConverterString.write(value.professor, into);
+      FfiConverterString.write(value.department, into);
+      FfiConverterString.write(value.timePoints, into);
+      FfiConverterString.write(value.personeel, into);
+      FfiConverterString.write(value.remainingSeats, into);
+      FfiConverterString.write(value.scheduleRoom, into);
+      FfiConverterString.write(value.target, into);
+      FfiConverterString.write(value.remarks, into);
     }
     allocationSize(value: TypeName): number {
-      return FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation.allocationSize(
-        value.schedule
+      return (
+        FfiConverterOptionalString.allocationSize(value.syllabus) +
+        FfiConverterString.allocationSize(value.category) +
+        FfiConverterOptionalString.allocationSize(value.subCategory) +
+        FfiConverterOptionalString.allocationSize(value.abeekInfo) +
+        FfiConverterOptionalString.allocationSize(value.field) +
+        FfiConverterString.allocationSize(value.code) +
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterOptionalString.allocationSize(value.division) +
+        FfiConverterString.allocationSize(value.professor) +
+        FfiConverterString.allocationSize(value.department) +
+        FfiConverterString.allocationSize(value.timePoints) +
+        FfiConverterString.allocationSize(value.personeel) +
+        FfiConverterString.allocationSize(value.remainingSeats) +
+        FfiConverterString.allocationSize(value.scheduleRoom) +
+        FfiConverterString.allocationSize(value.target) +
+        FfiConverterString.allocationSize(value.remarks)
       );
     }
   }
@@ -2920,6 +3894,221 @@ const FfiConverterTypeStudentWorkInformation = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * 핵심역량
+ */
+export type SyllabusCompetency = {
+  /**
+   * 역량명
+   */
+  name: string;
+  /**
+   * 관련비율 (%)
+   */
+  rate: string;
+};
+
+/**
+ * Generated factory for {@link SyllabusCompetency} record objects.
+ */
+export const SyllabusCompetency = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SyllabusCompetency, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SyllabusCompetency}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SyllabusCompetency}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<SyllabusCompetency>,
+  });
+})();
+
+const FfiConverterTypeSyllabusCompetency = (() => {
+  type TypeName = SyllabusCompetency;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        name: FfiConverterString.read(from),
+        rate: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.name, into);
+      FfiConverterString.write(value.rate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterString.allocationSize(value.rate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 성적평가 항목
+ */
+export type SyllabusGradingItem = {
+  /**
+   * 평가항목명
+   */
+  name: string;
+  /**
+   * 비율 (%)
+   */
+  rate: string;
+};
+
+/**
+ * Generated factory for {@link SyllabusGradingItem} record objects.
+ */
+export const SyllabusGradingItem = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SyllabusGradingItem, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SyllabusGradingItem}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SyllabusGradingItem}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<SyllabusGradingItem>,
+  });
+})();
+
+const FfiConverterTypeSyllabusGradingItem = (() => {
+  type TypeName = SyllabusGradingItem;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        name: FfiConverterString.read(from),
+        rate: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.name, into);
+      FfiConverterString.write(value.rate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterString.allocationSize(value.rate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 주차별 수업계획
+ */
+export type SyllabusWeeklyPlan = {
+  /**
+   * 주차
+   */
+  week: string;
+  /**
+   * 핵심주제
+   */
+  topic: string;
+  /**
+   * 세부내용
+   */
+  details: string;
+  /**
+   * 수업방법
+   */
+  teachingMethod: string;
+};
+
+/**
+ * Generated factory for {@link SyllabusWeeklyPlan} record objects.
+ */
+export const SyllabusWeeklyPlan = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SyllabusWeeklyPlan, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SyllabusWeeklyPlan}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SyllabusWeeklyPlan}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link rusaint} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<SyllabusWeeklyPlan>,
+  });
+})();
+
+const FfiConverterTypeSyllabusWeeklyPlan = (() => {
+  type TypeName = SyllabusWeeklyPlan;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        week: FfiConverterString.read(from),
+        topic: FfiConverterString.read(from),
+        details: FfiConverterString.read(from),
+        teachingMethod: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.week, into);
+      FfiConverterString.write(value.topic, into);
+      FfiConverterString.write(value.details, into);
+      FfiConverterString.write(value.teachingMethod, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.week) +
+        FfiConverterString.allocationSize(value.topic) +
+        FfiConverterString.allocationSize(value.details) +
+        FfiConverterString.allocationSize(value.teachingMethod)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * uniffi 지원을 위한 u32 Pair입니다.
  */
@@ -4627,6 +5816,16 @@ const FfiConverterOptionalFloat32 = new FfiConverterOptional(
   FfiConverterFloat32
 );
 
+// FfiConverter for LectureDetail | undefined
+const FfiConverterOptionalTypeLectureDetail = new FfiConverterOptional(
+  FfiConverterTypeLectureDetail
+);
+
+// FfiConverter for LectureSyllabus | undefined
+const FfiConverterOptionalTypeLectureSyllabus = new FfiConverterOptional(
+  FfiConverterTypeLectureSyllabus
+);
+
 // FfiConverter for StudentForignStudyInformation | undefined
 const FfiConverterOptionalTypeStudentForignStudyInformation =
   new FfiConverterOptional(FfiConverterTypeStudentForignStudyInformation);
@@ -4651,6 +5850,11 @@ const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 // FfiConverter for /*u32*/number | undefined
 const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
 
+// FfiConverter for Array<AlternativeLecture>
+const FfiConverterArrayTypeAlternativeLecture = new FfiConverterArray(
+  FfiConverterTypeAlternativeLecture
+);
+
 // FfiConverter for Array<ChapelAbsenceRequest>
 const FfiConverterArrayTypeChapelAbsenceRequest = new FfiConverterArray(
   FfiConverterTypeChapelAbsenceRequest
@@ -4661,11 +5865,26 @@ const FfiConverterArrayTypeChapelAttendance = new FfiConverterArray(
   FfiConverterTypeChapelAttendance
 );
 
+// FfiConverter for Array<ClassGradeItem>
+const FfiConverterArrayTypeClassGradeItem = new FfiConverterArray(
+  FfiConverterTypeClassGradeItem
+);
+
 // FfiConverter for Array<CourseScheduleInformation>
 const FfiConverterArrayTypeCourseScheduleInformation = new FfiConverterArray(
   FfiConverterTypeCourseScheduleInformation
 );
 
+// FfiConverter for Array<LectureChangeHistory>
+const FfiConverterArrayTypeLectureChangeHistory = new FfiConverterArray(
+  FfiConverterTypeLectureChangeHistory
+);
+
+// FfiConverter for Array<PrerequisiteLecture>
+const FfiConverterArrayTypePrerequisiteLecture = new FfiConverterArray(
+  FfiConverterTypePrerequisiteLecture
+);
+
 // FfiConverter for Array<StudentAcademicRecord>
 const FfiConverterArrayTypeStudentAcademicRecord = new FfiConverterArray(
   FfiConverterTypeStudentAcademicRecord
@@ -4681,6 +5900,21 @@ const FfiConverterArrayTypeStudentTransferRecord = new FfiConverterArray(
   FfiConverterTypeStudentTransferRecord
 );
 
+// FfiConverter for Array<SyllabusCompetency>
+const FfiConverterArrayTypeSyllabusCompetency = new FfiConverterArray(
+  FfiConverterTypeSyllabusCompetency
+);
+
+// FfiConverter for Array<SyllabusGradingItem>
+const FfiConverterArrayTypeSyllabusGradingItem = new FfiConverterArray(
+  FfiConverterTypeSyllabusGradingItem
+);
+
+// FfiConverter for Array<SyllabusWeeklyPlan>
+const FfiConverterArrayTypeSyllabusWeeklyPlan = new FfiConverterArray(
+  FfiConverterTypeSyllabusWeeklyPlan
+);
+
 // FfiConverter for Array<string>
 const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
 
@@ -4827,15 +6061,19 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
+    FfiConverterTypeAlternativeLecture,
     FfiConverterTypeChapelAbsenceRequest,
     FfiConverterTypeChapelAttendance,
     FfiConverterTypeChapelInformation,
     FfiConverterTypeClassGrade,
+    FfiConverterTypeClassGradeItem,
     FfiConverterTypeClassScore,
     FfiConverterTypeCourseScheduleInformation,
     FfiConverterTypeCourseType,
+    FfiConverterTypeDetailedLecture,
     FfiConverterTypeGeneralChapelInformation,
     FfiConverterTypeGradeSummary,
+    FfiConverterTypeGradesByClassification,
     FfiConverterTypeGraduationRequirement,
     FfiConverterTypeGraduationRequirements,
     FfiConverterTypeGraduationStudent,
@@ -4843,7 +6081,12 @@ export default Object.freeze({
     FfiConverterTypeLectureAssessmentResult,
     FfiConverterTypeLectureCategory,
     FfiConverterTypeLectureCategoryBuilder,
+    FfiConverterTypeLectureChangeHistory,
+    FfiConverterTypeLectureDetail,
+    FfiConverterTypeLectureSyllabus,
     FfiConverterTypePersonalCourseSchedule,
+    FfiConverterTypePrerequisiteLecture,
+    FfiConverterTypeRegisteredLecture,
     FfiConverterTypeScholarship,
     FfiConverterTypeSemesterGrade,
     FfiConverterTypeSemesterType,
@@ -4864,6 +6107,9 @@ export default Object.freeze({
     FfiConverterTypeStudentTransferRecord,
     FfiConverterTypeStudentTransferRecords,
     FfiConverterTypeStudentWorkInformation,
+    FfiConverterTypeSyllabusCompetency,
+    FfiConverterTypeSyllabusGradingItem,
+    FfiConverterTypeSyllabusWeeklyPlan,
     FfiConverterTypeU32Pair,
     FfiConverterTypeUnsignedIntPair,
     FfiConverterTypeWeekday,