@rusaint/react-native 0.10.0-dev.0

package/src/generated/rusaint.ts

@@ -0,0 +1,4867 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+import nativeModule, {
+  type UniffiRustFutureContinuationCallback,
+  type UniffiForeignFuture,
+  type UniffiForeignFutureStructU8,
+  type UniffiForeignFutureCompleteU8,
+  type UniffiForeignFutureStructI8,
+  type UniffiForeignFutureCompleteI8,
+  type UniffiForeignFutureStructU16,
+  type UniffiForeignFutureCompleteU16,
+  type UniffiForeignFutureStructI16,
+  type UniffiForeignFutureCompleteI16,
+  type UniffiForeignFutureStructU32,
+  type UniffiForeignFutureCompleteU32,
+  type UniffiForeignFutureStructI32,
+  type UniffiForeignFutureCompleteI32,
+  type UniffiForeignFutureStructU64,
+  type UniffiForeignFutureCompleteU64,
+  type UniffiForeignFutureStructI64,
+  type UniffiForeignFutureCompleteI64,
+  type UniffiForeignFutureStructF32,
+  type UniffiForeignFutureCompleteF32,
+  type UniffiForeignFutureStructF64,
+  type UniffiForeignFutureCompleteF64,
+  type UniffiForeignFutureStructPointer,
+  type UniffiForeignFutureCompletePointer,
+  type UniffiForeignFutureStructRustBuffer,
+  type UniffiForeignFutureCompleteRustBuffer,
+  type UniffiForeignFutureStructVoid,
+  type UniffiForeignFutureCompleteVoid,
+} from './rusaint-ffi';
+import {
+  type FfiConverter,
+  type UniffiByteArray,
+  type UniffiObjectFactory,
+  type UniffiRustArcPtr,
+  type UnsafeMutableRawPointer,
+  AbstractFfiConverterByteArray,
+  FfiConverterArray,
+  FfiConverterArrayBuffer,
+  FfiConverterBool,
+  FfiConverterFloat32,
+  FfiConverterInt32,
+  FfiConverterMap,
+  FfiConverterObject,
+  FfiConverterOptional,
+  FfiConverterUInt32,
+  FfiConverterUInt64,
+  RustBuffer,
+  UniffiAbstractObject,
+  UniffiEnum,
+  UniffiInternalError,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  uniffiCreateRecord,
+  uniffiTypeNameSymbol,
+} from 'uniffi-bindgen-react-native';
+
+// Get converters from the other files, if any.
+const uniffiCaller = new UniffiRustCaller();
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== 'object' ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== 'production' ||
+  false;
+// Public interface members begin here.
+
+/**
+ * 채플 결석신청 정보
+ */
+export type ChapelAbsenceRequest = {
+  year: /*u32*/ number;
+  semester: SemesterType;
+  absenceDetail: string;
+  absenceStart: string;
+  absenceEnd: string;
+  absenceReasonKr: string;
+  absenceReasonEn: string;
+  applicationDate: string;
+  approvalDate: string;
+  denialReason: string;
+  status: string;
+};
+
+/**
+ * Generated factory for {@link ChapelAbsenceRequest} record objects.
+ */
+export const ChapelAbsenceRequest = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      ChapelAbsenceRequest,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ChapelAbsenceRequest}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ChapelAbsenceRequest}, 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<ChapelAbsenceRequest>,
+  });
+})();
+
+const FfiConverterTypeChapelAbsenceRequest = (() => {
+  type TypeName = ChapelAbsenceRequest;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        year: FfiConverterUInt32.read(from),
+        semester: FfiConverterTypeSemesterType.read(from),
+        absenceDetail: FfiConverterString.read(from),
+        absenceStart: FfiConverterString.read(from),
+        absenceEnd: FfiConverterString.read(from),
+        absenceReasonKr: FfiConverterString.read(from),
+        absenceReasonEn: FfiConverterString.read(from),
+        applicationDate: FfiConverterString.read(from),
+        approvalDate: FfiConverterString.read(from),
+        denialReason: FfiConverterString.read(from),
+        status: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.year, into);
+      FfiConverterTypeSemesterType.write(value.semester, into);
+      FfiConverterString.write(value.absenceDetail, into);
+      FfiConverterString.write(value.absenceStart, into);
+      FfiConverterString.write(value.absenceEnd, into);
+      FfiConverterString.write(value.absenceReasonKr, into);
+      FfiConverterString.write(value.absenceReasonEn, into);
+      FfiConverterString.write(value.applicationDate, into);
+      FfiConverterString.write(value.approvalDate, into);
+      FfiConverterString.write(value.denialReason, into);
+      FfiConverterString.write(value.status, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.year) +
+        FfiConverterTypeSemesterType.allocationSize(value.semester) +
+        FfiConverterString.allocationSize(value.absenceDetail) +
+        FfiConverterString.allocationSize(value.absenceStart) +
+        FfiConverterString.allocationSize(value.absenceEnd) +
+        FfiConverterString.allocationSize(value.absenceReasonKr) +
+        FfiConverterString.allocationSize(value.absenceReasonEn) +
+        FfiConverterString.allocationSize(value.applicationDate) +
+        FfiConverterString.allocationSize(value.approvalDate) +
+        FfiConverterString.allocationSize(value.denialReason) +
+        FfiConverterString.allocationSize(value.status)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 채플 수업별 출석정보
+ */
+export type ChapelAttendance = {
+  division: /*u32*/ number;
+  classDate: string;
+  category: string;
+  instructor: string;
+  instructorDepartment: string;
+  title: string;
+  attendance: string;
+  result: string;
+  note: string;
+};
+
+/**
+ * Generated factory for {@link ChapelAttendance} record objects.
+ */
+export const ChapelAttendance = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ChapelAttendance, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ChapelAttendance}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ChapelAttendance}, 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<ChapelAttendance>,
+  });
+})();
+
+const FfiConverterTypeChapelAttendance = (() => {
+  type TypeName = ChapelAttendance;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        division: FfiConverterUInt32.read(from),
+        classDate: FfiConverterString.read(from),
+        category: FfiConverterString.read(from),
+        instructor: FfiConverterString.read(from),
+        instructorDepartment: FfiConverterString.read(from),
+        title: FfiConverterString.read(from),
+        attendance: FfiConverterString.read(from),
+        result: FfiConverterString.read(from),
+        note: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.division, into);
+      FfiConverterString.write(value.classDate, into);
+      FfiConverterString.write(value.category, into);
+      FfiConverterString.write(value.instructor, into);
+      FfiConverterString.write(value.instructorDepartment, into);
+      FfiConverterString.write(value.title, into);
+      FfiConverterString.write(value.attendance, into);
+      FfiConverterString.write(value.result, into);
+      FfiConverterString.write(value.note, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.division) +
+        FfiConverterString.allocationSize(value.classDate) +
+        FfiConverterString.allocationSize(value.category) +
+        FfiConverterString.allocationSize(value.instructor) +
+        FfiConverterString.allocationSize(value.instructorDepartment) +
+        FfiConverterString.allocationSize(value.title) +
+        FfiConverterString.allocationSize(value.attendance) +
+        FfiConverterString.allocationSize(value.result) +
+        FfiConverterString.allocationSize(value.note)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학기별 채플 정보
+ */
+export type ChapelInformation = {
+  year: /*u32*/ number;
+  semester: SemesterType;
+  generalInformation: GeneralChapelInformation;
+  attendances: Array<ChapelAttendance>;
+  absenceRequests: Array<ChapelAbsenceRequest>;
+};
+
+/**
+ * Generated factory for {@link ChapelInformation} record objects.
+ */
+export const ChapelInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ChapelInformation, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ChapelInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ChapelInformation}, 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<ChapelInformation>,
+  });
+})();
+
+const FfiConverterTypeChapelInformation = (() => {
+  type TypeName = ChapelInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        year: FfiConverterUInt32.read(from),
+        semester: FfiConverterTypeSemesterType.read(from),
+        generalInformation: FfiConverterTypeGeneralChapelInformation.read(from),
+        attendances: FfiConverterArrayTypeChapelAttendance.read(from),
+        absenceRequests: FfiConverterArrayTypeChapelAbsenceRequest.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.year, into);
+      FfiConverterTypeSemesterType.write(value.semester, into);
+      FfiConverterTypeGeneralChapelInformation.write(
+        value.generalInformation,
+        into
+      );
+      FfiConverterArrayTypeChapelAttendance.write(value.attendances, into);
+      FfiConverterArrayTypeChapelAbsenceRequest.write(
+        value.absenceRequests,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.year) +
+        FfiConverterTypeSemesterType.allocationSize(value.semester) +
+        FfiConverterTypeGeneralChapelInformation.allocationSize(
+          value.generalInformation
+        ) +
+        FfiConverterArrayTypeChapelAttendance.allocationSize(
+          value.attendances
+        ) +
+        FfiConverterArrayTypeChapelAbsenceRequest.allocationSize(
+          value.absenceRequests
+        )
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 과목별 성적
+ */
+export type ClassGrade = {
+  /**
+   * 이수학년도
+   */
+  year: /*u32*/ number;
+  /**
+   * 이수학기
+   */
+  semester: SemesterType;
+  /**
+   * 과목코드
+   */
+  code: string;
+  /**
+   * 과목명
+   */
+  className: string;
+  /**
+   * 과목학점
+   */
+  gradePoints: /*f32*/ number;
+  /**
+   * 성적
+   */
+  score: ClassScore;
+  /**
+   * 등급
+   */
+  rank: string;
+  /**
+   * 교수명
+   */
+  professor: string;
+  /**
+   * 상세성적
+   */
+  detail: Map<string, /*f32*/ number> | undefined;
+};
+
+/**
+ * Generated factory for {@link ClassGrade} record objects.
+ */
+export const ClassGrade = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ClassGrade, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ClassGrade}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ClassGrade}, 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<ClassGrade>,
+  });
+})();
+
+const FfiConverterTypeClassGrade = (() => {
+  type TypeName = ClassGrade;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        year: FfiConverterUInt32.read(from),
+        semester: FfiConverterTypeSemesterType.read(from),
+        code: FfiConverterString.read(from),
+        className: FfiConverterString.read(from),
+        gradePoints: FfiConverterFloat32.read(from),
+        score: FfiConverterTypeClassScore.read(from),
+        rank: FfiConverterString.read(from),
+        professor: FfiConverterString.read(from),
+        detail: FfiConverterOptionalMapStringFloat32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.year, into);
+      FfiConverterTypeSemesterType.write(value.semester, into);
+      FfiConverterString.write(value.code, into);
+      FfiConverterString.write(value.className, into);
+      FfiConverterFloat32.write(value.gradePoints, into);
+      FfiConverterTypeClassScore.write(value.score, into);
+      FfiConverterString.write(value.rank, into);
+      FfiConverterString.write(value.professor, into);
+      FfiConverterOptionalMapStringFloat32.write(value.detail, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.year) +
+        FfiConverterTypeSemesterType.allocationSize(value.semester) +
+        FfiConverterString.allocationSize(value.code) +
+        FfiConverterString.allocationSize(value.className) +
+        FfiConverterFloat32.allocationSize(value.gradePoints) +
+        FfiConverterTypeClassScore.allocationSize(value.score) +
+        FfiConverterString.allocationSize(value.rank) +
+        FfiConverterString.allocationSize(value.professor) +
+        FfiConverterOptionalMapStringFloat32.allocationSize(value.detail)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 강의의 시간표 정보입니다.
+ */
+export type CourseScheduleInformation = {
+  name: string;
+  professor: string;
+  time: string;
+  classroom: string;
+};
+
+/**
+ * Generated factory for {@link CourseScheduleInformation} record objects.
+ */
+export const CourseScheduleInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      CourseScheduleInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link CourseScheduleInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link CourseScheduleInformation}, 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<CourseScheduleInformation>,
+  });
+})();
+
+const FfiConverterTypeCourseScheduleInformation = (() => {
+  type TypeName = CourseScheduleInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        name: FfiConverterString.read(from),
+        professor: FfiConverterString.read(from),
+        time: FfiConverterString.read(from),
+        classroom: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.name, into);
+      FfiConverterString.write(value.professor, into);
+      FfiConverterString.write(value.time, into);
+      FfiConverterString.write(value.classroom, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterString.allocationSize(value.professor) +
+        FfiConverterString.allocationSize(value.time) +
+        FfiConverterString.allocationSize(value.classroom)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 채플 기본 정보(좌석번호, 결석현황, 성적결과)
+ */
+export type GeneralChapelInformation = {
+  division: /*u32*/ number;
+  chapelTime: string;
+  chapelRoom: string;
+  floorLevel: /*u32*/ number;
+  seatNumber: string;
+  absenceTime: /*u32*/ number;
+  result: string;
+  note: string;
+};
+
+/**
+ * Generated factory for {@link GeneralChapelInformation} record objects.
+ */
+export const GeneralChapelInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      GeneralChapelInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link GeneralChapelInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link GeneralChapelInformation}, 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<GeneralChapelInformation>,
+  });
+})();
+
+const FfiConverterTypeGeneralChapelInformation = (() => {
+  type TypeName = GeneralChapelInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        division: FfiConverterUInt32.read(from),
+        chapelTime: FfiConverterString.read(from),
+        chapelRoom: FfiConverterString.read(from),
+        floorLevel: FfiConverterUInt32.read(from),
+        seatNumber: FfiConverterString.read(from),
+        absenceTime: FfiConverterUInt32.read(from),
+        result: FfiConverterString.read(from),
+        note: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.division, into);
+      FfiConverterString.write(value.chapelTime, into);
+      FfiConverterString.write(value.chapelRoom, into);
+      FfiConverterUInt32.write(value.floorLevel, into);
+      FfiConverterString.write(value.seatNumber, into);
+      FfiConverterUInt32.write(value.absenceTime, into);
+      FfiConverterString.write(value.result, into);
+      FfiConverterString.write(value.note, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.division) +
+        FfiConverterString.allocationSize(value.chapelTime) +
+        FfiConverterString.allocationSize(value.chapelRoom) +
+        FfiConverterUInt32.allocationSize(value.floorLevel) +
+        FfiConverterString.allocationSize(value.seatNumber) +
+        FfiConverterUInt32.allocationSize(value.absenceTime) +
+        FfiConverterString.allocationSize(value.result) +
+        FfiConverterString.allocationSize(value.note)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 전체 성적(학적부, 증명)
+ */
+export type GradeSummary = {
+  /**
+   * 신청학점
+   */
+  attemptedCredits: /*f32*/ number;
+  /**
+   * 취득학점
+   */
+  earnedCredits: /*f32*/ number;
+  /**
+   * 평점계
+   */
+  gradePointsSum: /*f32*/ number;
+  /**
+   * 평점평균
+   */
+  gradePointsAverage: /*f32*/ number;
+  /**
+   * 산술평균
+   */
+  arithmeticMean: /*f32*/ number;
+  /**
+   * P/F 학점계
+   */
+  pfEarnedCredits: /*f32*/ number;
+};
+
+/**
+ * Generated factory for {@link GradeSummary} record objects.
+ */
+export const GradeSummary = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<GradeSummary, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link GradeSummary}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link GradeSummary}, 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<GradeSummary>,
+  });
+})();
+
+const FfiConverterTypeGradeSummary = (() => {
+  type TypeName = GradeSummary;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        attemptedCredits: FfiConverterFloat32.read(from),
+        earnedCredits: FfiConverterFloat32.read(from),
+        gradePointsSum: FfiConverterFloat32.read(from),
+        gradePointsAverage: FfiConverterFloat32.read(from),
+        arithmeticMean: FfiConverterFloat32.read(from),
+        pfEarnedCredits: FfiConverterFloat32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterFloat32.write(value.attemptedCredits, into);
+      FfiConverterFloat32.write(value.earnedCredits, into);
+      FfiConverterFloat32.write(value.gradePointsSum, into);
+      FfiConverterFloat32.write(value.gradePointsAverage, into);
+      FfiConverterFloat32.write(value.arithmeticMean, into);
+      FfiConverterFloat32.write(value.pfEarnedCredits, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterFloat32.allocationSize(value.attemptedCredits) +
+        FfiConverterFloat32.allocationSize(value.earnedCredits) +
+        FfiConverterFloat32.allocationSize(value.gradePointsSum) +
+        FfiConverterFloat32.allocationSize(value.gradePointsAverage) +
+        FfiConverterFloat32.allocationSize(value.arithmeticMean) +
+        FfiConverterFloat32.allocationSize(value.pfEarnedCredits)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 졸업 요건
+ */
+export type GraduationRequirement = {
+  name: string;
+  requirement: /*u32*/ number | undefined;
+  calcuation: /*f32*/ number | undefined;
+  difference: /*f32*/ number | undefined;
+  result: boolean;
+  category: string;
+  lectures: Array<string>;
+};
+
+/**
+ * Generated factory for {@link GraduationRequirement} record objects.
+ */
+export const GraduationRequirement = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      GraduationRequirement,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link GraduationRequirement}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link GraduationRequirement}, 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<GraduationRequirement>,
+  });
+})();
+
+const FfiConverterTypeGraduationRequirement = (() => {
+  type TypeName = GraduationRequirement;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        name: FfiConverterString.read(from),
+        requirement: FfiConverterOptionalUInt32.read(from),
+        calcuation: FfiConverterOptionalFloat32.read(from),
+        difference: FfiConverterOptionalFloat32.read(from),
+        result: FfiConverterBool.read(from),
+        category: FfiConverterString.read(from),
+        lectures: FfiConverterArrayString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.name, into);
+      FfiConverterOptionalUInt32.write(value.requirement, into);
+      FfiConverterOptionalFloat32.write(value.calcuation, into);
+      FfiConverterOptionalFloat32.write(value.difference, into);
+      FfiConverterBool.write(value.result, into);
+      FfiConverterString.write(value.category, into);
+      FfiConverterArrayString.write(value.lectures, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterOptionalUInt32.allocationSize(value.requirement) +
+        FfiConverterOptionalFloat32.allocationSize(value.calcuation) +
+        FfiConverterOptionalFloat32.allocationSize(value.difference) +
+        FfiConverterBool.allocationSize(value.result) +
+        FfiConverterString.allocationSize(value.category) +
+        FfiConverterArrayString.allocationSize(value.lectures)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 전체 졸업 요건 정보
+ */
+export type GraduationRequirements = {
+  isGraduatable: boolean;
+  requirements: Map<string, GraduationRequirement>;
+};
+
+/**
+ * Generated factory for {@link GraduationRequirements} record objects.
+ */
+export const GraduationRequirements = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      GraduationRequirements,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link GraduationRequirements}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link GraduationRequirements}, 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<GraduationRequirements>,
+  });
+})();
+
+const FfiConverterTypeGraduationRequirements = (() => {
+  type TypeName = GraduationRequirements;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        isGraduatable: FfiConverterBool.read(from),
+        requirements: FfiConverterMapStringTypeGraduationRequirement.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterBool.write(value.isGraduatable, into);
+      FfiConverterMapStringTypeGraduationRequirement.write(
+        value.requirements,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterBool.allocationSize(value.isGraduatable) +
+        FfiConverterMapStringTypeGraduationRequirement.allocationSize(
+          value.requirements
+        )
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 졸업 학생 정보
+ */
+export type GraduationStudent = {
+  number: /*u32*/ number;
+  name: string;
+  grade: /*u32*/ number;
+  semester: /*u32*/ number;
+  status: string;
+  applyYear: /*u32*/ number;
+  applyType: string;
+  department: string;
+  majors: Array<string>;
+  auditDate: string;
+  graduationPoints: /*f32*/ number;
+  completedPoints: /*f32*/ number;
+};
+
+/**
+ * Generated factory for {@link GraduationStudent} record objects.
+ */
+export const GraduationStudent = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<GraduationStudent, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link GraduationStudent}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link GraduationStudent}, 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<GraduationStudent>,
+  });
+})();
+
+const FfiConverterTypeGraduationStudent = (() => {
+  type TypeName = GraduationStudent;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        number: FfiConverterUInt32.read(from),
+        name: FfiConverterString.read(from),
+        grade: FfiConverterUInt32.read(from),
+        semester: FfiConverterUInt32.read(from),
+        status: FfiConverterString.read(from),
+        applyYear: FfiConverterUInt32.read(from),
+        applyType: FfiConverterString.read(from),
+        department: FfiConverterString.read(from),
+        majors: FfiConverterArrayString.read(from),
+        auditDate: FfiConverterString.read(from),
+        graduationPoints: FfiConverterFloat32.read(from),
+        completedPoints: FfiConverterFloat32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.number, into);
+      FfiConverterString.write(value.name, into);
+      FfiConverterUInt32.write(value.grade, into);
+      FfiConverterUInt32.write(value.semester, into);
+      FfiConverterString.write(value.status, into);
+      FfiConverterUInt32.write(value.applyYear, into);
+      FfiConverterString.write(value.applyType, into);
+      FfiConverterString.write(value.department, into);
+      FfiConverterArrayString.write(value.majors, into);
+      FfiConverterString.write(value.auditDate, into);
+      FfiConverterFloat32.write(value.graduationPoints, into);
+      FfiConverterFloat32.write(value.completedPoints, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.number) +
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterUInt32.allocationSize(value.grade) +
+        FfiConverterUInt32.allocationSize(value.semester) +
+        FfiConverterString.allocationSize(value.status) +
+        FfiConverterUInt32.allocationSize(value.applyYear) +
+        FfiConverterString.allocationSize(value.applyType) +
+        FfiConverterString.allocationSize(value.department) +
+        FfiConverterArrayString.allocationSize(value.majors) +
+        FfiConverterString.allocationSize(value.auditDate) +
+        FfiConverterFloat32.allocationSize(value.graduationPoints) +
+        FfiConverterFloat32.allocationSize(value.completedPoints)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 과목 정보
+ */
+export type Lecture = {
+  /**
+   * 계획
+   */
+  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;
+};
+
+/**
+ * Generated factory for {@link Lecture} record objects.
+ */
+export const Lecture = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<Lecture, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Lecture}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link Lecture}, 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<Lecture>,
+  });
+})();
+
+const FfiConverterTypeLecture = (() => {
+  type TypeName = Lecture;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        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),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      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);
+    }
+    allocationSize(value: TypeName): number {
+      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)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 강의평가 결과
+ */
+export type LectureAssessmentResult = {
+  year: string;
+  semester: SemesterType;
+  lectureCode: /*u32*/ number;
+  lectureName: string;
+  points: /*f32*/ number;
+  professor: string;
+  collage: string;
+  department: string;
+  position: string;
+  score: /*f32*/ number;
+};
+
+/**
+ * Generated factory for {@link LectureAssessmentResult} record objects.
+ */
+export const LectureAssessmentResult = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      LectureAssessmentResult,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LectureAssessmentResult}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LectureAssessmentResult}, 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<LectureAssessmentResult>,
+  });
+})();
+
+const FfiConverterTypeLectureAssessmentResult = (() => {
+  type TypeName = LectureAssessmentResult;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        year: FfiConverterString.read(from),
+        semester: FfiConverterTypeSemesterType.read(from),
+        lectureCode: FfiConverterUInt32.read(from),
+        lectureName: FfiConverterString.read(from),
+        points: FfiConverterFloat32.read(from),
+        professor: FfiConverterString.read(from),
+        collage: FfiConverterString.read(from),
+        department: FfiConverterString.read(from),
+        position: FfiConverterString.read(from),
+        score: FfiConverterFloat32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.year, into);
+      FfiConverterTypeSemesterType.write(value.semester, into);
+      FfiConverterUInt32.write(value.lectureCode, into);
+      FfiConverterString.write(value.lectureName, into);
+      FfiConverterFloat32.write(value.points, into);
+      FfiConverterString.write(value.professor, into);
+      FfiConverterString.write(value.collage, into);
+      FfiConverterString.write(value.department, into);
+      FfiConverterString.write(value.position, into);
+      FfiConverterFloat32.write(value.score, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.year) +
+        FfiConverterTypeSemesterType.allocationSize(value.semester) +
+        FfiConverterUInt32.allocationSize(value.lectureCode) +
+        FfiConverterString.allocationSize(value.lectureName) +
+        FfiConverterFloat32.allocationSize(value.points) +
+        FfiConverterString.allocationSize(value.professor) +
+        FfiConverterString.allocationSize(value.collage) +
+        FfiConverterString.allocationSize(value.department) +
+        FfiConverterString.allocationSize(value.position) +
+        FfiConverterFloat32.allocationSize(value.score)
+      );
+    }
+  }
+  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 Scholarship = {
+  year: /*u32*/ number;
+  semester: SemesterType;
+  name: string;
+  receivedAmount: /*u64*/ bigint;
+  receiveType: string;
+  status: string;
+  processedAt: string;
+  selectedAmount: /*u64*/ bigint;
+  refundedAmount: /*u64*/ bigint;
+  replacedAmount: /*u64*/ bigint;
+  replacedBy: string;
+  dropReason: string;
+  note: string;
+  workedAt: string;
+};
+
+/**
+ * Generated factory for {@link Scholarship} record objects.
+ */
+export const Scholarship = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<Scholarship, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Scholarship}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link Scholarship}, 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<Scholarship>,
+  });
+})();
+
+const FfiConverterTypeScholarship = (() => {
+  type TypeName = Scholarship;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        year: FfiConverterUInt32.read(from),
+        semester: FfiConverterTypeSemesterType.read(from),
+        name: FfiConverterString.read(from),
+        receivedAmount: FfiConverterUInt64.read(from),
+        receiveType: FfiConverterString.read(from),
+        status: FfiConverterString.read(from),
+        processedAt: FfiConverterString.read(from),
+        selectedAmount: FfiConverterUInt64.read(from),
+        refundedAmount: FfiConverterUInt64.read(from),
+        replacedAmount: FfiConverterUInt64.read(from),
+        replacedBy: FfiConverterString.read(from),
+        dropReason: FfiConverterString.read(from),
+        note: FfiConverterString.read(from),
+        workedAt: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.year, into);
+      FfiConverterTypeSemesterType.write(value.semester, into);
+      FfiConverterString.write(value.name, into);
+      FfiConverterUInt64.write(value.receivedAmount, into);
+      FfiConverterString.write(value.receiveType, into);
+      FfiConverterString.write(value.status, into);
+      FfiConverterString.write(value.processedAt, into);
+      FfiConverterUInt64.write(value.selectedAmount, into);
+      FfiConverterUInt64.write(value.refundedAmount, into);
+      FfiConverterUInt64.write(value.replacedAmount, into);
+      FfiConverterString.write(value.replacedBy, into);
+      FfiConverterString.write(value.dropReason, into);
+      FfiConverterString.write(value.note, into);
+      FfiConverterString.write(value.workedAt, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.year) +
+        FfiConverterTypeSemesterType.allocationSize(value.semester) +
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterUInt64.allocationSize(value.receivedAmount) +
+        FfiConverterString.allocationSize(value.receiveType) +
+        FfiConverterString.allocationSize(value.status) +
+        FfiConverterString.allocationSize(value.processedAt) +
+        FfiConverterUInt64.allocationSize(value.selectedAmount) +
+        FfiConverterUInt64.allocationSize(value.refundedAmount) +
+        FfiConverterUInt64.allocationSize(value.replacedAmount) +
+        FfiConverterString.allocationSize(value.replacedBy) +
+        FfiConverterString.allocationSize(value.dropReason) +
+        FfiConverterString.allocationSize(value.note) +
+        FfiConverterString.allocationSize(value.workedAt)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학기별 성적
+ */
+export type SemesterGrade = {
+  /**
+   * 학년도
+   */
+  year: /*u32*/ number;
+  /**
+   * 학기
+   */
+  semester: SemesterType;
+  /**
+   * 신청학점
+   */
+  attemptedCredits: /*f32*/ number;
+  /**
+   * 취득학점
+   */
+  earnedCredits: /*f32*/ number;
+  /**
+   * P/F학점
+   */
+  pfEarnedCredits: /*f32*/ number;
+  /**
+   * 평점평균
+   */
+  gradePointsAverage: /*f32*/ number;
+  /**
+   * 평점계
+   */
+  gradePointsSum: /*f32*/ number;
+  /**
+   * 산술평균
+   */
+  arithmeticMean: /*f32*/ number;
+  /**
+   * 학기별석차
+   */
+  semesterRank: U32Pair;
+  /**
+   * 전체석차
+   */
+  generalRank: U32Pair;
+  /**
+   * 학사경고
+   */
+  academicProbation: boolean;
+  /**
+   * 상담여부
+   */
+  consult: boolean;
+  /**
+   * 유급
+   */
+  flunked: boolean;
+};
+
+/**
+ * Generated factory for {@link SemesterGrade} record objects.
+ */
+export const SemesterGrade = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SemesterGrade, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SemesterGrade}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SemesterGrade}, 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<SemesterGrade>,
+  });
+})();
+
+const FfiConverterTypeSemesterGrade = (() => {
+  type TypeName = SemesterGrade;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        year: FfiConverterUInt32.read(from),
+        semester: FfiConverterTypeSemesterType.read(from),
+        attemptedCredits: FfiConverterFloat32.read(from),
+        earnedCredits: FfiConverterFloat32.read(from),
+        pfEarnedCredits: FfiConverterFloat32.read(from),
+        gradePointsAverage: FfiConverterFloat32.read(from),
+        gradePointsSum: FfiConverterFloat32.read(from),
+        arithmeticMean: FfiConverterFloat32.read(from),
+        semesterRank: FfiConverterTypeU32Pair.read(from),
+        generalRank: FfiConverterTypeU32Pair.read(from),
+        academicProbation: FfiConverterBool.read(from),
+        consult: FfiConverterBool.read(from),
+        flunked: FfiConverterBool.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.year, into);
+      FfiConverterTypeSemesterType.write(value.semester, into);
+      FfiConverterFloat32.write(value.attemptedCredits, into);
+      FfiConverterFloat32.write(value.earnedCredits, into);
+      FfiConverterFloat32.write(value.pfEarnedCredits, into);
+      FfiConverterFloat32.write(value.gradePointsAverage, into);
+      FfiConverterFloat32.write(value.gradePointsSum, into);
+      FfiConverterFloat32.write(value.arithmeticMean, into);
+      FfiConverterTypeU32Pair.write(value.semesterRank, into);
+      FfiConverterTypeU32Pair.write(value.generalRank, into);
+      FfiConverterBool.write(value.academicProbation, into);
+      FfiConverterBool.write(value.consult, into);
+      FfiConverterBool.write(value.flunked, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.year) +
+        FfiConverterTypeSemesterType.allocationSize(value.semester) +
+        FfiConverterFloat32.allocationSize(value.attemptedCredits) +
+        FfiConverterFloat32.allocationSize(value.earnedCredits) +
+        FfiConverterFloat32.allocationSize(value.pfEarnedCredits) +
+        FfiConverterFloat32.allocationSize(value.gradePointsAverage) +
+        FfiConverterFloat32.allocationSize(value.gradePointsSum) +
+        FfiConverterFloat32.allocationSize(value.arithmeticMean) +
+        FfiConverterTypeU32Pair.allocationSize(value.semesterRank) +
+        FfiConverterTypeU32Pair.allocationSize(value.generalRank) +
+        FfiConverterBool.allocationSize(value.academicProbation) +
+        FfiConverterBool.allocationSize(value.consult) +
+        FfiConverterBool.allocationSize(value.flunked)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 학적상태 기록
+ */
+export type StudentAcademicRecord = {
+  startDate: string;
+  endDate: string;
+  year: string;
+  term: string;
+  category: string;
+  reason: string;
+  processDate: string;
+};
+
+/**
+ * Generated factory for {@link StudentAcademicRecord} record objects.
+ */
+export const StudentAcademicRecord = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentAcademicRecord,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentAcademicRecord}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentAcademicRecord}, 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<StudentAcademicRecord>,
+  });
+})();
+
+const FfiConverterTypeStudentAcademicRecord = (() => {
+  type TypeName = StudentAcademicRecord;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        startDate: FfiConverterString.read(from),
+        endDate: FfiConverterString.read(from),
+        year: FfiConverterString.read(from),
+        term: FfiConverterString.read(from),
+        category: FfiConverterString.read(from),
+        reason: FfiConverterString.read(from),
+        processDate: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.startDate, into);
+      FfiConverterString.write(value.endDate, into);
+      FfiConverterString.write(value.year, into);
+      FfiConverterString.write(value.term, into);
+      FfiConverterString.write(value.category, into);
+      FfiConverterString.write(value.reason, into);
+      FfiConverterString.write(value.processDate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.startDate) +
+        FfiConverterString.allocationSize(value.endDate) +
+        FfiConverterString.allocationSize(value.year) +
+        FfiConverterString.allocationSize(value.term) +
+        FfiConverterString.allocationSize(value.category) +
+        FfiConverterString.allocationSize(value.reason) +
+        FfiConverterString.allocationSize(value.processDate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 학적상태 정보
+ */
+export type StudentAcademicRecords = {
+  records: Array<StudentAcademicRecord>;
+};
+
+/**
+ * Generated factory for {@link StudentAcademicRecords} record objects.
+ */
+export const StudentAcademicRecords = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentAcademicRecords,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentAcademicRecords}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentAcademicRecords}, 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<StudentAcademicRecords>,
+  });
+})();
+
+const FfiConverterTypeStudentAcademicRecords = (() => {
+  type TypeName = StudentAcademicRecords;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        records: FfiConverterArrayTypeStudentAcademicRecord.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeStudentAcademicRecord.write(value.records, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayTypeStudentAcademicRecord.allocationSize(
+        value.records
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 은행 계좌 정보
+ */
+export type StudentBankAccount = {
+  bank: string | undefined;
+  accountNumber: string | undefined;
+  holder: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentBankAccount} record objects.
+ */
+export const StudentBankAccount = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<StudentBankAccount, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentBankAccount}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentBankAccount}, 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<StudentBankAccount>,
+  });
+})();
+
+const FfiConverterTypeStudentBankAccount = (() => {
+  type TypeName = StudentBankAccount;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        bank: FfiConverterOptionalString.read(from),
+        accountNumber: FfiConverterOptionalString.read(from),
+        holder: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.bank, into);
+      FfiConverterOptionalString.write(value.accountNumber, into);
+      FfiConverterOptionalString.write(value.holder, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.bank) +
+        FfiConverterOptionalString.allocationSize(value.accountNumber) +
+        FfiConverterOptionalString.allocationSize(value.holder)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 가족관계 정보
+ */
+export type StudentFamily = {
+  members: Array<StudentFamilyMember>;
+};
+
+/**
+ * Generated factory for {@link StudentFamily} record objects.
+ */
+export const StudentFamily = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<StudentFamily, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentFamily}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentFamily}, 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<StudentFamily>,
+  });
+})();
+
+const FfiConverterTypeStudentFamily = (() => {
+  type TypeName = StudentFamily;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        members: FfiConverterArrayTypeStudentFamilyMember.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeStudentFamilyMember.write(value.members, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayTypeStudentFamilyMember.allocationSize(
+        value.members
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 가족 구성원
+ */
+export type StudentFamilyMember = {
+  relationType: string | undefined;
+  telNumber: string | undefined;
+  name: string | undefined;
+  mobileNumber: string | undefined;
+  office: string | undefined;
+  job: string | undefined;
+  position: string | undefined;
+  isGuardian: boolean;
+  isCohabit: boolean;
+};
+
+/**
+ * Generated factory for {@link StudentFamilyMember} record objects.
+ */
+export const StudentFamilyMember = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<StudentFamilyMember, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentFamilyMember}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentFamilyMember}, 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<StudentFamilyMember>,
+  });
+})();
+
+const FfiConverterTypeStudentFamilyMember = (() => {
+  type TypeName = StudentFamilyMember;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        relationType: FfiConverterOptionalString.read(from),
+        telNumber: FfiConverterOptionalString.read(from),
+        name: FfiConverterOptionalString.read(from),
+        mobileNumber: FfiConverterOptionalString.read(from),
+        office: FfiConverterOptionalString.read(from),
+        job: FfiConverterOptionalString.read(from),
+        position: FfiConverterOptionalString.read(from),
+        isGuardian: FfiConverterBool.read(from),
+        isCohabit: FfiConverterBool.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.relationType, into);
+      FfiConverterOptionalString.write(value.telNumber, into);
+      FfiConverterOptionalString.write(value.name, into);
+      FfiConverterOptionalString.write(value.mobileNumber, into);
+      FfiConverterOptionalString.write(value.office, into);
+      FfiConverterOptionalString.write(value.job, into);
+      FfiConverterOptionalString.write(value.position, into);
+      FfiConverterBool.write(value.isGuardian, into);
+      FfiConverterBool.write(value.isCohabit, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.relationType) +
+        FfiConverterOptionalString.allocationSize(value.telNumber) +
+        FfiConverterOptionalString.allocationSize(value.name) +
+        FfiConverterOptionalString.allocationSize(value.mobileNumber) +
+        FfiConverterOptionalString.allocationSize(value.office) +
+        FfiConverterOptionalString.allocationSize(value.job) +
+        FfiConverterOptionalString.allocationSize(value.position) +
+        FfiConverterBool.allocationSize(value.isGuardian) +
+        FfiConverterBool.allocationSize(value.isCohabit)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 7+1 프로그램 정보를 반환합니다.
+ */
+export type StudentForignStudyInformation = {
+  approvalDate: string | undefined;
+  authenticationNumber: string | undefined;
+  issueDate: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentForignStudyInformation} record objects.
+ */
+export const StudentForignStudyInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentForignStudyInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentForignStudyInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentForignStudyInformation}, 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<StudentForignStudyInformation>,
+  });
+})();
+
+const FfiConverterTypeStudentForignStudyInformation = (() => {
+  type TypeName = StudentForignStudyInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        approvalDate: FfiConverterOptionalString.read(from),
+        authenticationNumber: FfiConverterOptionalString.read(from),
+        issueDate: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.approvalDate, into);
+      FfiConverterOptionalString.write(value.authenticationNumber, into);
+      FfiConverterOptionalString.write(value.issueDate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.approvalDate) +
+        FfiConverterOptionalString.allocationSize(value.authenticationNumber) +
+        FfiConverterOptionalString.allocationSize(value.issueDate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 졸업 정보를 반환합니다. 졸업하지 않았다면 반환되지 않습니다.
+ */
+export type StudentGraduation = {
+  graduationCardinal: /*u32*/ number;
+  graduationCertificationNumber: /*u32*/ number;
+  graduationYear: /*u32*/ number;
+  graduationTerms: /*u32*/ number;
+  graduationDate: string;
+  academicDegreeNumber: /*u32*/ number;
+  academicDegreeName: string;
+  earlyGraduation: boolean;
+  graduationRank: /*u32*/ number;
+  graduationPersonnelNumber: /*u32*/ number;
+};
+
+/**
+ * Generated factory for {@link StudentGraduation} record objects.
+ */
+export const StudentGraduation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<StudentGraduation, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentGraduation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentGraduation}, 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<StudentGraduation>,
+  });
+})();
+
+const FfiConverterTypeStudentGraduation = (() => {
+  type TypeName = StudentGraduation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        graduationCardinal: FfiConverterUInt32.read(from),
+        graduationCertificationNumber: FfiConverterUInt32.read(from),
+        graduationYear: FfiConverterUInt32.read(from),
+        graduationTerms: FfiConverterUInt32.read(from),
+        graduationDate: FfiConverterString.read(from),
+        academicDegreeNumber: FfiConverterUInt32.read(from),
+        academicDegreeName: FfiConverterString.read(from),
+        earlyGraduation: FfiConverterBool.read(from),
+        graduationRank: FfiConverterUInt32.read(from),
+        graduationPersonnelNumber: FfiConverterUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.graduationCardinal, into);
+      FfiConverterUInt32.write(value.graduationCertificationNumber, into);
+      FfiConverterUInt32.write(value.graduationYear, into);
+      FfiConverterUInt32.write(value.graduationTerms, into);
+      FfiConverterString.write(value.graduationDate, into);
+      FfiConverterUInt32.write(value.academicDegreeNumber, into);
+      FfiConverterString.write(value.academicDegreeName, into);
+      FfiConverterBool.write(value.earlyGraduation, into);
+      FfiConverterUInt32.write(value.graduationRank, into);
+      FfiConverterUInt32.write(value.graduationPersonnelNumber, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.graduationCardinal) +
+        FfiConverterUInt32.allocationSize(value.graduationCertificationNumber) +
+        FfiConverterUInt32.allocationSize(value.graduationYear) +
+        FfiConverterUInt32.allocationSize(value.graduationTerms) +
+        FfiConverterString.allocationSize(value.graduationDate) +
+        FfiConverterUInt32.allocationSize(value.academicDegreeNumber) +
+        FfiConverterString.allocationSize(value.academicDegreeName) +
+        FfiConverterBool.allocationSize(value.earlyGraduation) +
+        FfiConverterUInt32.allocationSize(value.graduationRank) +
+        FfiConverterUInt32.allocationSize(value.graduationPersonnelNumber)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 기본 학생 정보
+ */
+export type StudentInformation = {
+  applyYear: /*u32*/ number;
+  studentNumber: /*u32*/ number;
+  name: string;
+  rrn: /*u32*/ number;
+  collage: string;
+  department: string;
+  major: string | undefined;
+  division: string | undefined;
+  grade: /*u32*/ number;
+  term: /*u32*/ number;
+  image: ArrayBuffer;
+  alias: string | undefined;
+  kanjiName: string | undefined;
+  email: string | undefined;
+  telNumber: string | undefined;
+  mobileNumber: string | undefined;
+  postCode: string | undefined;
+  address: string | undefined;
+  specificAddress: string | undefined;
+  isTransferStudent: boolean;
+  applyDate: string;
+  appliedCollage: string;
+  appliedDepartment: string;
+  pluralMajor: string | undefined;
+  subMajor: string | undefined;
+  connectedMajor: string | undefined;
+  abeek: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentInformation} record objects.
+ */
+export const StudentInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<StudentInformation, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentInformation}, 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<StudentInformation>,
+  });
+})();
+
+const FfiConverterTypeStudentInformation = (() => {
+  type TypeName = StudentInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        applyYear: FfiConverterUInt32.read(from),
+        studentNumber: FfiConverterUInt32.read(from),
+        name: FfiConverterString.read(from),
+        rrn: FfiConverterUInt32.read(from),
+        collage: FfiConverterString.read(from),
+        department: FfiConverterString.read(from),
+        major: FfiConverterOptionalString.read(from),
+        division: FfiConverterOptionalString.read(from),
+        grade: FfiConverterUInt32.read(from),
+        term: FfiConverterUInt32.read(from),
+        image: FfiConverterArrayBuffer.read(from),
+        alias: FfiConverterOptionalString.read(from),
+        kanjiName: FfiConverterOptionalString.read(from),
+        email: FfiConverterOptionalString.read(from),
+        telNumber: FfiConverterOptionalString.read(from),
+        mobileNumber: FfiConverterOptionalString.read(from),
+        postCode: FfiConverterOptionalString.read(from),
+        address: FfiConverterOptionalString.read(from),
+        specificAddress: FfiConverterOptionalString.read(from),
+        isTransferStudent: FfiConverterBool.read(from),
+        applyDate: FfiConverterString.read(from),
+        appliedCollage: FfiConverterString.read(from),
+        appliedDepartment: FfiConverterString.read(from),
+        pluralMajor: FfiConverterOptionalString.read(from),
+        subMajor: FfiConverterOptionalString.read(from),
+        connectedMajor: FfiConverterOptionalString.read(from),
+        abeek: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.applyYear, into);
+      FfiConverterUInt32.write(value.studentNumber, into);
+      FfiConverterString.write(value.name, into);
+      FfiConverterUInt32.write(value.rrn, into);
+      FfiConverterString.write(value.collage, into);
+      FfiConverterString.write(value.department, into);
+      FfiConverterOptionalString.write(value.major, into);
+      FfiConverterOptionalString.write(value.division, into);
+      FfiConverterUInt32.write(value.grade, into);
+      FfiConverterUInt32.write(value.term, into);
+      FfiConverterArrayBuffer.write(value.image, into);
+      FfiConverterOptionalString.write(value.alias, into);
+      FfiConverterOptionalString.write(value.kanjiName, into);
+      FfiConverterOptionalString.write(value.email, into);
+      FfiConverterOptionalString.write(value.telNumber, into);
+      FfiConverterOptionalString.write(value.mobileNumber, into);
+      FfiConverterOptionalString.write(value.postCode, into);
+      FfiConverterOptionalString.write(value.address, into);
+      FfiConverterOptionalString.write(value.specificAddress, into);
+      FfiConverterBool.write(value.isTransferStudent, into);
+      FfiConverterString.write(value.applyDate, into);
+      FfiConverterString.write(value.appliedCollage, into);
+      FfiConverterString.write(value.appliedDepartment, into);
+      FfiConverterOptionalString.write(value.pluralMajor, into);
+      FfiConverterOptionalString.write(value.subMajor, into);
+      FfiConverterOptionalString.write(value.connectedMajor, into);
+      FfiConverterOptionalString.write(value.abeek, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.applyYear) +
+        FfiConverterUInt32.allocationSize(value.studentNumber) +
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterUInt32.allocationSize(value.rrn) +
+        FfiConverterString.allocationSize(value.collage) +
+        FfiConverterString.allocationSize(value.department) +
+        FfiConverterOptionalString.allocationSize(value.major) +
+        FfiConverterOptionalString.allocationSize(value.division) +
+        FfiConverterUInt32.allocationSize(value.grade) +
+        FfiConverterUInt32.allocationSize(value.term) +
+        FfiConverterArrayBuffer.allocationSize(value.image) +
+        FfiConverterOptionalString.allocationSize(value.alias) +
+        FfiConverterOptionalString.allocationSize(value.kanjiName) +
+        FfiConverterOptionalString.allocationSize(value.email) +
+        FfiConverterOptionalString.allocationSize(value.telNumber) +
+        FfiConverterOptionalString.allocationSize(value.mobileNumber) +
+        FfiConverterOptionalString.allocationSize(value.postCode) +
+        FfiConverterOptionalString.allocationSize(value.address) +
+        FfiConverterOptionalString.allocationSize(value.specificAddress) +
+        FfiConverterBool.allocationSize(value.isTransferStudent) +
+        FfiConverterString.allocationSize(value.applyDate) +
+        FfiConverterString.allocationSize(value.appliedCollage) +
+        FfiConverterString.allocationSize(value.appliedDepartment) +
+        FfiConverterOptionalString.allocationSize(value.pluralMajor) +
+        FfiConverterOptionalString.allocationSize(value.subMajor) +
+        FfiConverterOptionalString.allocationSize(value.connectedMajor) +
+        FfiConverterOptionalString.allocationSize(value.abeek)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 평생교육사 정보
+ */
+export type StudentLifelongInformation = {
+  applyDate: string | undefined;
+  lifelongType: string | undefined;
+  qualificationNumber: string | undefined;
+  qualificationDate: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentLifelongInformation} record objects.
+ */
+export const StudentLifelongInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentLifelongInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentLifelongInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentLifelongInformation}, 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<StudentLifelongInformation>,
+  });
+})();
+
+const FfiConverterTypeStudentLifelongInformation = (() => {
+  type TypeName = StudentLifelongInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        applyDate: FfiConverterOptionalString.read(from),
+        lifelongType: FfiConverterOptionalString.read(from),
+        qualificationNumber: FfiConverterOptionalString.read(from),
+        qualificationDate: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.applyDate, into);
+      FfiConverterOptionalString.write(value.lifelongType, into);
+      FfiConverterOptionalString.write(value.qualificationNumber, into);
+      FfiConverterOptionalString.write(value.qualificationDate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.applyDate) +
+        FfiConverterOptionalString.allocationSize(value.lifelongType) +
+        FfiConverterOptionalString.allocationSize(value.qualificationNumber) +
+        FfiConverterOptionalString.allocationSize(value.qualificationDate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 자격(교직이수, 평생교육사, 7+1 프로그램) 정보
+ */
+export type StudentQualification = {
+  teachingMajor: StudentTeachingMajorInformation | undefined;
+  teachingPluralMajor: StudentTeachingPluralMajorInformation | undefined;
+  lifelong: StudentLifelongInformation | undefined;
+  forignStudy: StudentForignStudyInformation | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentQualification} record objects.
+ */
+export const StudentQualification = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentQualification,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentQualification}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentQualification}, 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<StudentQualification>,
+  });
+})();
+
+const FfiConverterTypeStudentQualification = (() => {
+  type TypeName = StudentQualification;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        teachingMajor:
+          FfiConverterOptionalTypeStudentTeachingMajorInformation.read(from),
+        teachingPluralMajor:
+          FfiConverterOptionalTypeStudentTeachingPluralMajorInformation.read(
+            from
+          ),
+        lifelong: FfiConverterOptionalTypeStudentLifelongInformation.read(from),
+        forignStudy:
+          FfiConverterOptionalTypeStudentForignStudyInformation.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalTypeStudentTeachingMajorInformation.write(
+        value.teachingMajor,
+        into
+      );
+      FfiConverterOptionalTypeStudentTeachingPluralMajorInformation.write(
+        value.teachingPluralMajor,
+        into
+      );
+      FfiConverterOptionalTypeStudentLifelongInformation.write(
+        value.lifelong,
+        into
+      );
+      FfiConverterOptionalTypeStudentForignStudyInformation.write(
+        value.forignStudy,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalTypeStudentTeachingMajorInformation.allocationSize(
+          value.teachingMajor
+        ) +
+        FfiConverterOptionalTypeStudentTeachingPluralMajorInformation.allocationSize(
+          value.teachingPluralMajor
+        ) +
+        FfiConverterOptionalTypeStudentLifelongInformation.allocationSize(
+          value.lifelong
+        ) +
+        FfiConverterOptionalTypeStudentForignStudyInformation.allocationSize(
+          value.forignStudy
+        )
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 종교 정보
+ */
+export type StudentReligion = {
+  religionType: string | undefined;
+  startDate: string | undefined;
+  church: string | undefined;
+  churchMan: string | undefined;
+  baptismLevel: string | undefined;
+  baptismGrp: string | undefined;
+  serviceDepartment: string | undefined;
+  serviceDepartmentTitle: string | undefined;
+  churchAddress: string | undefined;
+  singeub: string | undefined;
+  baptismDate: string | undefined;
+  baptismChurch: string | undefined;
+  baptismMan: string | undefined;
+  churchGrp: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentReligion} record objects.
+ */
+export const StudentReligion = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<StudentReligion, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentReligion}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentReligion}, 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<StudentReligion>,
+  });
+})();
+
+const FfiConverterTypeStudentReligion = (() => {
+  type TypeName = StudentReligion;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        religionType: FfiConverterOptionalString.read(from),
+        startDate: FfiConverterOptionalString.read(from),
+        church: FfiConverterOptionalString.read(from),
+        churchMan: FfiConverterOptionalString.read(from),
+        baptismLevel: FfiConverterOptionalString.read(from),
+        baptismGrp: FfiConverterOptionalString.read(from),
+        serviceDepartment: FfiConverterOptionalString.read(from),
+        serviceDepartmentTitle: FfiConverterOptionalString.read(from),
+        churchAddress: FfiConverterOptionalString.read(from),
+        singeub: FfiConverterOptionalString.read(from),
+        baptismDate: FfiConverterOptionalString.read(from),
+        baptismChurch: FfiConverterOptionalString.read(from),
+        baptismMan: FfiConverterOptionalString.read(from),
+        churchGrp: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.religionType, into);
+      FfiConverterOptionalString.write(value.startDate, into);
+      FfiConverterOptionalString.write(value.church, into);
+      FfiConverterOptionalString.write(value.churchMan, into);
+      FfiConverterOptionalString.write(value.baptismLevel, into);
+      FfiConverterOptionalString.write(value.baptismGrp, into);
+      FfiConverterOptionalString.write(value.serviceDepartment, into);
+      FfiConverterOptionalString.write(value.serviceDepartmentTitle, into);
+      FfiConverterOptionalString.write(value.churchAddress, into);
+      FfiConverterOptionalString.write(value.singeub, into);
+      FfiConverterOptionalString.write(value.baptismDate, into);
+      FfiConverterOptionalString.write(value.baptismChurch, into);
+      FfiConverterOptionalString.write(value.baptismMan, into);
+      FfiConverterOptionalString.write(value.churchGrp, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.religionType) +
+        FfiConverterOptionalString.allocationSize(value.startDate) +
+        FfiConverterOptionalString.allocationSize(value.church) +
+        FfiConverterOptionalString.allocationSize(value.churchMan) +
+        FfiConverterOptionalString.allocationSize(value.baptismLevel) +
+        FfiConverterOptionalString.allocationSize(value.baptismGrp) +
+        FfiConverterOptionalString.allocationSize(value.serviceDepartment) +
+        FfiConverterOptionalString.allocationSize(
+          value.serviceDepartmentTitle
+        ) +
+        FfiConverterOptionalString.allocationSize(value.churchAddress) +
+        FfiConverterOptionalString.allocationSize(value.singeub) +
+        FfiConverterOptionalString.allocationSize(value.baptismDate) +
+        FfiConverterOptionalString.allocationSize(value.baptismChurch) +
+        FfiConverterOptionalString.allocationSize(value.baptismMan) +
+        FfiConverterOptionalString.allocationSize(value.churchGrp)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 연구비 입금 계좌 정보
+ */
+export type StudentResearchBankAccount = {
+  bank: string | undefined;
+  accountNumber: string | undefined;
+  holder: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentResearchBankAccount} record objects.
+ */
+export const StudentResearchBankAccount = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentResearchBankAccount,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentResearchBankAccount}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentResearchBankAccount}, 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<StudentResearchBankAccount>,
+  });
+})();
+
+const FfiConverterTypeStudentResearchBankAccount = (() => {
+  type TypeName = StudentResearchBankAccount;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        bank: FfiConverterOptionalString.read(from),
+        accountNumber: FfiConverterOptionalString.read(from),
+        holder: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.bank, into);
+      FfiConverterOptionalString.write(value.accountNumber, into);
+      FfiConverterOptionalString.write(value.holder, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.bank) +
+        FfiConverterOptionalString.allocationSize(value.accountNumber) +
+        FfiConverterOptionalString.allocationSize(value.holder)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 교직이수(주전공) 정보
+ */
+export type StudentTeachingMajorInformation = {
+  majorName: string | undefined;
+  qualificationNumber: string | undefined;
+  initiationDate: string | undefined;
+  qualificationDate: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentTeachingMajorInformation} record objects.
+ */
+export const StudentTeachingMajorInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentTeachingMajorInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentTeachingMajorInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentTeachingMajorInformation}, 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<StudentTeachingMajorInformation>,
+  });
+})();
+
+const FfiConverterTypeStudentTeachingMajorInformation = (() => {
+  type TypeName = StudentTeachingMajorInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        majorName: FfiConverterOptionalString.read(from),
+        qualificationNumber: FfiConverterOptionalString.read(from),
+        initiationDate: FfiConverterOptionalString.read(from),
+        qualificationDate: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.majorName, into);
+      FfiConverterOptionalString.write(value.qualificationNumber, into);
+      FfiConverterOptionalString.write(value.initiationDate, into);
+      FfiConverterOptionalString.write(value.qualificationDate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.majorName) +
+        FfiConverterOptionalString.allocationSize(value.qualificationNumber) +
+        FfiConverterOptionalString.allocationSize(value.initiationDate) +
+        FfiConverterOptionalString.allocationSize(value.qualificationDate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 교직이수(복수전공) 정보
+ */
+export type StudentTeachingPluralMajorInformation = {
+  majorName: string | undefined;
+  qualificationNumber: string | undefined;
+  qualificationDate: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentTeachingPluralMajorInformation} record objects.
+ */
+export const StudentTeachingPluralMajorInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentTeachingPluralMajorInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentTeachingPluralMajorInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentTeachingPluralMajorInformation}, 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<StudentTeachingPluralMajorInformation>,
+  });
+})();
+
+const FfiConverterTypeStudentTeachingPluralMajorInformation = (() => {
+  type TypeName = StudentTeachingPluralMajorInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        majorName: FfiConverterOptionalString.read(from),
+        qualificationNumber: FfiConverterOptionalString.read(from),
+        qualificationDate: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.majorName, into);
+      FfiConverterOptionalString.write(value.qualificationNumber, into);
+      FfiConverterOptionalString.write(value.qualificationDate, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.majorName) +
+        FfiConverterOptionalString.allocationSize(value.qualificationNumber) +
+        FfiConverterOptionalString.allocationSize(value.qualificationDate)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 편입정보 내 기록
+ */
+export type StudentTransferRecord = {
+  isTransfer: string;
+  admissionDate: string;
+  admissionGrade: string;
+  admissionTerm: string;
+  acceptedCredit: string;
+  acceptedTerms: string;
+};
+
+/**
+ * Generated factory for {@link StudentTransferRecord} record objects.
+ */
+export const StudentTransferRecord = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentTransferRecord,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentTransferRecord}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentTransferRecord}, 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<StudentTransferRecord>,
+  });
+})();
+
+const FfiConverterTypeStudentTransferRecord = (() => {
+  type TypeName = StudentTransferRecord;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        isTransfer: FfiConverterString.read(from),
+        admissionDate: FfiConverterString.read(from),
+        admissionGrade: FfiConverterString.read(from),
+        admissionTerm: FfiConverterString.read(from),
+        acceptedCredit: FfiConverterString.read(from),
+        acceptedTerms: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.isTransfer, into);
+      FfiConverterString.write(value.admissionDate, into);
+      FfiConverterString.write(value.admissionGrade, into);
+      FfiConverterString.write(value.admissionTerm, into);
+      FfiConverterString.write(value.acceptedCredit, into);
+      FfiConverterString.write(value.acceptedTerms, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.isTransfer) +
+        FfiConverterString.allocationSize(value.admissionDate) +
+        FfiConverterString.allocationSize(value.admissionGrade) +
+        FfiConverterString.allocationSize(value.admissionTerm) +
+        FfiConverterString.allocationSize(value.acceptedCredit) +
+        FfiConverterString.allocationSize(value.acceptedTerms)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생 편입 정보
+ */
+export type StudentTransferRecords = {
+  records: Array<StudentTransferRecord>;
+};
+
+/**
+ * Generated factory for {@link StudentTransferRecords} record objects.
+ */
+export const StudentTransferRecords = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentTransferRecords,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentTransferRecords}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentTransferRecords}, 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<StudentTransferRecords>,
+  });
+})();
+
+const FfiConverterTypeStudentTransferRecords = (() => {
+  type TypeName = StudentTransferRecords;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        records: FfiConverterArrayTypeStudentTransferRecord.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeStudentTransferRecord.write(value.records, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayTypeStudentTransferRecord.allocationSize(
+        value.records
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학생의 직업 정보
+ */
+export type StudentWorkInformation = {
+  job: string | undefined;
+  publicOfficial: string | undefined;
+  companyName: string | undefined;
+  departmentName: string | undefined;
+  title: string | undefined;
+  zipCode: string | undefined;
+  address: string | undefined;
+  specificAddress: string | undefined;
+  telNumber: string | undefined;
+  faxNumber: string | undefined;
+};
+
+/**
+ * Generated factory for {@link StudentWorkInformation} record objects.
+ */
+export const StudentWorkInformation = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      StudentWorkInformation,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link StudentWorkInformation}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link StudentWorkInformation}, 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<StudentWorkInformation>,
+  });
+})();
+
+const FfiConverterTypeStudentWorkInformation = (() => {
+  type TypeName = StudentWorkInformation;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        job: FfiConverterOptionalString.read(from),
+        publicOfficial: FfiConverterOptionalString.read(from),
+        companyName: FfiConverterOptionalString.read(from),
+        departmentName: FfiConverterOptionalString.read(from),
+        title: FfiConverterOptionalString.read(from),
+        zipCode: FfiConverterOptionalString.read(from),
+        address: FfiConverterOptionalString.read(from),
+        specificAddress: FfiConverterOptionalString.read(from),
+        telNumber: FfiConverterOptionalString.read(from),
+        faxNumber: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.job, into);
+      FfiConverterOptionalString.write(value.publicOfficial, into);
+      FfiConverterOptionalString.write(value.companyName, into);
+      FfiConverterOptionalString.write(value.departmentName, into);
+      FfiConverterOptionalString.write(value.title, into);
+      FfiConverterOptionalString.write(value.zipCode, into);
+      FfiConverterOptionalString.write(value.address, into);
+      FfiConverterOptionalString.write(value.specificAddress, into);
+      FfiConverterOptionalString.write(value.telNumber, into);
+      FfiConverterOptionalString.write(value.faxNumber, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.job) +
+        FfiConverterOptionalString.allocationSize(value.publicOfficial) +
+        FfiConverterOptionalString.allocationSize(value.companyName) +
+        FfiConverterOptionalString.allocationSize(value.departmentName) +
+        FfiConverterOptionalString.allocationSize(value.title) +
+        FfiConverterOptionalString.allocationSize(value.zipCode) +
+        FfiConverterOptionalString.allocationSize(value.address) +
+        FfiConverterOptionalString.allocationSize(value.specificAddress) +
+        FfiConverterOptionalString.allocationSize(value.telNumber) +
+        FfiConverterOptionalString.allocationSize(value.faxNumber)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * uniffi 지원을 위한 u32 Pair입니다.
+ */
+export type UnsignedIntPair = {
+  first: /*u32*/ number;
+  second: /*u32*/ number;
+};
+
+/**
+ * Generated factory for {@link UnsignedIntPair} record objects.
+ */
+export const UnsignedIntPair = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<UnsignedIntPair, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link UnsignedIntPair}, with defaults specified
+     * in Rust, in the {@link rusaint} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link UnsignedIntPair}, 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<UnsignedIntPair>,
+  });
+})();
+
+const FfiConverterTypeUnsignedIntPair = (() => {
+  type TypeName = UnsignedIntPair;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        first: FfiConverterUInt32.read(from),
+        second: FfiConverterUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.first, into);
+      FfiConverterUInt32.write(value.second, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.first) +
+        FfiConverterUInt32.allocationSize(value.second)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+const stringConverter = {
+  stringToBytes: (s: string) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(
+        s,
+        status
+      )
+    ),
+  bytesToString: (ab: UniffiByteArray) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(
+        ab,
+        status
+      )
+    ),
+  stringByteLength: (s: string) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(
+        s,
+        status
+      )
+    ),
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+/**
+ * Typealias from the type name used in the UDL file to the builtin type.  This
+ * is needed because the UDL type name is used in function/method signatures.
+ */
+export type U32Pair = UnsignedIntPair;
+// FfiConverter for U32Pair, a type alias for UnsignedIntPair.
+const FfiConverterTypeU32Pair = FfiConverterTypeUnsignedIntPair;
+
+// Enum: ClassScore
+export enum ClassScore_Tags {
+  Pass = 'Pass',
+  Failed = 'Failed',
+  Score = 'Score',
+  Empty = 'Empty',
+}
+/**
+ * 과목 점수
+ */
+export const ClassScore = (() => {
+  type Pass__interface = {
+    tag: ClassScore_Tags.Pass;
+  };
+
+  /**
+   * P/F 과목의 Pass
+   */
+  class Pass_ extends UniffiEnum implements Pass__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ClassScore';
+    readonly tag = ClassScore_Tags.Pass;
+    constructor() {
+      super('ClassScore', 'Pass');
+    }
+
+    static new(): Pass_ {
+      return new Pass_();
+    }
+
+    static instanceOf(obj: any): obj is Pass_ {
+      return obj.tag === ClassScore_Tags.Pass;
+    }
+  }
+
+  type Failed__interface = {
+    tag: ClassScore_Tags.Failed;
+  };
+
+  /**
+   * P/F 과목의 Failed
+   */
+  class Failed_ extends UniffiEnum implements Failed__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ClassScore';
+    readonly tag = ClassScore_Tags.Failed;
+    constructor() {
+      super('ClassScore', 'Failed');
+    }
+
+    static new(): Failed_ {
+      return new Failed_();
+    }
+
+    static instanceOf(obj: any): obj is Failed_ {
+      return obj.tag === ClassScore_Tags.Failed;
+    }
+  }
+
+  type Score__interface = {
+    tag: ClassScore_Tags.Score;
+    inner: Readonly<[/*u32*/ number]>;
+  };
+
+  /**
+   * 일반 과목의 점수
+   */
+  class Score_ extends UniffiEnum implements Score__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ClassScore';
+    readonly tag = ClassScore_Tags.Score;
+    readonly inner: Readonly<[/*u32*/ number]>;
+    constructor(v0: /*u32*/ number) {
+      super('ClassScore', 'Score');
+      this.inner = Object.freeze([v0]);
+    }
+
+    static new(v0: /*u32*/ number): Score_ {
+      return new Score_(v0);
+    }
+
+    static instanceOf(obj: any): obj is Score_ {
+      return obj.tag === ClassScore_Tags.Score;
+    }
+  }
+
+  type Empty__interface = {
+    tag: ClassScore_Tags.Empty;
+  };
+
+  /**
+   * 성적 없음
+   */
+  class Empty_ extends UniffiEnum implements Empty__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ClassScore';
+    readonly tag = ClassScore_Tags.Empty;
+    constructor() {
+      super('ClassScore', 'Empty');
+    }
+
+    static new(): Empty_ {
+      return new Empty_();
+    }
+
+    static instanceOf(obj: any): obj is Empty_ {
+      return obj.tag === ClassScore_Tags.Empty;
+    }
+  }
+
+  function instanceOf(obj: any): obj is ClassScore {
+    return obj[uniffiTypeNameSymbol] === 'ClassScore';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Pass: Pass_,
+    Failed: Failed_,
+    Score: Score_,
+    Empty: Empty_,
+  });
+})();
+
+/**
+ * 과목 점수
+ */
+
+export type ClassScore = InstanceType<
+  (typeof ClassScore)[keyof Omit<typeof ClassScore, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ClassScore
+const FfiConverterTypeClassScore = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ClassScore;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new ClassScore.Pass();
+        case 2:
+          return new ClassScore.Failed();
+        case 3:
+          return new ClassScore.Score(FfiConverterUInt32.read(from));
+        case 4:
+          return new ClassScore.Empty();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case ClassScore_Tags.Pass: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case ClassScore_Tags.Failed: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        case ClassScore_Tags.Score: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterUInt32.write(inner[0], into);
+          return;
+        }
+        case ClassScore_Tags.Empty: {
+          ordinalConverter.write(4, into);
+          return;
+        }
+        default:
+          // Throwing from here means that ClassScore_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case ClassScore_Tags.Pass: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case ClassScore_Tags.Failed: {
+          return ordinalConverter.allocationSize(2);
+        }
+        case ClassScore_Tags.Score: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterUInt32.allocationSize(inner[0]);
+          return size;
+        }
+        case ClassScore_Tags.Empty: {
+          return ordinalConverter.allocationSize(4);
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학위과정
+ */
+export enum CourseType {
+  /**
+   * 박사과정
+   */
+  Phd,
+  /**
+   * 석사과정
+   */
+  Master,
+  /**
+   * 석박과정
+   */
+  PhdIntergrated,
+  /**
+   * 연구과정
+   */
+  Research,
+  /**
+   * 학사과정
+   */
+  Bachelor,
+}
+
+const FfiConverterTypeCourseType = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = CourseType;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return CourseType.Phd;
+        case 2:
+          return CourseType.Master;
+        case 3:
+          return CourseType.PhdIntergrated;
+        case 4:
+          return CourseType.Research;
+        case 5:
+          return CourseType.Bachelor;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case CourseType.Phd:
+          return ordinalConverter.write(1, into);
+        case CourseType.Master:
+          return ordinalConverter.write(2, into);
+        case CourseType.PhdIntergrated:
+          return ordinalConverter.write(3, into);
+        case CourseType.Research:
+          return ordinalConverter.write(4, into);
+        case CourseType.Bachelor:
+          return ordinalConverter.write(5, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: LectureCategory
+export enum LectureCategory_Tags {
+  Major = 'Major',
+  RequiredElective = 'RequiredElective',
+  OptionalElective = 'OptionalElective',
+  Chapel = 'Chapel',
+  Education = 'Education',
+  Graduated = 'Graduated',
+  ConnectedMajor = 'ConnectedMajor',
+  UnitedMajor = 'UnitedMajor',
+  FindByProfessor = 'FindByProfessor',
+  FindByLecture = 'FindByLecture',
+  RecognizedOtherMajor = 'RecognizedOtherMajor',
+  Cyber = 'Cyber',
+}
+/**
+ * 강의를 찾을 때 사용하는 강의 카테고리
+ */
+export const LectureCategory = (() => {
+  type Major__interface = {
+    tag: LectureCategory_Tags.Major;
+    inner: Readonly<{
+      collage: string;
+      department: string;
+      major: string | undefined;
+    }>;
+  };
+
+  /**
+   * 전공 강의
+   */
+  class Major_ extends UniffiEnum implements Major__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.Major;
+    readonly inner: Readonly<{
+      collage: string;
+      department: string;
+      major: string | undefined;
+    }>;
+    constructor(inner: {
+      /**
+       * 단과대명
+       */ collage: string;
+      /**
+       * 학부명
+       */ department: string;
+      /**
+       * 전공명
+       */ major: string | undefined;
+    }) {
+      super('LectureCategory', 'Major');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 단과대명
+       */ collage: string;
+      /**
+       * 학부명
+       */ department: string;
+      /**
+       * 전공명
+       */ major: string | undefined;
+    }): Major_ {
+      return new Major_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Major_ {
+      return obj.tag === LectureCategory_Tags.Major;
+    }
+  }
+
+  type RequiredElective__interface = {
+    tag: LectureCategory_Tags.RequiredElective;
+    inner: Readonly<{ lectureName: string }>;
+  };
+
+  /**
+   * 교양필수
+   */
+  class RequiredElective_
+    extends UniffiEnum
+    implements RequiredElective__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.RequiredElective;
+    readonly inner: Readonly<{ lectureName: string }>;
+    constructor(inner: {
+      /**
+       * 과목명
+       */ lectureName: string;
+    }) {
+      super('LectureCategory', 'RequiredElective');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 과목명
+       */ lectureName: string;
+    }): RequiredElective_ {
+      return new RequiredElective_(inner);
+    }
+
+    static instanceOf(obj: any): obj is RequiredElective_ {
+      return obj.tag === LectureCategory_Tags.RequiredElective;
+    }
+  }
+
+  type OptionalElective__interface = {
+    tag: LectureCategory_Tags.OptionalElective;
+    inner: Readonly<{ category: string }>;
+  };
+
+  /**
+   * 교양선택
+   */
+  class OptionalElective_
+    extends UniffiEnum
+    implements OptionalElective__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.OptionalElective;
+    readonly inner: Readonly<{ category: string }>;
+    constructor(inner: {
+      /**
+       * 교양 분류
+       */ category: string;
+    }) {
+      super('LectureCategory', 'OptionalElective');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 교양 분류
+       */ category: string;
+    }): OptionalElective_ {
+      return new OptionalElective_(inner);
+    }
+
+    static instanceOf(obj: any): obj is OptionalElective_ {
+      return obj.tag === LectureCategory_Tags.OptionalElective;
+    }
+  }
+
+  type Chapel__interface = {
+    tag: LectureCategory_Tags.Chapel;
+    inner: Readonly<{ lectureName: string }>;
+  };
+
+  /**
+   * 채플
+   */
+  class Chapel_ extends UniffiEnum implements Chapel__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.Chapel;
+    readonly inner: Readonly<{ lectureName: string }>;
+    constructor(inner: {
+      /**
+       * 과목명
+       */ lectureName: string;
+    }) {
+      super('LectureCategory', 'Chapel');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 과목명
+       */ lectureName: string;
+    }): Chapel_ {
+      return new Chapel_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Chapel_ {
+      return obj.tag === LectureCategory_Tags.Chapel;
+    }
+  }
+
+  type Education__interface = {
+    tag: LectureCategory_Tags.Education;
+  };
+
+  /**
+   * 교직
+   */
+  class Education_ extends UniffiEnum implements Education__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.Education;
+    constructor() {
+      super('LectureCategory', 'Education');
+    }
+
+    static new(): Education_ {
+      return new Education_();
+    }
+
+    static instanceOf(obj: any): obj is Education_ {
+      return obj.tag === LectureCategory_Tags.Education;
+    }
+  }
+
+  type Graduated__interface = {
+    tag: LectureCategory_Tags.Graduated;
+    inner: Readonly<{ collage: string; department: string }>;
+  };
+
+  /**
+   * 대학원
+   */
+  class Graduated_ extends UniffiEnum implements Graduated__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.Graduated;
+    readonly inner: Readonly<{ collage: string; department: string }>;
+    constructor(inner: {
+      /**
+       * 단과대명
+       */ collage: string;
+      /**
+       * 학부명
+       */ department: string;
+    }) {
+      super('LectureCategory', 'Graduated');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 단과대명
+       */ collage: string;
+      /**
+       * 학부명
+       */ department: string;
+    }): Graduated_ {
+      return new Graduated_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Graduated_ {
+      return obj.tag === LectureCategory_Tags.Graduated;
+    }
+  }
+
+  type ConnectedMajor__interface = {
+    tag: LectureCategory_Tags.ConnectedMajor;
+    inner: Readonly<{ major: string }>;
+  };
+
+  /**
+   * 연계전공
+   */
+  class ConnectedMajor_
+    extends UniffiEnum
+    implements ConnectedMajor__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.ConnectedMajor;
+    readonly inner: Readonly<{ major: string }>;
+    constructor(inner: {
+      /**
+       * 전공명
+       */ major: string;
+    }) {
+      super('LectureCategory', 'ConnectedMajor');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 전공명
+       */ major: string;
+    }): ConnectedMajor_ {
+      return new ConnectedMajor_(inner);
+    }
+
+    static instanceOf(obj: any): obj is ConnectedMajor_ {
+      return obj.tag === LectureCategory_Tags.ConnectedMajor;
+    }
+  }
+
+  type UnitedMajor__interface = {
+    tag: LectureCategory_Tags.UnitedMajor;
+    inner: Readonly<{ major: string }>;
+  };
+
+  /**
+   * 융합전공
+   */
+  class UnitedMajor_ extends UniffiEnum implements UnitedMajor__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.UnitedMajor;
+    readonly inner: Readonly<{ major: string }>;
+    constructor(inner: {
+      /**
+       * 전공명
+       */ major: string;
+    }) {
+      super('LectureCategory', 'UnitedMajor');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 전공명
+       */ major: string;
+    }): UnitedMajor_ {
+      return new UnitedMajor_(inner);
+    }
+
+    static instanceOf(obj: any): obj is UnitedMajor_ {
+      return obj.tag === LectureCategory_Tags.UnitedMajor;
+    }
+  }
+
+  type FindByProfessor__interface = {
+    tag: LectureCategory_Tags.FindByProfessor;
+    inner: Readonly<{ keyword: string }>;
+  };
+
+  /**
+   * 교수명 검색
+   */
+  class FindByProfessor_
+    extends UniffiEnum
+    implements FindByProfessor__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.FindByProfessor;
+    readonly inner: Readonly<{ keyword: string }>;
+    constructor(inner: {
+      /**
+       * 교수명
+       */ keyword: string;
+    }) {
+      super('LectureCategory', 'FindByProfessor');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 교수명
+       */ keyword: string;
+    }): FindByProfessor_ {
+      return new FindByProfessor_(inner);
+    }
+
+    static instanceOf(obj: any): obj is FindByProfessor_ {
+      return obj.tag === LectureCategory_Tags.FindByProfessor;
+    }
+  }
+
+  type FindByLecture__interface = {
+    tag: LectureCategory_Tags.FindByLecture;
+    inner: Readonly<{ keyword: string }>;
+  };
+
+  /**
+   * 과목명 검색
+   */
+  class FindByLecture_ extends UniffiEnum implements FindByLecture__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.FindByLecture;
+    readonly inner: Readonly<{ keyword: string }>;
+    constructor(inner: {
+      /**
+       * 과목명
+       */ keyword: string;
+    }) {
+      super('LectureCategory', 'FindByLecture');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 과목명
+       */ keyword: string;
+    }): FindByLecture_ {
+      return new FindByLecture_(inner);
+    }
+
+    static instanceOf(obj: any): obj is FindByLecture_ {
+      return obj.tag === LectureCategory_Tags.FindByLecture;
+    }
+  }
+
+  type RecognizedOtherMajor__interface = {
+    tag: LectureCategory_Tags.RecognizedOtherMajor;
+    inner: Readonly<{
+      collage: string;
+      department: string;
+      major: string | undefined;
+    }>;
+  };
+
+  /**
+   * 타전공인정과목
+   */
+  class RecognizedOtherMajor_
+    extends UniffiEnum
+    implements RecognizedOtherMajor__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.RecognizedOtherMajor;
+    readonly inner: Readonly<{
+      collage: string;
+      department: string;
+      major: string | undefined;
+    }>;
+    constructor(inner: {
+      /**
+       * 단과대명
+       */ collage: string;
+      /**
+       * 학부명
+       */ department: string;
+      /**
+       * 전공명
+       */ major: string | undefined;
+    }) {
+      super('LectureCategory', 'RecognizedOtherMajor');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * 단과대명
+       */ collage: string;
+      /**
+       * 학부명
+       */ department: string;
+      /**
+       * 전공명
+       */ major: string | undefined;
+    }): RecognizedOtherMajor_ {
+      return new RecognizedOtherMajor_(inner);
+    }
+
+    static instanceOf(obj: any): obj is RecognizedOtherMajor_ {
+      return obj.tag === LectureCategory_Tags.RecognizedOtherMajor;
+    }
+  }
+
+  type Cyber__interface = {
+    tag: LectureCategory_Tags.Cyber;
+  };
+
+  /**
+   * 숭실사이버대
+   */
+  class Cyber_ extends UniffiEnum implements Cyber__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LectureCategory';
+    readonly tag = LectureCategory_Tags.Cyber;
+    constructor() {
+      super('LectureCategory', 'Cyber');
+    }
+
+    static new(): Cyber_ {
+      return new Cyber_();
+    }
+
+    static instanceOf(obj: any): obj is Cyber_ {
+      return obj.tag === LectureCategory_Tags.Cyber;
+    }
+  }
+
+  function instanceOf(obj: any): obj is LectureCategory {
+    return obj[uniffiTypeNameSymbol] === 'LectureCategory';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Major: Major_,
+    RequiredElective: RequiredElective_,
+    OptionalElective: OptionalElective_,
+    Chapel: Chapel_,
+    Education: Education_,
+    Graduated: Graduated_,
+    ConnectedMajor: ConnectedMajor_,
+    UnitedMajor: UnitedMajor_,
+    FindByProfessor: FindByProfessor_,
+    FindByLecture: FindByLecture_,
+    RecognizedOtherMajor: RecognizedOtherMajor_,
+    Cyber: Cyber_,
+  });
+})();
+
+/**
+ * 강의를 찾을 때 사용하는 강의 카테고리
+ */
+
+export type LectureCategory = InstanceType<
+  (typeof LectureCategory)[keyof Omit<typeof LectureCategory, 'instanceOf'>]
+>;
+
+// FfiConverter for enum LectureCategory
+const FfiConverterTypeLectureCategory = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = LectureCategory;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new LectureCategory.Major({
+            collage: FfiConverterString.read(from),
+            department: FfiConverterString.read(from),
+            major: FfiConverterOptionalString.read(from),
+          });
+        case 2:
+          return new LectureCategory.RequiredElective({
+            lectureName: FfiConverterString.read(from),
+          });
+        case 3:
+          return new LectureCategory.OptionalElective({
+            category: FfiConverterString.read(from),
+          });
+        case 4:
+          return new LectureCategory.Chapel({
+            lectureName: FfiConverterString.read(from),
+          });
+        case 5:
+          return new LectureCategory.Education();
+        case 6:
+          return new LectureCategory.Graduated({
+            collage: FfiConverterString.read(from),
+            department: FfiConverterString.read(from),
+          });
+        case 7:
+          return new LectureCategory.ConnectedMajor({
+            major: FfiConverterString.read(from),
+          });
+        case 8:
+          return new LectureCategory.UnitedMajor({
+            major: FfiConverterString.read(from),
+          });
+        case 9:
+          return new LectureCategory.FindByProfessor({
+            keyword: FfiConverterString.read(from),
+          });
+        case 10:
+          return new LectureCategory.FindByLecture({
+            keyword: FfiConverterString.read(from),
+          });
+        case 11:
+          return new LectureCategory.RecognizedOtherMajor({
+            collage: FfiConverterString.read(from),
+            department: FfiConverterString.read(from),
+            major: FfiConverterOptionalString.read(from),
+          });
+        case 12:
+          return new LectureCategory.Cyber();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case LectureCategory_Tags.Major: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.collage, into);
+          FfiConverterString.write(inner.department, into);
+          FfiConverterOptionalString.write(inner.major, into);
+          return;
+        }
+        case LectureCategory_Tags.RequiredElective: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.lectureName, into);
+          return;
+        }
+        case LectureCategory_Tags.OptionalElective: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.category, into);
+          return;
+        }
+        case LectureCategory_Tags.Chapel: {
+          ordinalConverter.write(4, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.lectureName, into);
+          return;
+        }
+        case LectureCategory_Tags.Education: {
+          ordinalConverter.write(5, into);
+          return;
+        }
+        case LectureCategory_Tags.Graduated: {
+          ordinalConverter.write(6, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.collage, into);
+          FfiConverterString.write(inner.department, into);
+          return;
+        }
+        case LectureCategory_Tags.ConnectedMajor: {
+          ordinalConverter.write(7, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.major, into);
+          return;
+        }
+        case LectureCategory_Tags.UnitedMajor: {
+          ordinalConverter.write(8, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.major, into);
+          return;
+        }
+        case LectureCategory_Tags.FindByProfessor: {
+          ordinalConverter.write(9, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.keyword, into);
+          return;
+        }
+        case LectureCategory_Tags.FindByLecture: {
+          ordinalConverter.write(10, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.keyword, into);
+          return;
+        }
+        case LectureCategory_Tags.RecognizedOtherMajor: {
+          ordinalConverter.write(11, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.collage, into);
+          FfiConverterString.write(inner.department, into);
+          FfiConverterOptionalString.write(inner.major, into);
+          return;
+        }
+        case LectureCategory_Tags.Cyber: {
+          ordinalConverter.write(12, into);
+          return;
+        }
+        default:
+          // Throwing from here means that LectureCategory_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case LectureCategory_Tags.Major: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.collage);
+          size += FfiConverterString.allocationSize(inner.department);
+          size += FfiConverterOptionalString.allocationSize(inner.major);
+          return size;
+        }
+        case LectureCategory_Tags.RequiredElective: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.lectureName);
+          return size;
+        }
+        case LectureCategory_Tags.OptionalElective: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.category);
+          return size;
+        }
+        case LectureCategory_Tags.Chapel: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(4);
+          size += FfiConverterString.allocationSize(inner.lectureName);
+          return size;
+        }
+        case LectureCategory_Tags.Education: {
+          return ordinalConverter.allocationSize(5);
+        }
+        case LectureCategory_Tags.Graduated: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(6);
+          size += FfiConverterString.allocationSize(inner.collage);
+          size += FfiConverterString.allocationSize(inner.department);
+          return size;
+        }
+        case LectureCategory_Tags.ConnectedMajor: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(7);
+          size += FfiConverterString.allocationSize(inner.major);
+          return size;
+        }
+        case LectureCategory_Tags.UnitedMajor: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(8);
+          size += FfiConverterString.allocationSize(inner.major);
+          return size;
+        }
+        case LectureCategory_Tags.FindByProfessor: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(9);
+          size += FfiConverterString.allocationSize(inner.keyword);
+          return size;
+        }
+        case LectureCategory_Tags.FindByLecture: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(10);
+          size += FfiConverterString.allocationSize(inner.keyword);
+          return size;
+        }
+        case LectureCategory_Tags.RecognizedOtherMajor: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(11);
+          size += FfiConverterString.allocationSize(inner.collage);
+          size += FfiConverterString.allocationSize(inner.department);
+          size += FfiConverterOptionalString.allocationSize(inner.major);
+          return size;
+        }
+        case LectureCategory_Tags.Cyber: {
+          return ordinalConverter.allocationSize(12);
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 학기 종류
+ *
+ * 각 애플리케이션에서의 변환은 애플리케이션 내에서 직접 처리하여야 합니다.
+ */
+export enum SemesterType {
+  /**
+   * 1학기
+   */
+  One,
+  /**
+   * 여름학기
+   */
+  Summer,
+  /**
+   * 2학기
+   */
+  Two,
+  /**
+   * 겨울학기
+   */
+  Winter,
+}
+
+const FfiConverterTypeSemesterType = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = SemesterType;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return SemesterType.One;
+        case 2:
+          return SemesterType.Summer;
+        case 3:
+          return SemesterType.Two;
+        case 4:
+          return SemesterType.Winter;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case SemesterType.One:
+          return ordinalConverter.write(1, into);
+        case SemesterType.Summer:
+          return ordinalConverter.write(2, into);
+        case SemesterType.Two:
+          return ordinalConverter.write(3, into);
+        case SemesterType.Winter:
+          return ordinalConverter.write(4, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * 한 주의 요일을 표현합니다.
+ */
+export enum Weekday {
+  /**
+   * 월요일
+   */
+  Mon,
+  /**
+   * 화요일
+   */
+  Tue,
+  /**
+   * 수요일
+   */
+  Wed,
+  /**
+   * 목요일
+   */
+  Thu,
+  /**
+   * 금요일
+   */
+  Fri,
+  /**
+   * 토요일
+   */
+  Sat,
+  /**
+   * 일요일
+   */
+  Sun,
+}
+
+const FfiConverterTypeWeekday = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = Weekday;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return Weekday.Mon;
+        case 2:
+          return Weekday.Tue;
+        case 3:
+          return Weekday.Wed;
+        case 4:
+          return Weekday.Thu;
+        case 5:
+          return Weekday.Fri;
+        case 6:
+          return Weekday.Sat;
+        case 7:
+          return Weekday.Sun;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case Weekday.Mon:
+          return ordinalConverter.write(1, into);
+        case Weekday.Tue:
+          return ordinalConverter.write(2, into);
+        case Weekday.Wed:
+          return ordinalConverter.write(3, into);
+        case Weekday.Thu:
+          return ordinalConverter.write(4, into);
+        case Weekday.Fri:
+          return ordinalConverter.write(5, into);
+        case Weekday.Sat:
+          return ordinalConverter.write(6, into);
+        case Weekday.Sun:
+          return ordinalConverter.write(7, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+// FfiConverter for Map<string, /*f32*/number>
+const FfiConverterMapStringFloat32 = new FfiConverterMap(
+  FfiConverterString,
+  FfiConverterFloat32
+);
+
+// FfiConverter for Map<string, GraduationRequirement>
+const FfiConverterMapStringTypeGraduationRequirement = new FfiConverterMap(
+  FfiConverterString,
+  FfiConverterTypeGraduationRequirement
+);
+
+/**
+ * 새로운 `LectureCategory`를 만드는 빌더입니다.
+ */
+export interface LectureCategoryBuilderInterface {
+  /**
+   * 채플 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  chapel(lectureName: string): LectureCategory;
+  /**
+   * 연계전공 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  connectedMajor(major: string): LectureCategory;
+  /**
+   * 숭실사이버대 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  cyber(): LectureCategory;
+  /**
+   * 교직 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  education(): LectureCategory;
+  /**
+   * 과목명으로 찾기 위한 [`LectureCategory`]를 만듭니다.
+   */
+  findByLecture(keyword: string): LectureCategory;
+  /**
+   * 교수명으로 찾기 위한 [`LectureCategory`]를 만듭니다.
+   */
+  findByProfessor(keyword: string): LectureCategory;
+  /**
+   * 대학원 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  graduated(collage: string, department: string): LectureCategory;
+  /**
+   * 전공과목 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  major(
+    collage: string,
+    department: string,
+    major: string | undefined
+  ): LectureCategory;
+  /**
+   * 교양선택 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  optionalElective(category: string): LectureCategory;
+  /**
+   * 타전공인정과목 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  recognizedOtherMajor(
+    collage: string,
+    department: string,
+    major: string | undefined
+  ): LectureCategory;
+  /**
+   * 교양필수 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  requiredElective(lectureName: string): LectureCategory;
+  /**
+   * 융합전공 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  unitedMajor(major: string): LectureCategory;
+}
+
+/**
+ * 새로운 `LectureCategory`를 만드는 빌더입니다.
+ */
+export class LectureCategoryBuilder
+  extends UniffiAbstractObject
+  implements LectureCategoryBuilderInterface
+{
+  readonly [uniffiTypeNameSymbol] = 'LectureCategoryBuilder';
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  /**
+   * `LectureCategoryBuilder`를 만듭니다.
+   */
+  constructor() {
+    super();
+    const pointer = uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_rusaint_fn_constructor_lecturecategorybuilder_new(
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    );
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeLectureCategoryBuilderObjectFactory.bless(pointer);
+  }
+
+  /**
+   * 채플 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public chapel(lectureName: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_chapel(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(lectureName),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 연계전공 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public connectedMajor(major: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_connected_major(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(major),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 숭실사이버대 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public cyber(): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_cyber(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 교직 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public education(): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_education(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 과목명으로 찾기 위한 [`LectureCategory`]를 만듭니다.
+   */
+  public findByLecture(keyword: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_find_by_lecture(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(keyword),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 교수명으로 찾기 위한 [`LectureCategory`]를 만듭니다.
+   */
+  public findByProfessor(keyword: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_find_by_professor(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(keyword),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 대학원 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public graduated(collage: string, department: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_graduated(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(collage),
+            FfiConverterString.lower(department),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 전공과목 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public major(
+    collage: string,
+    department: string,
+    major: string | undefined
+  ): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_major(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(collage),
+            FfiConverterString.lower(department),
+            FfiConverterOptionalString.lower(major),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 교양선택 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public optionalElective(category: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_optional_elective(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(category),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 타전공인정과목 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public recognizedOtherMajor(
+    collage: string,
+    department: string,
+    major: string | undefined
+  ): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_recognized_other_major(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(collage),
+            FfiConverterString.lower(department),
+            FfiConverterOptionalString.lower(major),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 교양필수 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public requiredElective(lectureName: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_required_elective(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(lectureName),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * 융합전공 분류의 [`LectureCategory`]를 만듭니다.
+   */
+  public unitedMajor(major: string): LectureCategory {
+    return FfiConverterTypeLectureCategory.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_rusaint_fn_method_lecturecategorybuilder_united_major(
+            uniffiTypeLectureCategoryBuilderObjectFactory.clonePointer(this),
+            FfiConverterString.lower(major),
+            callStatus
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift
+      )
+    );
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer =
+        uniffiTypeLectureCategoryBuilderObjectFactory.pointer(this);
+      uniffiTypeLectureCategoryBuilderObjectFactory.freePointer(pointer);
+      uniffiTypeLectureCategoryBuilderObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is LectureCategoryBuilder {
+    return uniffiTypeLectureCategoryBuilderObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeLectureCategoryBuilderObjectFactory: UniffiObjectFactory<LectureCategoryBuilderInterface> =
+  {
+    create(pointer: UnsafeMutableRawPointer): LectureCategoryBuilderInterface {
+      const instance = Object.create(LectureCategoryBuilder.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = 'LectureCategoryBuilder';
+      return instance;
+    },
+
+    bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+      return uniffiCaller.rustCall(
+        /*caller:*/ (status) =>
+          nativeModule().ubrn_uniffi_internal_fn_method_lecturecategorybuilder_ffi__bless_pointer(
+            p,
+            status
+          ),
+        /*liftString:*/ FfiConverterString.lift
+      );
+    },
+
+    unbless(ptr: UniffiRustArcPtr) {
+      ptr.markDestroyed();
+    },
+
+    pointer(obj: LectureCategoryBuilderInterface): UnsafeMutableRawPointer {
+      if ((obj as any)[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(
+      obj: LectureCategoryBuilderInterface
+    ): UnsafeMutableRawPointer {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_rusaint_fn_clone_lecturecategorybuilder(
+            pointer,
+            callStatus
+          ),
+        /*liftString:*/ FfiConverterString.lift
+      );
+    },
+
+    freePointer(pointer: UnsafeMutableRawPointer): void {
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_rusaint_fn_free_lecturecategorybuilder(
+            pointer,
+            callStatus
+          ),
+        /*liftString:*/ FfiConverterString.lift
+      );
+    },
+
+    isConcreteType(obj: any): obj is LectureCategoryBuilderInterface {
+      return (
+        obj[destructorGuardSymbol] &&
+        obj[uniffiTypeNameSymbol] === 'LectureCategoryBuilder'
+      );
+    },
+  };
+// FfiConverter for LectureCategoryBuilderInterface
+const FfiConverterTypeLectureCategoryBuilder = new FfiConverterObject(
+  uniffiTypeLectureCategoryBuilderObjectFactory
+);
+
+// FfiConverter for /*f32*/number | undefined
+const FfiConverterOptionalFloat32 = new FfiConverterOptional(
+  FfiConverterFloat32
+);
+
+// FfiConverter for StudentForignStudyInformation | undefined
+const FfiConverterOptionalTypeStudentForignStudyInformation =
+  new FfiConverterOptional(FfiConverterTypeStudentForignStudyInformation);
+
+// FfiConverter for StudentLifelongInformation | undefined
+const FfiConverterOptionalTypeStudentLifelongInformation =
+  new FfiConverterOptional(FfiConverterTypeStudentLifelongInformation);
+
+// FfiConverter for StudentTeachingMajorInformation | undefined
+const FfiConverterOptionalTypeStudentTeachingMajorInformation =
+  new FfiConverterOptional(FfiConverterTypeStudentTeachingMajorInformation);
+
+// FfiConverter for StudentTeachingPluralMajorInformation | undefined
+const FfiConverterOptionalTypeStudentTeachingPluralMajorInformation =
+  new FfiConverterOptional(
+    FfiConverterTypeStudentTeachingPluralMajorInformation
+  );
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for /*u32*/number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+// FfiConverter for Array<ChapelAbsenceRequest>
+const FfiConverterArrayTypeChapelAbsenceRequest = new FfiConverterArray(
+  FfiConverterTypeChapelAbsenceRequest
+);
+
+// FfiConverter for Array<ChapelAttendance>
+const FfiConverterArrayTypeChapelAttendance = new FfiConverterArray(
+  FfiConverterTypeChapelAttendance
+);
+
+// FfiConverter for Array<CourseScheduleInformation>
+const FfiConverterArrayTypeCourseScheduleInformation = new FfiConverterArray(
+  FfiConverterTypeCourseScheduleInformation
+);
+
+// FfiConverter for Array<StudentAcademicRecord>
+const FfiConverterArrayTypeStudentAcademicRecord = new FfiConverterArray(
+  FfiConverterTypeStudentAcademicRecord
+);
+
+// FfiConverter for Array<StudentFamilyMember>
+const FfiConverterArrayTypeStudentFamilyMember = new FfiConverterArray(
+  FfiConverterTypeStudentFamilyMember
+);
+
+// FfiConverter for Array<StudentTransferRecord>
+const FfiConverterArrayTypeStudentTransferRecord = new FfiConverterArray(
+  FfiConverterTypeStudentTransferRecord
+);
+
+// FfiConverter for Array<string>
+const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
+
+// FfiConverter for Map<Weekday, Array<CourseScheduleInformation>>
+const FfiConverterMapTypeWeekdayArrayTypeCourseScheduleInformation =
+  new FfiConverterMap(
+    FfiConverterTypeWeekday,
+    FfiConverterArrayTypeCourseScheduleInformation
+  );
+
+// FfiConverter for Map<string, /*f32*/number> | undefined
+const FfiConverterOptionalMapStringFloat32 = new FfiConverterOptional(
+  FfiConverterMapStringFloat32
+);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+  // Get the bindings contract version from our ComponentInterface
+  const bindingsContractVersion = 29;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion =
+    nativeModule().ubrn_ffi_rusaint_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_chapel() !==
+    36146
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_chapel'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_connected_major() !==
+    23575
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_connected_major'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_cyber() !==
+    62603
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_cyber'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_education() !==
+    26923
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_education'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_find_by_lecture() !==
+    60430
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_find_by_lecture'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_find_by_professor() !==
+    34168
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_find_by_professor'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_graduated() !==
+    33032
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_graduated'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_major() !==
+    62920
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_major'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_optional_elective() !==
+    18560
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_optional_elective'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_recognized_other_major() !==
+    31169
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_recognized_other_major'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_required_elective() !==
+    31001
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_required_elective'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_method_lecturecategorybuilder_united_major() !==
+    40110
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_method_lecturecategorybuilder_united_major'
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_rusaint_checksum_constructor_lecturecategorybuilder_new() !==
+    19652
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_rusaint_checksum_constructor_lecturecategorybuilder_new'
+    );
+  }
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeChapelAbsenceRequest,
+    FfiConverterTypeChapelAttendance,
+    FfiConverterTypeChapelInformation,
+    FfiConverterTypeClassGrade,
+    FfiConverterTypeClassScore,
+    FfiConverterTypeCourseScheduleInformation,
+    FfiConverterTypeCourseType,
+    FfiConverterTypeGeneralChapelInformation,
+    FfiConverterTypeGradeSummary,
+    FfiConverterTypeGraduationRequirement,
+    FfiConverterTypeGraduationRequirements,
+    FfiConverterTypeGraduationStudent,
+    FfiConverterTypeLecture,
+    FfiConverterTypeLectureAssessmentResult,
+    FfiConverterTypeLectureCategory,
+    FfiConverterTypeLectureCategoryBuilder,
+    FfiConverterTypePersonalCourseSchedule,
+    FfiConverterTypeScholarship,
+    FfiConverterTypeSemesterGrade,
+    FfiConverterTypeSemesterType,
+    FfiConverterTypeStudentAcademicRecord,
+    FfiConverterTypeStudentAcademicRecords,
+    FfiConverterTypeStudentBankAccount,
+    FfiConverterTypeStudentFamily,
+    FfiConverterTypeStudentFamilyMember,
+    FfiConverterTypeStudentForignStudyInformation,
+    FfiConverterTypeStudentGraduation,
+    FfiConverterTypeStudentInformation,
+    FfiConverterTypeStudentLifelongInformation,
+    FfiConverterTypeStudentQualification,
+    FfiConverterTypeStudentReligion,
+    FfiConverterTypeStudentResearchBankAccount,
+    FfiConverterTypeStudentTeachingMajorInformation,
+    FfiConverterTypeStudentTeachingPluralMajorInformation,
+    FfiConverterTypeStudentTransferRecord,
+    FfiConverterTypeStudentTransferRecords,
+    FfiConverterTypeStudentWorkInformation,
+    FfiConverterTypeU32Pair,
+    FfiConverterTypeUnsignedIntPair,
+    FfiConverterTypeWeekday,
+  },
+});