/** 创建字典项请求体 只包含code、key、value和sort_order 其他字段由后端自动填充 用于 /dictionary/items POST 示例：{"code": "gender", "key": "male", "value": "男", "sort_order": 1} */
export interface ControllerCreateDictionaryItemRequest {
  /** 字典类型编码 */
  code: string;
  /** 字典项key */
  key: string;
  /**
   * 排序值
   * @example 1
   */
  sort_order?: number;
  /** 字典项value */
  value: string;
}

/** 创建字典类型请求体 只包含code和name 其他字段由后端自动填充 用于 /dictionary/types POST  示例：{"code": "gender", "name": "性别"} */
export interface ControllerCreateDictionaryTypeRequest {
  /** 字典编码 */
  code: string;
  /** 字典名称 */
  name: string;
}

/** 创建学校请求体 包含name、code和stage 其他字段由后端自动填充 用于 /schools POST 示例：{"name": "清华大学", "code": "THU", "stage": "university"} */
export interface ControllerCreateSchoolRequest {
  /** 学校编码 */
  code: string;
  /** 学校名称 */
  name: string;
  /** 学阶 */
  stage: string;
}

export interface ControllerResponse {
  code?: number;
  message?: string;
}

/** 更新字典项请求体 只包含key、value和sort_order 其他字段由后端自动填充 用于 /dictionary/items/{id} PUT 示例：{"key": "male", "value": "男", "sort_order": 1} */
export interface ControllerUpdateDictionaryItemRequest {
  /** 字典项key */
  key: string;
  /**
   * 排序值
   * @example 1
   */
  sort_order?: number;
  /** 字典项value */
  value: string;
}

/** 更新字典类型请求体 只包含code和name 其他字段由后端自动填充 用于 /dictionary/types/{id} PUT 示例：{"code": "gender", "name": "性别"} */
export interface ControllerUpdateDictionaryTypeRequest {
  /** 字典编码 */
  code: string;
  /** 字典名称 */
  name: string;
}

/** 更新学校请求体 包含name、code、stage和is_enable 其他字段由后端自动填充 用于 /schools/{id} PUT 示例：{"name": "清华大学", "code": "THU", "stage": "university", "is_enable": true} */
export interface ControllerUpdateSchoolRequest {
  /** 学校编码 */
  code: string;
  /** 是否启用 */
  is_enable?: number;
  /** 学校名称 */
  name: string;
  /** 学阶 */
  stage: string;
}

/** 批量缺考操作的响应结果 */
export interface ExamBatchAbsentOperationResponse {
  /** 受影响的学生数量 */
  affected_students?: number;
  /** 考试ID */
  exam_id?: number;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 操作类型：absent_to_zero/zero_to_absent/set_student_absent */
  operation?: string;
}

/** 批量统分/取消统分的请求参数 */
export interface ExamBatchCalculateRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 是否统分：true-统分，false-取消统分 */
  is_calculated: boolean;
}

/** 批量修改虚拟阅卷老师密码的请求参数 */
export interface ExamBatchChangePasswordRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 用户ID列表
   * @minItems 1
   */
  ids: number[];
  /**
   * 新密码
   * @minLength 6
   */
  new_password: string;
}

/** 批量创建考试虚拟阅卷老师的请求参数 */
export interface ExamBatchCreateExamVirtualTeacherRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 科目创建信息列表
   * @minItems 1
   */
  subjects: ExamSubjectCreateInfo[];
}

export interface ExamBatchCreateMarkingTaskRecordRequest {
  /**
   * 批量数据
   * @minItems 1
   */
  batch_data: ExamCreateMarkingTaskRecordRequest[];
  /** 是否是回评 */
  is_review?: boolean;
}

/** 批量创建操作响应 */
export interface ExamBatchCreateResponse {
  /** 创建成功的列表 */
  created_list?: ExamExamVirtualTeacherResponse[];
  /** 失败数量 */
  failed_count?: number;
  /** 成功创建数量 */
  success_count?: number;
}

/** 批量删除考试虚拟阅卷老师的请求参数 */
export interface ExamBatchDeleteExamVirtualTeacherRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * ID列表
   * @minItems 1
   */
  ids: number[];
}

export interface ExamBatchDeleteRequest {
  /**
   * 要删除的汇总表ID列表
   * @minItems 1
   */
  ids: number[];
}

/** 批量删除操作响应 */
export interface ExamBatchDeleteResponse {
  /** 删除成功的ID列表 */
  deleted_ids?: number[];
  /** 失败数量 */
  failed_count?: number;
  /** 成功删除数量 */
  success_count?: number;
}

export interface ExamBatchDeleteScanAnswerSheetInfoRequest {
  /** 扫描答题卡ID列表 */
  ids: number[];
}

/** 批量排除学生的请求参数 */
export interface ExamBatchExcludeStudentsRequest {
  /**
   * 汇总表ID数组
   * @minItems 1
   */
  student_ids: number[];
}

/** 批量排除学生的响应结构 */
export interface ExamBatchExcludeStudentsResponse {
  /** 失败数量 */
  failed_count?: number;
  /** 失败的汇总表ID列表 */
  failed_ids?: number[];
  /** 操作结果信息 */
  message?: string;
  /** 成功排除数量 */
  success_count?: number;
  /** 总处理数量 */
  total_count?: number;
}

export interface ExamBatchFailItem {
  /** 数据索引 */
  index?: number;
  /** 失败原因 */
  message?: string;
  /** 模板题目ID */
  question_id?: number;
  /** 扫描答题卡信息ID */
  scan_info_id?: number;
  /** 任务ID */
  task_id?: number;
}

export interface ExamBatchMarkingTaskRecordResponse {
  /** 失败数量 */
  fail_count?: number;
  /** 失败的数据 */
  fail_data?: ExamBatchFailItem[];
  /** 是否结束 */
  is_end?: boolean;
  /** 成功创建数量 */
  success_count?: number;
  /** 成功创建的数据 */
  success_data?: ExamMarkingTaskRecordResponse[];
}

export interface ExamBatchObjectiveQuestionRiskProcessRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 处理情况 null:不选 0：待处理 1：已处理 */
  handle_status?: number;
  /** 学校ID */
  school_id?: number;
}

/** 批量操作的响应结果 */
export interface ExamBatchOperationResponse {
  /** 受影响的科目数量 */
  affected_subjects?: number;
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 操作类型：calculate/uncalculate/publish/unpublish */
  operation?: string;
}

/** 批量发布/取消发布的请求参数：根据考试ID与 exam_subject_ids（逗号分隔的考试科目ID列表）仅对指定科目执行发布/取消发布 */
export interface ExamBatchPublishRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 指定要发布/取消发布的考试科目ID列表
   * @minItems 1
   */
  exam_subject_ids: number[];
  /** 是否发布：true-发布，false-取消发布 */
  is_published: boolean;
}

/** 批量将指定学校的缺考学生成绩设置为0分 */
export interface ExamBatchSetAbsentToZeroRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 考试科目ID
   * @min 1
   */
  exam_subject_id: number;
}

/** 批量将指定学校的0分学生标记为缺考 */
export interface ExamBatchSetZeroToAbsentRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 考试科目ID
   * @min 1
   */
  exam_subject_id: number;
}

export interface ExamBatchTransferScanAnswerSheetInfoRequest {
  /** 扫描批次ID，转移整个批次时传 */
  batch_id?: number;
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 扫描答题卡ID列表,单个试卷或多个试卷时传 */
  ids?: number[];
  /** 学校ID */
  school_id: number;
}

/** 批量修改考号的响应结构 */
export interface ExamBatchUpdateExamNumberResponse {
  /** 错误信息列表 */
  error_messages?: string[];
  /** 失败数量 */
  failed_count?: number;
  /** 失败的数据列表 */
  failed_data?: ExamExcelExamNumberData[];
  /** 操作结果信息 */
  message?: string;
  /** Excel总行数（不含表头） */
  total_rows?: number;
  /** 成功更新数量 */
  updated_count?: number;
}

/** 批量更新答题卡模板题目请求结构体，用于批量更新或新增答题卡模板的题目信息，包含题目基本信息、答案设置、评分规则、阅卷配置等完整信息 */
export interface ExamBatchUpdateTemplateQuestionRequest {
  /**
   * @Description AI题目类型，用于AI识别和自动评分：
   * - objective: 客观题，如选择题、判断题等，可以自动评分
   * - subjective: 主观题，如简答题、论述题等，需要人工评分
   * 注意：此字段影响AI识别和自动评分的行为
   * @example "objective"
   */
  ai_question_type?: ExamBatchUpdateTemplateQuestionRequestAiQuestionTypeEnum;
  /**
   * @Description 分配方式，决定任务如何分配给教师：
   * - efficiency: 效率优先，系统根据教师历史阅卷效率自动分配
   * - quantity: 定量分配，手动指定每个教师分配的具体任务数量
   * - student: 按学生分配，根据学生数量进行分配
   * 注意：选择quantity时必须提供quantity_task_allocation配置
   * @example "efficiency"
   */
  allocation_method?: ExamBatchUpdateTemplateQuestionRequestAllocationMethodEnum;
  /**
   * @Description 答案得分类型，决定答案的评分方式：
   * - standard: 标准，按标准答案评分
   * - different: 不同选项，不同选项有不同分值
   * - number: 正确选项个数，按正确选项数量评分
   * 注意：此字段主要用于多选题和复杂评分场景
   * @example "standard"
   */
  answer_score_type?: ExamBatchUpdateTemplateQuestionRequestAnswerScoreTypeEnum;
  /**
   * @Description 仲裁老师列表，可选字段。仲裁老师负责处理阅卷争议和最终评分裁定。
   * 每个仲裁老师包含id(教师ID)和name(教师姓名)两个字段
   * 系统会自动为仲裁老师设置teacher_type=2
   */
  arbitration_teacher?: ExamSimpleTeacherInfo[];
  /**
   * @Description 分校分配配置列表，当allocation_method不为quantity时必填，quantity方式不需要。
   * 每个配置项包含school_id(学校ID)、allocation_method(分配类型)、average(平均分配数量)
   * 分配类型：average-平均分配，proportional-按比例分配
   * 系统会根据此配置将任务按学校进行分配
   */
  branch_task_allocation?: ExamBranchTaskAllocation[];
  /**
   * @Description 评阅方式，决定题目如何被评阅：
   * - single: 单评，每个题目只由一位教师评阅
   * - double: 双评，每个题目由两位教师评阅，系统会计算平均分或取最高分
   * - part: 部分评，每个题目由一位教师评阅，系统会计算部分得分
   * - multi: 多评，每个题目由多位教师评阅，系统会计算平均分或取最高分
   * - none: 无仲裁多评
   * 注意：双评模式下需要确保有足够的阅卷老师
   * @example "single"
   */
  evaluate_method?: ExamBatchUpdateTemplateQuestionRequestEvaluateMethodEnum;
  /**
   * @Description 评阅规则JSON字符串，用于存储具体的评阅规则配置
   * 注意：此字段为可选字段，用于存储复杂的评阅规则配置，如评分标准、容错范围等
   * @example "{"tolerance": 0.5, "max_diff": 2.0}"
   */
  evaluate_rules?: string;
  /**
   * @Description 满分值，题目的最高得分。用于计算得分比例和统计
   * 注意：必须是正数，建议与题目实际满分保持一致
   * @example 10
   */
  full_score?: number;
  /**
   * @Description 组长列表，可选字段。组长负责监督阅卷质量和进度。
   * 每个组长包含id(教师ID)和name(教师姓名)两个字段
   * 系统会自动为组长设置teacher_type=3
   */
  group_leader?: ExamSimpleTeacherInfo[];
  /**
   * @Description 半分值，题目的部分得分。用于部分正确的情况
   * 注意：通常小于满分值，可以为0表示不设半分
   * @example 5
   */
  half_score?: number;
  /**
   * @Description 题目ID，用于标识要操作的题目：
   * - 0: 表示新增记录，系统会创建新的题目
   * - 大于0: 表示更新记录，系统会根据此ID查找并更新现有题目
   * 注意：新增时必须提供template_id、question_major、question_minor字段
   * @example 0
   */
  id?: number;
  /**
   * @Description 是否错题纠正，标识此题是否为错题纠正题目
   * 注意：错题纠正题目可能有特殊的评分规则
   * @example false
   */
  is_wrong_correction?: boolean;
  /**
   * @Description 联考模式，决定考试的组织方式：
   * - single: 单校模式，适用于单个学校的考试
   * - branch: 分校模式，适用于分校考试
   * - mixed: 混合模式，适用于分校和单校混合考试
   * 注意：联考模式下必须提供branch_task_allocation配置
   * @example "single"
   */
  joint_mode?: ExamBatchUpdateTemplateQuestionRequestJointModeEnum;
  /**
   * @Description 阅卷老师列表，必填字段。阅卷老师负责具体的题目评阅工作。
   * 每个阅卷老师包含id(教师ID)和name(教师姓名)两个字段
   * 系统会自动为阅卷老师设置teacher_type=1
   * 注意：阅卷老师数量必须满足评选方式的要求，双评模式下至少需要2位阅卷老师
   */
  marking_teacher?: ExamSimpleTeacherInfo[];
  /**
   * @Description 选项个数，题目的选项数量。主要用于选择题
   * 注意：此字段主要用于统计和显示，不影响评分逻辑
   * @example 4
   */
  options_count?: number;
  /**
   * @Description 排序权重，用于控制题目在列表中的显示顺序
   * 注意：权重值越小排序越靠前，建议使用连续的整数
   * @example 1
   */
  order?: number;
  /**
   * @Description 数量分配配置列表，当allocation_method为quantity时必填，其他情况不需要。
   * 每个配置项包含school_id(学校ID)、teacher_id(教师ID)、teacher_name(教师姓名)、task_quantity(分配数量)
   * 系统会根据此配置将指定数量的任务分配给对应教师
   * 注意：所有配置的task_quantity总和应该等于或接近总任务数
   */
  quantity_task_allocation?: ExamQuantityTaskAllocation[];
  /**
   * @Description 大题号，题目的主要分类编号，如"一"、"二"、"三"等。新增记录时必填，更新记录时可选
   * 注意：同一模板下大题号应该唯一
   * @example "一"
   */
  question_major?: string;
  /**
   * @Description 小题号，题目的具体编号，如"1"、"2"、"3"等。新增记录时必填，更新记录时可选
   * 注意：同一大题下小题号应该唯一
   * @example "1"
   */
  question_minor?: string;
  /**
   * @Description 题目类型，题目的具体类型：
   * - single: 单选题，只有一个正确答案
   * - multiple: 多选题，有多个正确答案
   * - judge: 判断题
   * - answer: 解答题
   * - fill: 填空题
   * - composition: 作文题
   * - optional: 选做题
   * 注意：此字段影响答题卡的设计和评分逻辑
   * @example "single"
   */
  question_type?: ExamBatchUpdateTemplateQuestionRequestQuestionTypeEnum;
  /**
   * @Description 阅卷时长，单位：秒。用于计算阅卷进度和预估完成时间
   * 建议根据题目难度和字数合理设置，一般主观题建议300-600秒，客观题建议60-120秒
   * @example 300
   */
  review_time?: number;
  /**
   * @Description 得分类型，决定如何计算得分：
   * - zero: 零分
   * - full: 满分
   * 注意：此字段影响评分逻辑，建议与题目类型匹配
   * @example "full"
   */
  score_type?: ExamBatchUpdateTemplateQuestionRequestScoreTypeEnum;
  /**
   * @Description 打分模式，决定如何计算最终得分：
   * - total: 总分，直接使用评阅得分
   * - partial: 部分分，根据部分正确情况计算得分
   * 注意：此字段影响最终得分的计算方式
   * @example "total"
   */
  scoring_mode?: ExamBatchUpdateTemplateQuestionRequestScoringModeEnum;
  /**
   * @Description 标准答案，题目的正确答案。用于自动评分和参考答案
   * 注意：客观题建议提供标准答案，主观题可以为空或提供参考答案
   * @example "A"
   */
  standard_answer?: string;
  /**
   * @Description 综合科拆分单科ID，用于综合科题目拆分到具体单科。可选字段
   * 注意：只有综合科题目才需要此字段，单科题目不需要
   * @example 1
   */
  subject_id?: number;
  /**
   * @Description 模板ID，指定题目所属的答题卡模板。新增记录时必填，更新记录时可选
   * 注意：必须是系统中已存在的模板ID
   * @example 1001
   */
  template_id: number;
}

/** 分校任务分配结构体，用于非定量分配方式下的分校分配配置。当allocation_method为efficiency或student时使用此结构体进行按学校的任务分配 */
export interface ExamBranchTaskAllocation {
  /**
   * @Description 分配类型，决定该学校的任务分配方式：
   * - average: 平均分配，系统会将任务平均分配给该学校的教师
   * - proportional: 按比例分配，系统会根据该学校的学生数量按比例分配任务
   * 注意：选择proportional时，系统会自动计算分配比例，Average字段可能被忽略
   * @example "average"
   */
  allocation_method?: ExamBranchTaskAllocationAllocationMethodEnum;
  /**
   * @Description 平均分配数量，当AllocationType为average时使用此字段
   * 注意：
   * 1. 必须是正整数
   * 2. 此数量表示该学校每个教师平均分配的任务数量
   * 3. 实际分配时系统会根据该学校的教师数量进行调整
   * 4. 当AllocationType为proportional时，此字段可能被忽略
   * @example 30
   */
  average?: number;
  /**
   * @Description 学校ID，指定参与任务分配的学校。必须是系统中已存在的学校ID
   * 注意：此字段用于多校联考场景，每个参与学校都需要一个配置项
   * @example 1
   */
  school_id?: number;
}

export interface ExamCheckScoreItem {
  /** 远程查看URL */
  away_view_url?: string[];
  /** 考号 */
  exam_number?: string;
  /** 最终分数（可能为空） */
  final_score?: number;
  /** 阅卷时间 */
  marked_datetime?: string;
  /** 题目ID */
  question_id?: number;
  /** 阅卷记录列表 */
  records?: ExamCheckScoreRecord[];
  /** 备注 */
  remark?: string;
  /** 扫描信息ID */
  scan_info_id?: number;
  /** 学生ID（考号） */
  student_id?: string;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamCheckScoreRecord {
  /** 是否可以修改 */
  can_edit?: boolean;
  /** 是否可以打回重阅 */
  can_reread?: boolean;
  /** 创建人（改分时表示修改者） */
  created_by?: string;
  /** 是否优秀 */
  is_excellent?: boolean;
  /** 是否典型 */
  is_model?: boolean;
  /** 是否问题卷 */
  is_problem?: boolean;
  /** 记录ID */
  record_id?: number;
  /** 标注 */
  remark?: string;
  /** 学校ID */
  school_id?: number;
  /** 打分 */
  score?: number;
  /** 任务类型 */
  task_type?: string;
  /** 教师ID */
  teacher_id?: number;
  /** 教师姓名 */
  teacher_name?: string;
}

export interface ExamCheckScoreResponse {
  /** 平均分 */
  average_score?: number;
  /** 评价方法 */
  evaluate_method?: string;
  /** 学生答题列表 */
  items?: ExamCheckScoreItem[];
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 总记录数 */
  total_count?: number;
  /** 总分 */
  total_score?: number;
}

export interface ExamClassMatchRequest {
  /** 班级KEY */
  class_key?: number;
  /** 考试ID */
  exam_id?: number;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 学校ID */
  school_id?: number;
  /** 模板ID */
  template_id?: number;
  /** 上传状态筛选 */
  upload_status?: ExamClassMatchRequestUploadStatusEnum;
}

/** 客户端创建扫描答题卡批次请求体 */
export interface ExamCreateClientScanAnswerSheetBatchRequest {
  /** 考试科目ID */
  exam_subject_id: number;
  /** 学校ID */
  school_id: number;
  /** 模板ID（我们自己的模板表id） */
  template_id: number;
}

/** 客户端创建扫描答题卡批次响应体 */
export interface ExamCreateClientScanAnswerSheetBatchResponse {
  /** 批次ID */
  batch_id?: number;
  /** 批次索引 */
  batch_index?: number;
  /** 批次号 */
  batch_no?: string;
}

export interface ExamCreateClientScanAnswerSheetInfoRequest {
  /** AI识别的答题卡JSON数据 */
  ai_answer_sheet_json: string;
  /** 答题卡图片地址（多张正反面） */
  answer_sheet_urls: string[];
  /** 批次ID */
  batch_id: number;
}

export interface ExamCreateClientScanAnswerSheetInfoResponse {
  /** 扫描答题卡详情id */
  id?: number;
  /** 是否上传成功（无任何扫描异常） */
  is_success?: boolean;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamCreateExamAdminRequest {
  /** @maxLength 20 */
  name?: string;
  /**
   * 电话
   * @maxLength 20
   * @example "13800138000"
   */
  phone?: string;
  /**
   * 角色ID
   * @example "1"
   */
  role_id: string;
  /**
   * 学校ID
   * @example 1
   */
  school_id: number;
  /**
   * 科目ID
   * @max 100
   * @example 1
   */
  subject?: number;
  /**
   * 用户ID
   * @example "1"
   */
  teacher_id: string;
}

/** 创建考试报告发布设置的请求参数 */
export interface ExamCreateExamReportSettingRequest {
  /** 详细配置 */
  config: string;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 设置类型
   * @maxLength 50
   */
  setting_type: string;
}

/** 创建考试的请求参数 */
export interface ExamCreateExamRequest {
  /**
   * 考试班级列表
   * @minLength 1
   */
  exam_class: string;
  /** 考试日期，格式：yyyy-mm-dd，将被转换为time.Time类型 */
  exam_date: string;
  /** 考试年级字典key */
  exam_grade: string;
  /**
   * 考试名称
   * @minLength 1
   * @maxLength 50
   */
  exam_name: string;
  /**
   * 综合科目（科目ID，逗号分隔）
   * @maxLength 100
   */
  exam_subject_comprehensive?: string;
  /**
   * 单科考试科目（科目ID，逗号分隔）
   * @maxLength 100
   */
  exam_subject_single?: string;
  /** 考试类型字典key */
  exam_type: string;
  /** 阅卷方式字典key */
  marking_method: string;
  /** 扫描方式字典key */
  scan_method: string;
  /**
   * 学校ID，逗号分隔的字符串
   * @minItems 1
   */
  school_ids: number[];
}

/** 创建考试学生关联的请求参数 */
export interface ExamCreateExamStudentRequest {
  /**
   * 班级
   * @maxLength 20
   */
  class: string;
  /** 班级KEY */
  class_key: number;
  /**
   * 选考科目（字典）
   * @maxLength 200
   */
  elective_subjects?: string;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 考号
   * @maxLength 50
   */
  exam_number: string;
  /**
   * 外语项目
   * @maxLength 50
   */
  foreign_language?: string;
  /**
   * 年级
   * @maxLength 20
   */
  grade: string;
  /** 年级KEY */
  grade_key: number;
  /** 是否被剔除统计 */
  is_excluded?: boolean;
  /** 是否为补录考生 */
  is_supplemented?: boolean;
  /**
   * 家长姓名
   * @maxLength 50
   */
  parent_name: string;
  /**
   * 家长电话
   * @maxLength 50
   */
  parent_phone: string;
  /**
   * 学校ID
   * @min 1
   */
  school_id: number;
  /**
   * 学籍号
   * @maxLength 50
   */
  student_code?: string;
  /**
   * 学生姓名
   * @maxLength 50
   */
  student_name: string;
  /**
   * 学号
   * @maxLength 50
   */
  student_number?: string;
  /**
   * 学生标签
   * @maxLength 100
   */
  student_tag?: string;
}

/** 创建考试答题卡模板的请求体 */
export interface ExamCreateExamSubjectAnswerSheetTemplateRequest {
  /** @minLength 1 */
  ai_template_id: string;
  /** 关联的答题卡ID，当answer_sheet_type为answer_sheet时必填 */
  answer_sheet_id?: number;
  /** @minItems 1 */
  answer_sheet_images: string[];
  /** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
  answer_sheet_type: ExamCreateExamSubjectAnswerSheetTemplateRequestAnswerSheetTypeEnum;
  exam_no_length?: number;
  /** @min 1 */
  exam_subject_id: number;
  /**
   * 模板原始JSON信息
   * @minLength 1
   */
  raw_info: string;
  /** @minLength 1 */
  template_name: string;
}

/** 创建考试答题卡模板的响应体 */
export interface ExamCreateExamSubjectAnswerSheetTemplateResponse {
  /** AI识别模板ID */
  ai_template_id?: string;
  /** 关联的答题卡ID */
  answer_sheet_id?: number;
  /** 答题卡图片 */
  answer_sheet_images?: string;
  /** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
  answer_sheet_type?: string;
  /** 答题卡组件信息 */
  component_info?: string;
  /** 创建人姓名 */
  created_by?: string;
  /** 记录创建时间 */
  created_time?: string;
  /** 关联的考试ID */
  exam_id?: number;
  /** 考号位数 */
  exam_no_length?: number;
  /** 关联的考试科目ID */
  exam_subject_id?: number;
  /** 自增长主键ID */
  id?: number;
  /** 是否删除 */
  is_deleted?: number;
  /** 模板名称 */
  name?: string;
  /** 更新人姓名 */
  updated_by?: string;
  /** 记录最后更新时间 */
  updated_time?: string;
}

export interface ExamCreateMarkingTaskRecordRequest {
  /** 阅卷花费时长(单位:s) */
  duration?: number;
  /**
   * 阅卷记录id
   * @min 1
   */
  id: number;
  /**
   * 是否标记为优秀
   * @min 0
   * @max 1
   */
  is_excellent?: number;
  /**
   * 是否标记为典型
   * @min 0
   * @max 1
   */
  is_model?: number;
  /**
   * 是否标记为问题卷
   * @min 0
   * @max 1
   */
  is_problem?: number;
  /** 页面模式 */
  page_mode?: string;
  /** 模板题目ID */
  question_id?: number;
  /** （record_id弃用，使用id）阅卷任务记录ID，0表示新增，>0表示更新 */
  record_id?: number;
  /** 备注 */
  remark?: string;
  /** 扫描答题卡信息ID */
  scan_info_id?: number;
  /** 打分 */
  score?: number;
  /** 任务ID */
  task_id?: number;
}

/** 创建扫描答题卡批次请求体 */
export interface ExamCreateScanAnswerSheetBatchRequest {
  answer_sheet_images?: string[][];
  exam_id?: number;
  exam_subject_id?: number;
  school_id?: number;
  template_id?: number;
}

export interface ExamDeleteClientScanAnswerSheetBatchRequest {
  /** 批次ID */
  batch_id: number;
}

export interface ExamDeleteClientScanAnswerSheetInfoRequest {
  ids: number[];
}

export interface ExamDeleteExamAdminRequest {
  /**
   * 要删除的考试管理员ID数组（支持单个或多个）
   * @minItems 1
   */
  ids: number[];
}

/** 根据科目删除考生的请求参数 */
export interface ExamDeleteExamStudentBySubjectRequest {
  /**
   * 科目ID
   * @min 1
   */
  exam_subject_id: number;
  /**
   * 汇总表ID
   * @min 1
   */
  id: number;
}

/** 删除试卷或答案的请求参数 */
export interface ExamDeletePaperRequest {
  /**
   * 考试科目ID
   * @min 1
   */
  exam_subject_id: number;
  /** 删除类型：1-清空paper_url，2-清空paper_answer_url */
  type: ExamDeletePaperRequestTypeEnum;
}

/** 删除扫描答题卡批次 */
export interface ExamDeleteScanAnswerSheetBatchRequest {
  scan_batch_id?: number;
}

export interface ExamDistribution {
  /** 分数段人数 */
  count?: number;
  /** 分数段：例如 "0-10", "11-20", "21-30" 等 */
  score?: string;
}

export interface ExamDownloadScanAnswerSheetAbsentListRequest {
  /** 缺考名单的状态（缺考包含 缺考和未上传两种状态），null：所有的缺考名单 1：缺考名单-缺考 2：缺考名单-未上传 */
  absent_exam_status?: number;
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 学校ID */
  school_id?: number;
  /** 类型 1：缺考名单 2：未上传名单 3：考号异常名单 */
  type: number;
}

export interface ExamExamAdminListResponse {
  /** 考试管理员列表 */
  list?: ExamExamAdminResponse[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

export interface ExamExamAdminResponse {
  exam_id?: number;
  id?: number;
  /** 姓名 */
  name?: string;
  /** 电话 */
  phone?: string;
  /** 角色ID */
  role_id?: string;
  /** 学校ID（通过关联查询获取） */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 科目ID */
  subject?: number;
  /** 科目名称 */
  subject_name?: string;
  /** 用户ID */
  teacher_id?: string;
}

/** 考试与班级的关联关系 */
export interface ExamExamClass {
  /**
   * 班级名称
   * @example "1班"
   */
  class?: string;
  /**
   * 班级KEY
   * @example 1
   */
  class_key?: number;
  /**
   * 考试ID
   * @example 1
   */
  exam_id?: number;
  /**
   * 主键ID
   * @example 1
   */
  id?: number;
}

/** 考试列表响应结构 */
export interface ExamExamListResponse {
  /** 考试列表 */
  list?: ExamExamResponse[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

/** 考试总览基本信息 */
export interface ExamExamOverviewInfo {
  /** 缺考人数 */
  absent_count?: number;
  /** 平均分 */
  avg_score?: number;
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 考试类型："联考" 或 "单校考试" */
  exam_type?: string;
  /** 最高分 */
  max_score?: number;
  /** 最低分 */
  min_score?: number;
  /** 参与考试学校数量 */
  school_count?: number;
  /** 考生人数 */
  student_count?: number;
}

/** 考试的整体进度和统计信息，按科目列表形式展示 */
export interface ExamExamOverviewResponse {
  /** 各科目统计列表 */
  subjects?: ExamSubjectOverviewStats[];
}

/** 考试报告发布设置信息响应 */
export interface ExamExamReportSettingResponse {
  /** 详细配置 (JSON格式) */
  config?: string;
  /** 考试ID */
  exam_id?: number;
  /** 主键ID */
  id?: number;
  /** 设置类型 */
  setting_type?: string;
  /** 配置版本号 */
  version?: string;
}

/** 考试信息响应 */
export interface ExamExamResponse {
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  created_user_id?: string;
  /** 考试批次编号 */
  exam_batch_no?: number;
  /** 考试班级列表 */
  exam_classes?: ExamExamClass[];
  /** 考试日期 */
  exam_date?: string;
  /** 考试年级字典key */
  exam_grade?: string;
  /** 考试年级名称 */
  exam_grade_name?: string;
  /** 考试名称 */
  exam_name?: string;
  /** 考试类型字典key */
  exam_type?: string;
  /** 考试类型名称 */
  exam_type_name?: string;
  /** 满分 */
  full_score?: number;
  id?: number;
  /** 阅卷方式字典key */
  marking_method?: string;
  /** 阅卷方式名称 */
  marking_method_name?: string;
  /** 试卷答案路径 */
  paper_answer_url?: string;
  /** 原试卷路径 */
  paper_url?: string;
  /** 扫描方式字典key */
  scan_method?: string;
  /** 扫描方式名称 */
  scan_method_name?: string;
  /** 学校ID列表（逗号分隔） */
  school_ids?: string;
  /** 关联学校列表 */
  schools?: ExamSchool[];
  /** 考试状态 */
  status?: string;
  /** 考试状态名称 */
  status_name?: string;
  /** 考生人数 */
  student_count?: number;
  /** 考试科目列表 */
  subjects?: ExamExamSubjectResponse[];
  /** 修改人 */
  updated_by?: string;
  /** 修改时间 */
  updated_time?: string;
  updated_user_id?: string;
}

/** 考试学生关联列表响应结构 */
export interface ExamExamStudentListResponse {
  /** 考试学生关联列表 */
  list?: ExamExamStudentResponse[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

/** 考试学生关联信息响应 */
export interface ExamExamStudentResponse {
  /** 班级 */
  class?: string;
  /** 班级KEY */
  class_key?: number;
  /** 汇总表id */
  collect_id?: number;
  /** 选考科目 */
  elective_subjects?: string;
  /** 选考科目名称 */
  elective_subjects_name?: string;
  /** 科目 */
  exam_id?: number;
  /** 考号 */
  exam_number?: string;
  /** 外语科目 */
  foreign_language?: string;
  /** 年级 */
  grade?: string;
  /** 年级KEY */
  grade_key?: number;
  id?: number;
  /** 是否被剔除统计 */
  is_excluded?: boolean;
  /** 是否为补录考生 */
  is_supplemented?: boolean;
  /** 家长姓名 */
  parent_name?: string;
  /** 家长手机号 */
  parent_telphone?: string;
  /** 学校id */
  school_id?: number;
  /** 学籍号 */
  student_code?: string;
  /** 学生表主键 */
  student_id?: number;
  /** 学生姓名 */
  student_name?: string;
  /** 学号 */
  student_number?: string;
  /** 学生标签 */
  student_tag?: string;
  /** 科目名称 */
  subject_name?: string;
  /** 系统号 */
  system_number?: string;
  /** 上传状态 */
  upload_status?: string;
}

/** 考试科目答题卡模板模型 */
export interface ExamExamSubjectAnswerSheetTemplate {
  /** AI识别模板ID */
  ai_template_id?: string;
  /** 关联的答题卡ID，当answer_sheet_type为answer_sheet时必填 */
  answer_sheet_id?: number;
  /** 答题卡图片 */
  answer_sheet_images?: string;
  /** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
  answer_sheet_type?: string;
  /** 答题卡组件信息 */
  component_info?: string;
  /** 创建人姓名 */
  created_by?: string;
  /** 记录创建时间 */
  created_time?: string;
  /** 关联的考试ID */
  exam_id?: number;
  /** 考号位数 */
  exam_no_length?: number;
  /** 关联的考试科目ID */
  exam_subject_id?: number;
  /** 自增长主键ID */
  id?: number;
  /** 答题卡图片数量（计算字段） */
  image_num?: number;
  is_deleted?: number;
  /** 模板名称 */
  name?: string;
  /** 模板原始JSON信息 */
  raw_info?: string;
  /** 模板状态：0-未开始，1-进行中，2-已完成 */
  template_status?: number;
  /** 更新人姓名 */
  updated_by?: string;
  /** 记录最后更新时间 */
  updated_time?: string;
}

/** 考试科目答题卡模板详情响应体，包含模板信息和题目列表 */
export interface ExamExamSubjectAnswerSheetTemplateDetailResponse {
  /** AI识别模板ID */
  ai_template_id?: string;
  /** 关联的答题卡ID */
  answer_sheet_id?: number;
  /** 答题卡图片 */
  answer_sheet_images?: string;
  /** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
  answer_sheet_type?: string;
  /** 答题卡组件信息 */
  component_info?: string;
  /** 创建人姓名 */
  created_by?: string;
  /** 记录创建时间 */
  created_time?: string;
  /** 关联的考试ID */
  exam_id?: number;
  /** 考号位数 */
  exam_no_length?: number;
  /** 关联的考试科目ID */
  exam_subject_id?: number;
  /** 自增长主键ID */
  id?: number;
  /** 是否删除 */
  is_deleted?: number;
  /** 模板名称 */
  name?: string;
  /** 题目列表 */
  questions?: ExamExamSubjectAnswerSheetTemplateQuestion[];
  /** 模板原始JSON信息 */
  raw_info?: string;
  /** 更新人姓名 */
  updated_by?: string;
  /** 记录最后更新时间 */
  updated_time?: string;
}

/** 考试科目答题卡模板题目信息 */
export interface ExamExamSubjectAnswerSheetTemplateQuestion {
  ai_question_type?: string;
  allocation_method?: string;
  answer_score_type?: string;
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  evaluate_method?: string;
  evaluate_rules?: string;
  exam_subject_id?: number;
  full_score?: number;
  half_score?: number;
  id?: number;
  is_deleted?: number;
  is_wrong_correction?: boolean;
  joint_mode?: string;
  json_position?: string;
  marking_status?: string;
  options_count?: number;
  order?: number;
  question_major?: string;
  question_minor?: string;
  question_type?: string;
  review_time?: number;
  score_distribution?: string;
  score_type?: string;
  scoring_mode?: string;
  standard_answer?: string;
  store_status?: string;
  subject_id?: number;
  task_marked_num?: number;
  task_total_num?: number;
  template_id?: number;
  /** 修改人 */
  updated_by?: string;
  /** 修改时间 */
  updated_time?: string;
}

/** 考试科目详细信息响应，包含考试科目基本信息和关联的科目信息 */
export interface ExamExamSubjectInfoResponse {
  /** 考试科目基本信息 */
  exam_subject?: ExamExamSubjectResponse;
  /** 如果是综合科，包含的单科列表 */
  single_subjects?: ModelSingleSubjectResponse[];
  /** 关联的科目详细信息 */
  subject?: ModelSubjectResponse;
}

/** 考试科目列表项结构 */
export interface ExamExamSubjectListItem {
  /** 科目ID */
  id?: number;
  /** 科目名称 */
  name?: string;
  /** 学校ID（可为空，表示系统科目） */
  school_id?: number;
  /** 排序 */
  sort?: number;
  /** 科目类型 */
  type?: string;
}

/** 考试科目信息响应 */
export interface ExamExamSubjectResponse {
  /** 定位点及考号异常数 */
  anomaly_count?: number;
  /** 考试ID */
  exam_id?: number;
  /** 科目ID */
  id?: number;
  /** 是否已统分 */
  is_calculated?: boolean;
  /** 是否已发布 */
  is_published?: boolean;
  /** 是否已拆分（针对综合科） */
  is_split?: boolean;
  /** 阅卷进度 */
  marking_progress?: number;
  /** 客观题完成数 */
  objective_answer_done?: number;
  /** 试卷答案路径 */
  paper_answer_url?: string;
  /** 原试卷路径 */
  paper_url?: string;
  /** 问题试卷数量 */
  problem_sheet_count?: number;
  /** 扫描数量 */
  scanned_count?: number;
  /** 学校ID列表（逗号分隔） */
  school_ids?: string;
  /** 阅卷状态 */
  status?: number;
  /** 阅卷状态名称 */
  status_name?: string;
  /** 科目代码 */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
  /** 科目类型 */
  subject_type?: number;
  /** 科目类型名称 */
  subject_type_name?: string;
  /** 任务分配完成数 */
  task_assignment_done?: number;
  /** 已阅卷数量 */
  task_marked_num?: number;
  /** 任务总数 */
  task_total_num?: number;
  /** 模板ID */
  template_id?: number;
}

/** 考试科目扫描答题卡题目模型 */
export interface ExamExamSubjectScanAnswerSheetQuestion {
  /** AI识别题目类型名称,主观题/客观题 */
  ai_question_type?: string;
  /** 阅卷分配方式 */
  allocation_method?: string;
  /** 答案得分类型 */
  answer_score_type?: string;
  /** 创建人姓名 */
  created_by?: string;
  /** 记录创建时间 */
  created_time?: string;
  /** 评选方式 */
  evaluate_method?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 满分值 */
  full_score?: number;
  /** 半分值 */
  half_score?: number;
  /** 自增长主键ID */
  id?: number;
  is_deleted?: number;
  /** 是否是错题纠正，0:否，1:是 */
  is_wrong_correction?: boolean;
  /** 联考模式 */
  joint_mode?: string;
  json_position?: string;
  /** 阅卷老师 */
  marking_teacher?: string;
  options_count?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 题目类型名称 */
  question_type?: string;
  /** 阅卷时长，单位：秒 */
  review_time?: number;
  /** 得分分布 */
  score_distribution?: string;
  /** 得分类型 */
  score_type?: string;
  /** 标准答案 */
  standard_answer?: string;
  /** 考试科目答题卡模板ID */
  template_id?: number;
  /** 更新人姓名 */
  updated_by?: string;
  /** 记录最后更新时间 */
  updated_time?: string;
}

/** 考试各科目虚拟教师数量统计响应 */
export interface ExamExamVirtualTeacherCountResponse {
  /** 考试ID */
  exam_id?: number;
  /** 各科目统计列表 */
  subjects?: ExamSubjectVirtualTeacherCount[];
  /** 总数量 */
  total?: number;
}

/** 考试虚拟阅卷老师列表响应结构 */
export interface ExamExamVirtualTeacherListResponse {
  /** 考试虚拟阅卷老师列表 */
  list?: ExamExamVirtualTeacherResponse[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

/** 考试虚拟阅卷老师信息响应 */
export interface ExamExamVirtualTeacherResponse {
  /** 考试ID */
  exam_id?: number;
  id?: number;
  /** 阅卷进度 */
  marking_progress?: ExamMarkingProgress;
  /** 题目列表 */
  questions?: string;
  /** 科目信息 */
  subject?: ExamSubjectInfo;
  /** 科目ID */
  subject_id?: number;
  /** 老师信息 */
  teacher?: ExamTeacherInfo;
}

/** Excel模板中单个学生的考号数据结构 */
export interface ExamExcelExamNumberData {
  /** 班级 */
  class?: string;
  /** 考号 */
  exam_number?: string;
  /** Excel中的行号（用于错误定位） */
  row_number?: number;
  /** 学校 */
  school?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 科目 */
  subject?: string;
  /** 系统号 */
  system_number?: string;
}

/** Excel模板中单个学生的数据结构 */
export interface ExamExcelStudentData {
  /** 班级 */
  class?: string;
  /** 班级KEY */
  class_key?: number;
  /** 考号 */
  exam_number?: string;
  /** 年级 */
  grade?: string;
  /** 年级KEY */
  grade_key?: number;
  /** Excel中的行号（用于错误定位） */
  row_number?: number;
  /** 学校 */
  school?: string;
  /** 学生ID（从数据库查询得到） */
  student_id?: number;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamExportObjectiveQuestionRiskRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 处理情况 null:不选 0：待处理 1：已处理 */
  handle_status?: number;
  /** 学校ID */
  school_id?: number;
  /** 高低风险，1：低风险 2：高风险 */
  type: number;
}

/** 生成成绩补录模板的请求参数 */
export interface ExamGenerateScoreTemplateRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 模板类型：detail-小题分模式，total-总分模式 */
  type: ExamGenerateScoreTemplateRequestTypeEnum;
}

/** 获取答题详情标记信息响应体 */
export interface ExamGetAnswerDetailMarkingResponse {
  /** 答题详情ID */
  id?: number;
  /** 是否标记为优秀 */
  is_excellent?: number;
  /** 是否标记为典型 */
  is_model?: number;
  /** 是否标记为问题卷 */
  is_problem?: number;
  /** 问题卷附属说明 */
  problem_addition?: string;
  /** 问题卷状态 */
  problem_status?: string;
  /** 问题卷类型 */
  problem_type?: string;
  /** 备注 */
  remark?: string;
  /** 更新人 */
  updated_by?: string;
  /** 更新时间 */
  updated_time?: string;
}

/** 获取答题卡响应体 */
export interface ExamGetAnswerSheetResponse {
  /** 总分 */
  all_score?: number;
  /** 答题卡图片路径 */
  answer_sheet_images?: string[];
  /** 附加题得分 */
  bonus_score?: number;
  /** 班级 */
  class?: string;
  /** 班级排名 */
  class_rank?: number;
  /** 满分 */
  full_score?: number;
  /** 年级排名 */
  grade_rank?: number;
  /** 客观题答案列表 */
  objective_answer?: ExamObjectiveAnswer[];
  /** 客观题得分 */
  objective_score?: number;
  /** 原始数据 */
  raw_info?: string;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 主观题答案列表 */
  subjective_answer?: ExamSubjectiveAnswer[];
  /** 主观题得分 */
  subjective_score?: number;
}

export interface ExamGetExamSubjectsByExamIDResponse {
  exam_subject_id?: string;
  subject_name?: string;
}

export interface ExamGetObjectiveQuestionRiskListRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 处理情况 null:不选 0：待处理 1：已处理 */
  handle_status?: number;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
  /** 学校ID */
  school_id?: number;
  /** 高低风险，1：低风险 2：高风险 */
  type: number;
}

export interface ExamGetObjectiveQuestionRiskListResponse {
  /** AI模板ID */
  ai_template_id?: string;
  /** 答题卡图片列表 */
  answer_sheet_images?: string[];
  /** 第几份答题卡(某一个批次的几张) */
  answer_sheet_index?: number;
  /** 扫描批次ID */
  batch_id?: number;
  /** 班级 */
  class?: string;
  /** 处理情况 0：待处理 1：已处理 */
  handle_status?: number;
  /** 扫描答题卡ID */
  id?: number;
  /** ai答题卡原始数据 */
  raw_json?: string;
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 模板ID */
  template_id?: number;
  /** 模板原始数据 */
  template_raw_json?: string;
}

export interface ExamGetObjectiveQuestionRiskQuestionListRequest {
  /** 扫描答题卡ID */
  id: number;
  /** 题目类型 null:全部题 1：异常题 */
  type?: number;
}

export interface ExamGetObjectiveQuestionRiskQuestionListResponse {
  /** 学生作答内容 */
  answer?: string;
  /** 答题卡题目详情id */
  id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
}

export interface ExamGetObjectiveQuestionRiskStatisticsRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 学校ID */
  school_id?: number;
  /** 高低风险，1：低风险 2：高风险 */
  type: number;
}

export interface ExamGetObjectiveQuestionRiskStatisticsResponse {
  /** 异常数 */
  abnormal_count?: number;
  /** 已处理数 */
  handled_count?: number;
  /** 待处理数 */
  pending_count?: number;
}

export interface ExamGetQuestionMarkingQualityResponse {
  /** 所有学校下每个老师的平均分数 */
  average_score?: number;
  /** 评价方法 */
  evaluate_method?: string;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 按学校分组的阅卷质量数据 */
  school_groups?: ExamQuestionMarkingQualitySchool[];
  /** 所有学校下所有老师的总分数 */
  total_score?: number;
}

export interface ExamGetScanAnswerSheetAbsentListRequest {
  /** 缺考名单的状态（缺考包含 缺考和未上传两种状态），null：所有的缺考名单 1：缺考名单-缺考 2：缺考名单-未上传 */
  absent_exam_status?: number;
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
  /** 学校ID */
  school_id?: number;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 类型 1：缺考名单 2：未上传名单 3：考号异常名单 */
  type: number;
}

export interface ExamGetScanAnswerSheetAbsentListResponse {
  /** 班级 */
  class?: string;
  /** 姓名 */
  name?: string;
  /** 学校名称 */
  school_name?: string;
  /** 状态, 1：缺考 2：未上传 3：考号异常 */
  status?: number;
  /** 考号 */
  student_exam_number?: string;
}

export interface ExamGetScanAnswerSheetBatchCountResponse {
  /** 批次号 */
  batch_no?: number;
  /** 批次ID */
  scan_batch_id?: number;
  /** 已扫描数量 */
  scanned_count?: number;
  /** 异常数量 */
  unusual_count?: number;
  /** 已上传数量 */
  upload_count?: number;
}

export interface ExamGetScanAnswerSheetBatchDetailResponse {
  /** 异常数量 */
  abnormal_count?: number;
  /** 扫描批次号 */
  batch_no?: number;
  /** 答题卡详细信息 */
  list?: ExamScanAnswerSheetItem[];
  /** 扫描批次ID */
  scan_batch_id?: number;
  /** 已扫描数量 */
  scanned_count?: number;
  /** 已上传数量 */
  updated_count?: number;
}

export interface ExamGetScanAnswerSheetBatchListDetailRequest {
  /** 扫描批次ID */
  scan_batch_id?: number;
}

export interface ExamGetScanAnswerSheetBatchListDetailResponse {
  /** 图片 */
  images?: string[];
  /** 题目异常详情 */
  unusual_detail?: string;
  /** 题目异常 */
  unusual_objective?: number;
  /** 扫描异常 */
  unusual_scan?: number;
}

export interface ExamGetScanAnswerSheetBatchListRequest {
  /** 扫描人 */
  create_by?: string;
  /** 考试ID */
  exam_id?: number;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 学校ID */
  school_id?: number;
  /** 模板ID */
  template_id?: number;
}

export interface ExamGetScanAnswerSheetClassMatchDetailRequest {
  /** 班级KEY */
  class_key?: number;
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
  /** 学校ID */
  school_id: number;
  /** 状态 null:全部 1：已入库 2：已入库（缺考） 3：未入库 */
  status?: number;
}

export interface ExamGetScanAnswerSheetClassMatchDetailResponse {
  /** 答题卡图片列表 */
  answer_sheet_images?: string[];
  /** 班级 */
  class?: string;
  /** 试卷上传 */
  is_uploaded?: boolean;
  /** ai答题卡原始数据 */
  raw_json?: string;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamGetScanAnswerSheetClassMatchListRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 学校ID */
  school_id: number;
}

export interface ExamGetScanAnswerSheetClassMatchListResponse {
  /** 班级名称 */
  class?: string;
  /** 班级KEY */
  class_key?: number;
  /** 匹配的考生数（对后端就是上传数） */
  match_count?: number;
  /** 未上传数 */
  not_upload_count?: number;
  /** 班级的考生数 */
  total?: number;
}

export interface ExamGetScanAnswerSheetExceptionListRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
  /** 扫描人ID */
  scan_user_id?: string;
  /** 学校ID */
  school_id?: number;
  /** 类型 1：折角异常 2：试卷不完整 3：定位点异常 4：考号识别异常 5：考号重复 */
  type: number;
}

export interface ExamGetScanAnswerSheetExceptionListResponse {
  /** AI模板ID */
  ai_template_id?: string;
  /** 答题卡图片列表 */
  answer_sheet_images?: string[];
  /** 第几份答题卡 */
  answer_sheet_index?: number;
  /** 扫描批次ID */
  batch_id?: number;
  /** 扫描批次数 */
  batch_index?: number;
  /** 扫描批次号 */
  batch_no?: string;
  /** 考生姓名 */
  exam_student_name?: string;
  /** 考生考号 */
  exam_student_number?: string;
  /** 异常原因 */
  exception_reason?: string;
  /** 扫描答题卡ID */
  id?: number;
  /** ai答题卡原始数据 */
  raw_json?: string;
  /** 考号重复列表（考号重复比较特殊，所以当考号重复时返回一组，上面的字段可以不用了） */
  repeat_exam_student_number_list?: ExamGetScanAnswerSheetExceptionListResponse[];
  /** 扫描人姓名 */
  scan_user_name?: string;
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 模板ID */
  template_id?: number;
  /** 模板原始数据 */
  template_raw_json?: string;
}

export interface ExamGetScanAnswerSheetInfoListRequest {
  /** 答题卡状态列表 null:查询全部 勾选几个传几个, 1：未识别 2：定位点异常 3：考号重复 4：考号异常 5：已入库（考号重复） 6：正常/已入库 */
  answer_sheet_status_list?: number[];
  /** 扫描批次ID */
  batch_id?: number;
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
  /** 扫描人ID */
  scan_user_id?: string;
  /** 学校ID */
  school_id?: number;
}

export interface ExamGetScanAnswerSheetInfoListResponse {
  /** AI模板ID */
  ai_template_id?: string;
  /** 答题卡图片列表 */
  answer_sheet_images?: string[];
  /** 答题卡状态,1：未识别 2：定位点异常 3：考号重复 4：考号异常 5：已入库（考号重复） 6：正常/已入库 */
  answer_sheet_status?: number[];
  /** 扫描批次ID */
  batch_id?: number;
  /** 扫描批次索引 */
  batch_index?: number;
  /** 扫描批次号 */
  batch_no?: string;
  /** 扫描答题卡ID */
  id?: number;
  /** 扫描人姓名 */
  scan_user_name?: string;
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 学生学号 */
  student_number?: string;
  /** 模板ID */
  template_id?: number;
}

export interface ExamGetScanAnswerSheetInfoStatisticsRequest {
  /** 扫描批次ID */
  batch_id?: number;
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 扫描人ID */
  scan_user_id?: string;
  /** 学校ID */
  school_id?: number;
}

export interface ExamGetScanAnswerSheetInfoStatisticsResponse {
  /** 未识别数 */
  not_recognize_count?: number;
  /** 定位点异常数 */
  positioning_abnormal_count?: number;
  /** 考号异常数 */
  student_exam_number_abnormal_count?: number;
  /** 考号重复数 */
  student_exam_number_repeat_count?: number;
}

export interface ExamGetScanAnswerSheetProgressRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
}

export interface ExamGetScanAnswerSheetProgressResponse {
  /** 考号重复数（中间值，最终会归类到positioning_and_exam_number_abnormal_count中） */
  exam_number_repeat_count?: number;
  /** 未识别试卷数 */
  not_recognize_count?: number;
  /** 客观题异常数 */
  objective_question_abnormal_count?: number;
  /** 定位以及考号异常数 */
  positioning_and_exam_number_abnormal_count?: number;
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 总数量 */
  total_count?: number;
  /** 已上传数量 */
  upload_count?: number;
}

export interface ExamGetScanAnswerSheetProgressStatisticsRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
}

export interface ExamGetScanAnswerSheetProgressStatisticsResponse {
  /** 缺考 */
  absent_count?: number;
  /** 考生数 */
  student_count?: number;
  /** 总进度 */
  total_progress?: number;
  /** 已上传数 */
  uploaded_count?: number;
}

export interface ExamGetScanAnswerSheetRepeatStudentInfoRequest {
  /** 扫描答题卡ID */
  id: number;
}

export interface ExamGetScanAnswerSheetRepeatStudentInfoResponse {
  /** 考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamGetScanProcessDetailRequest {
  /** 批次号 */
  batch_no?: number;
  /** 考试ID */
  exam_id?: number;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 学校ID */
  school_id?: number;
  /** 模板ID */
  template_id?: number;
  /** 题目异常 */
  unusual_objective?: number;
  /** 扫描异常 */
  unusual_scan?: number;
}

export interface ExamGetScanProcessDetailResponse {
  list?: ExamScanProcessDetailItem[];
}

export interface ExamGetScoreDistributionResponse {
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 学校ID（可选） */
  school_id?: number;
  /** 分数分布列表 */
  score_items?: ExamScoreDistributionItem[];
  /** 教师ID（可选） */
  teacher_id?: number;
  /** 总阅卷数量 */
  total_count?: number;
}

export interface ExamGetStudentMarkingQualityResponse {
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 学生列表 */
  students?: ExamStudentMarkingQualityItem[];
  /** 总数量 */
  total_count?: number;
}

/** 获取科目列表的响应结果 */
export interface ExamGetSubjectListResponse {
  /** 科目列表 */
  list?: ExamExamSubjectListItem[];
  /** 总数 */
  total?: number;
}

export interface ExamHandleProblemRecordResponse {
  /** 是否结束 */
  is_end?: boolean;
}

export interface ExamIncrClientScanAnswerSheetBatchUploadNumRequest {
  /** 批次ID */
  batch_id: number;
}

export interface ExamMarkObjectiveQuestionRiskAbsentRequest {
  /** 答题卡ID */
  id: number;
}

/** 阅卷进度信息 */
export interface ExamMarkingProgress {
  /** 已完成数量 */
  completed_count?: number;
  /** 进度百分比 */
  progress?: number;
  /** 总数量 */
  total_count?: number;
}

/** 所有学校的阅卷进度统计 */
export interface ExamMarkingProgressBySchoolResponse {
  /** 学校列表 */
  list?: ExamSchoolMarkingProgress[];
}

export interface ExamMarkingProgressResponse {
  /** 创建时间 */
  created_time?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 最终进度 */
  final_progress?: ExamProgressDetail;
  /** 进度百分比 */
  progress_percent?: number;
  /** 题目进度详情 */
  questions?: ExamQuestionProgressDetail[];
  /** 单人进度 */
  single_progress?: ExamProgressDetail;
  /** 阅卷状态 */
  status?: number;
  /** 答题卡模板ID */
  template_id?: number;
  /** 答题卡模板名称 */
  template_name?: string;
  /** 已阅卷量 */
  total_marked_num?: number;
  /** 新增进度字段 */
  total_progress?: ExamProgressDetail;
  /** 总题目数 */
  total_questions?: number;
  /** 总分 */
  total_score?: number;
  /** 总任务量 */
  total_task_num?: number;
  /** 更新时间 */
  updated_time?: string;
}

export interface ExamMarkingQualityResponse {
  /** 客观题质量统计 */
  objective_item?: ExamObjectiveQualityItem;
  /** 主观题质量统计 */
  subjective_item?: ExamSubjectiveQualityItem;
}

export interface ExamMarkingTaskAverageScoreResponse {
  /** 本题均分 */
  average_score?: number;
  /** 我的均分 */
  my_average_score?: number;
  /** 我阅数量 */
  my_scored_count?: number;
  /** 分数分布 */
  score_distribution?: ExamDistribution[];
  /** 已阅数量 */
  scored_count?: number;
}

export interface ExamMarkingTaskHistoryRecord {
  /** AI识别题目类型 */
  ai_question_type?: string;
  /** 学生作答内容 */
  answer?: string;
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  /** 答题详情ID */
  detail_id?: number;
  /** 试卷方向 */
  direction?: string;
  /** 阅卷花费时长(单位:s) */
  duration?: number;
  /** 结束时间 */
  end_time?: string;
  /** 最终得分 */
  final_score?: number;
  /** 满分值 */
  full_score?: number;
  /** 半分值 */
  half_score?: number;
  /** 记录ID */
  id?: number;
  /** 图片完整路径数组 */
  image_urls?: string[];
  /** 是否标记为优秀 */
  is_excellent?: number;
  /** 是否标记为典型 */
  is_model?: number;
  /** 是否标记为问题卷 */
  is_problem?: number;
  /** 阅卷状态,1:已分配（未阅）2：已阅 */
  marking_status?: number;
  /** 页面模式 */
  page_mode?: string;
  /** 问题卷附属说明 */
  problem_addition?: string;
  /** 问题卷状态 */
  problem_status?: string;
  /** 问题卷类型 */
  problem_type?: string;
  /** 模板题目ID */
  question_id?: number;
  /** 题目相关字段 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 题目类型 */
  question_type?: string;
  /** 备注 */
  remark?: string;
  /** 扫描答题卡信息ID */
  scan_info_id?: number;
  /** 打分 */
  score?: number;
  /** 阅卷历史记录序号 */
  seq?: number;
  /** 标准答案 */
  standard_answer?: string;
  /** 开始时间 */
  start_time?: string;
  /** 任务ID */
  task_id?: number;
  /** 更新人 */
  updated_by?: string;
  /** 更新时间 */
  updated_time?: string;
}

export interface ExamMarkingTaskListResponse {
  /** 任务列表 */
  list?: ExamMarkingTaskResponse[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

export interface ExamMarkingTaskRecordResponse {
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  /** 阅卷话费时长(单位:s) */
  duration?: number;
  /** 结束时间 */
  end_time?: string;
  /** 记录ID */
  id?: number;
  /** 图片完整路径数组 */
  image_urls?: string[];
  /** 是否结束 */
  is_end?: boolean;
  /** 是否标记为优秀 */
  is_excellent?: number;
  /** 是否标记为典型 */
  is_model?: number;
  /** 是否标记为问题卷 */
  is_problem?: number;
  /** 页面模式 */
  page_mode?: string;
  /** 模板题目ID */
  question_id?: number;
  /** 备注 */
  remark?: string;
  /** 扫描答题卡信息ID */
  scan_info_id?: number;
  /** 打分 */
  score?: number;
  /** 开始时间 */
  start_time?: string;
  /** 任务ID */
  task_id?: number;
}

export interface ExamMarkingTaskResponse {
  /** 创建时间 */
  created_time?: string;
  /** 评估类型 */
  evaluate_method?: string;
  /** 考试时间 */
  exam_date?: string;
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 科目考试状态 */
  exam_subject_status?: number;
  /** 是否存在问题卷 */
  is_problem_pending?: boolean;
  /** 阅卷状态 */
  marking_status?: string;
  /** 题目数量 */
  question_count?: number;
  /** 科目ID */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
  /** 教师类型：normal-阅卷老师, arbitration-仲裁老师, leader-组长 */
  teacher_type?: string;
  /** 模板ID */
  template_id?: number;
}

export interface ExamNoScoreQuestionRequest {
  /**
   * 阅卷记录id
   * @min 1
   */
  id: number;
  /**
   * 任务ID
   * @min 1
   */
  task_id: number;
}

/** 客观题答案 */
export interface ExamObjectiveAnswer {
  /** 最终得分 */
  final_score?: number;
  /** 满分 */
  full_score?: number;
  /** 题目ID */
  question_id?: number;
  /** 题目大类 */
  question_major?: string;
  /** 题目小类 */
  question_minor?: string;
  /** 标准答案 */
  standard_answer?: string;
}

export interface ExamObjectiveQualityItem {
  /** 平均分 */
  average_score?: number;
  /** 总分 */
  total_score?: number;
  /** 按题目类型分组的统计 */
  type_items?: ExamObjectiveTypeQualityItem[];
}

export interface ExamObjectiveQuestionItem {
  /** 全对数量 */
  all_right_num?: number;
  /** 全对百分比 */
  all_right_percent?: number;
  /** 总数量 */
  all_total_num?: number;
  /** 半对数量（仅multiple类型） */
  half_right_num?: number;
  /** 半对百分比（仅multiple类型） */
  half_right_percent?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
}

export interface ExamObjectiveTypeQualityItem {
  /** 平均分 */
  average_score?: number;
  /** 题目统计列表 */
  question_items?: ExamObjectiveQuestionItem[];
  /** 题目类型 */
  question_type?: string;
  /** 总分 */
  total_score?: number;
}

export interface ExamProblemSheetListItem {
  /** 评分方式 */
  evaluate_method?: string;
  /** 题目总分 */
  full_score?: number;
  /** 问题卷信息ID */
  problem_info_id?: number;
  /** 总数量 */
  problem_total?: number;
  /** 已处理数量 */
  processed_num?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 未处理数量 */
  unprocessed_num?: number;
}

export interface ExamProblemSheetListResponse {
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 问题卷列表项 */
  items?: ExamProblemSheetListItem[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总记录数 */
  total_count?: number;
  /** 总页数 */
  total_pages?: number;
}

export interface ExamProblemSheetRereadRequest {
  /**
   * 题目ID列表（必传）
   * @minItems 1
   */
  question_ids: number[];
}

export interface ExamProblemSheetStatisticsItem {
  /** 待处理数量 */
  pending_num?: number;
  /** 已处理数量 */
  processed_num?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 总数量 */
  total_num?: number;
}

export interface ExamProblemSheetStatisticsResponse {
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 统计项列表 */
  items?: ExamProblemSheetStatisticsItem[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总问题卷数量 */
  total_count?: number;
  /** 总页数 */
  total_pages?: number;
}

export enum ExamProblemStatus {
  ProblemStatusPending = 'pending',
  ProblemStatusProcessing = 'processing',
  ProblemStatusResolved = 'resolved',
  ProblemStatusRejected = 'rejected',
  ProblemStatusProcessed = 'processed'
}

export enum ExamProblemType {
  ProblemTypeImageFog = 'image_fog',
  ProblemTypeFooterMissing = 'footer_missing'
}

export interface ExamProgressDetail {
  /** 已阅卷数量 */
  marked_quantity?: number;
  /** 未合分数量 */
  unmerged_quantity?: number;
}

/** 数量任务分配结构体，用于定量分配方式下的任务分配配置。当allocation_method为quantity时使用此结构体进行精确的任务数量分配 */
export interface ExamQuantityTaskAllocation {
  /**
   * @Description 是否为虚拟老师，指定接收任务的教师。必须是系统中已存在的教师用户ID
   * 注意：此教师必须是该学校的教师，且具有阅卷权限
   * @example 0
   */
  is_virtual?: number;
  /**
   * @Description 学校ID，指定任务分配的目标学校。必须是系统中已存在的学校ID
   * 注意：此字段用于多校联考场景，单校考试时通常为1
   * @example 1
   */
  school_id?: number;
  /**
   * @Description 分配的任务数量，指定分配给该教师的具体题目数量
   * 注意：
   * 1. 必须是正整数
   * 2. 所有配置的TaskQuantity总和应该等于或接近总题目数
   * 3. 建议根据教师能力和题目难度合理分配
   * 4. 系统会根据此数量创建具体的阅卷任务
   * @example 50
   */
  task_quantity?: number;
  /**
   * @Description 教师ID，指定接收任务的教师。必须是系统中已存在的教师用户ID
   * 注意：此教师必须是该学校的教师，且具有阅卷权限
   * @example 123
   */
  teacher_id?: number;
  /**
   * @Description 教师姓名，用于显示和确认。建议与系统中教师姓名保持一致
   * 注意：此字段主要用于显示，系统实际使用TeacherID进行关联
   * @example "张老师"
   */
  teacher_name?: string;
  /**
   * @Description 用户ID，指定接收任务的教师。必须是系统中已存在的教师用户ID
   * 注意：此教师必须是该学校的教师，且具有阅卷权限
   * @example "123"
   */
  user_id?: string;
}

export interface ExamQuestionAverageScoreComparisonResponse {
  /** 所有老师平均分 */
  all_teachers_score?: ExamQuestionAverageScoreResponse;
  /** 成绩分布 */
  distributions?: any;
  /** 题目ID */
  question_id?: number;
  /** 题号主号 */
  question_major?: string;
  /** 题号次号 */
  question_minor?: string;
  /** 特定老师平均分 */
  teacher_score?: ExamTeacherQuestionAverageScoreResponse;
}

export interface ExamQuestionAverageScoreResponse {
  /** 平均分 */
  average_score?: number;
  /** 题目ID */
  question_id?: number;
  /** 题号主号 */
  question_major?: string;
  /** 题号次号 */
  question_minor?: string;
  /** 已打分记录数 */
  scored_count?: number;
  /** 总记录数 */
  total_count?: number;
}

export interface ExamQuestionMarkingProgressResponse {
  /** 分配方式 */
  allocation_method?: string;
  /** 评选方式 */
  evaluate_method?: string;
  /** 已阅卷数量 */
  marked_quantity?: number;
  /** 阅卷状态 */
  marking_status?: string;
  /** 进度列表 */
  progress_list?: ExamTaskTypeProgressDetail[];
  /** 题目ID */
  question_id?: number;
  /** 总数量 */
  total_quantity?: number;
}

export interface ExamQuestionMarkingQualitySchool {
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 老师列表 */
  teachers?: ExamQuestionMarkingQualityTeacher[];
}

export interface ExamQuestionMarkingQualityTeacher {
  /** 平均分 */
  average_score?: number;
  /** 平均用时（秒） */
  average_time?: number;
  /** 阅卷量 */
  marking_count?: number;
  /** 老师手机号 */
  phone?: string;
  /** 标准差 */
  standard_dev?: number;
  /** 老师ID */
  teacher_id?: number;
  /** 老师名称 */
  teacher_name?: string;
}

export interface ExamQuestionProgressDetail {
  /** 平均分数 */
  average_score?: number;
  /** 评选方式 */
  evaluate_method?: string;
  /** 满分 */
  full_score?: number;
  /** 阅卷状态 */
  marking_status?: string;
  /** 进度百分比 */
  progress_percent?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 已阅卷量 */
  task_marked_num?: number;
  /** 总任务量 */
  task_total_num?: number;
}

export interface ExamQuestionSubjectDivisionResponse {
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 单科ID */
  subject_id?: number;
  /** 单科名称 */
  subject_name?: string;
}

export interface ExamQuestionWithTasksResponse {
  /** 评价方法 */
  evaluate_method?: string;
  /** 满分 */
  full_score?: number;
  /** 阅卷进度（题目维度）：已阅与待阅 */
  marked?: number;
  /** 待阅（总任务量-已阅），双评不乘以2 */
  pending?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 任务列表 */
  tasks?: Record<string, ExamTeacherMarkingTaskResponse>;
}

/** 排名项目（联考时为学校，单校时为班级） */
export interface ExamRankingItem {
  /** 平均分 */
  avg_score?: number;
  /** 单校时使用 */
  class_key?: number;
  /** 班级名称 */
  class_name?: string;
  /** 最高分 */
  max_score?: number;
  /** 最低分 */
  min_score?: number;
  /** 通用字段 */
  rank?: number;
  /** 联考时使用 */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
}

export interface ExamRereadByRecordIDRequest {
  /** 题目id */
  question_id: number;
  /** 答题卡id */
  scan_info_id: number;
}

export interface ExamRereadMarkingRequest {
  /** 题目ID列表 */
  question_ids?: number[];
  /** 重阅类型 */
  reread_type: ExamRereadMarkingRequestRereadTypeEnum;
  /** 学校ID */
  school_id?: number;
  /** 教师ID */
  teacher_id?: number;
  /** 指定值（time类型时为时间秒数） */
  value?: number;
  /** 多个指定值（score类型时为分数列表） */
  values?: number[];
}

export interface ExamRereadMarkingResponse {
  /** 删除的记录数量 */
  deleted_count?: number;
  /** 响应消息 */
  message?: string;
  /** 是否成功 */
  success?: boolean;
  /** 调度任务ID（仅all类型时返回） */
  task_id?: string;
}

export enum ExamRereadType {
  RereadTypeAll = 'all',
  RereadTypeScore = 'score',
  RereadTypeTime = 'time'
}

export interface ExamResumeMarkingRequest {
  /** ID：根据resume_type不同，传递考试科目ID或题目ID */
  id: number;
  /** 恢复类型：subject-考试科目，question-题目 */
  resume_type: ExamResumeMarkingRequestResumeTypeEnum;
}

export interface ExamResumeMarkingResponse {
  /** 响应消息 */
  message?: string;
  /** 是否成功 */
  success?: boolean;
}

export interface ExamReviewHistoryScoreRequest {
  /**
   * 任务ID
   * @min 1
   */
  task_id: number;
}

export interface ExamReviewHistoryScoreResponse {
  /** 历史评分列表,按照分数从低到高 */
  history_scores?: number[];
}

export interface ExamSaveObjectiveQuestionRiskAnswerRequest {
  /** 答题卡ID */
  id: number;
  /** 异常题或者全部题列表 */
  list: ExamSaveObjectiveQuestionRiskAnswerRequestItem[];
}

export interface ExamSaveObjectiveQuestionRiskAnswerRequestItem {
  /** 更正的答案 */
  answer: string;
  /** 答题卡题目详情id */
  id: number;
}

export interface ExamSaveScanAnswerSheetExceptionUploadRequest {
  /** 考试ID（批量保存并上传用） */
  exam_id?: number;
  /** 考试科目ID（批量保存并上传用） */
  exam_subject_id?: number;
  /** 扫描答题卡ID（单个保存并上传用） */
  id?: number;
  /** 类型 1：折角异常 2：试卷不完整 */
  type: number;
}

export interface ExamSaveUploadRequest {
  /** 答题卡ID */
  info_id?: number;
}

/** 扫描答题卡识别信息 */
export interface ExamScanAnswerSheetInfo {
  answer_sheet_image?: string[];
  raw_info?: string;
}

export interface ExamScanAnswerSheetItem {
  /** 扫描批次 */
  batch_no?: number;
  /** 扫描人 */
  create_by?: string;
  /** 扫描答题卡ID */
  scan_answer_sheet_id?: number;
  /** 扫描答题卡图片 */
  scan_answer_sheet_images?: string[];
  /** 答题卡扫描状态 */
  status?: string;
  /** 考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 学生学号 */
  student_number?: string;
}

export interface ExamScanAnswerSheetMatchStudentAddRequest {
  /** 扫描答题卡ID */
  id: number;
  /** 考号 */
  student_exam_number: string;
}

export interface ExamScanAnswerSheetOverviewRequest {
  /** 考试ID */
  exam_id: number;
  /** 考试科目ID */
  exam_subject_id: number;
  /** 学校ID */
  school_id: number;
}

export interface ExamScanAnswerSheetOverviewResponse {
  /** 客观题异常数 */
  objective_question_anomaly_count?: number;
  /** 折角异常数 */
  scan_anomaly_angle_count?: number;
  /** 定位点及考号异常数 */
  scan_anomaly_position_and_exam_number_count?: number;
  /** 总数量 */
  total_count?: number;
  /** 已上传数量 */
  uploaded_count?: number;
}

export interface ExamScanProcessDetailItem {
  /** 未识别数 */
  not_recognize_count?: number;
  /** 客观题异常数 */
  objective_question_abnormal_count?: number;
  /** 定位异常数 */
  positioning_abnormal_count?: number;
  /** 上传进度分母：扫描数 */
  scanned_count?: number;
  /** 学校名称 */
  school_name?: string;
  /** 学生考号异常 */
  student_exam_number_abnormal_count?: number;
  /** 上传进度分子：已上传数 */
  updated_count?: number;
}

export interface ExamScanTransferRequest {
  /** 答题卡ID */
  info_id?: number[];
  /** 目标科目ID */
  subject_id?: number;
}

/** 学校基本信息 */
export interface ExamSchool {
  /** 学校ID */
  id?: number;
  /** 学校代码 */
  school_code?: string;
  /** 学校名称 */
  school_name?: string;
}

/** 单个学校各科目的阅卷进度 */
export interface ExamSchoolMarkingProgress {
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 科目列表 */
  subjects?: ExamSubjectMarkingProgress[];
}

export interface ExamSchoolProgressDetail {
  /** 阅卷列表 */
  marking_list?: ExamTeacherMarkingDetail[];
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
}

/** 单个学校各科目的扫描进度 */
export interface ExamSchoolScanProgress {
  /** 学校ID */
  school_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 科目列表 */
  subjects?: ExamSubjectScanProgress[];
}

/** 各学校各科目的扫描进度统计 */
export interface ExamSchoolScanProgressResponse {
  /** 学校列表 */
  list?: ExamSchoolScanProgress[];
}

export interface ExamScoreDistributionItem {
  /** 该分数的数量 */
  count?: number;
  /** 分数 */
  score?: number;
}

/** 考试科目成绩总览响应 */
export interface ExamScoreOverviewResponse {
  /** 考试基本信息 */
  exam_info?: ExamExamOverviewInfo;
  /** 排名列表（联考显示学校排名，单校显示班级排名） */
  ranking_list?: ExamRankingItem[];
}

export interface ExamSetProblemRecordRequest {
  /**
   * 答题详情ID
   * @min 1
   */
  id: number;
  /** 是否是回评 */
  is_review?: boolean;
  /**
   * 问题卷附属说明
   * @maxLength 500
   */
  problem_addition?: string;
  /** 问题卷类型 */
  problem_type: ExamSetProblemRecordRequestProblemTypeEnum;
  /**
   * 任务ID
   * @min 1
   */
  task_id: number;
}

export interface ExamSetProblemRecordResponse {
  /** 问题卷附属说明 */
  problem_addition?: string;
  /** 问题卷状态 */
  problem_status?: ExamProblemStatus;
  /** 问题卷类型 */
  problem_type?: ExamProblemType;
  /** 扫描答题卡信息ID */
  scan_info_id?: number;
  /** 任务ID */
  task_id?: number;
  /** 模板题目ID */
  tpl_question_id?: number;
  /** 更新人 */
  updated_by?: string;
  /** 更新时间 */
  updated_time?: string;
}

export interface ExamSetQuestionSubjectRequest {
  /** 题目ID */
  question_id: number;
  /** 单科ID */
  subject_id: number;
}

/** 设置单个学生为缺考状态 */
export interface ExamSetStudentAbsentRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 学生考号
   * @maxLength 50
   */
  exam_number: string;
  /**
   * 考试科目ID
   * @min 1
   */
  exam_subject_id: number;
  /** 是否缺考：true-设为缺考，false-取消缺考 */
  is_absent?: boolean;
}

/** 简单老师信息结构，用于在任务分配中标识教师身份。包含教师的基本标识信息 */
export interface ExamSimpleTeacherInfo {
  /**
   * @Description 老师ID，必须是系统中已存在的教师用户ID。系统会根据此ID查找对应的教师信息进行任务分配
   * 注意：此ID必须是有效的教师用户ID，否则会导致任务分配失败
   * @example 123
   */
  id?: number;
  /**
   * @Description 是否为虚拟老师，用于标识该老师是否为虚拟老师
   * 注意：如果是虚拟老师，则需要设置为true，否则为false
   * @example false
   */
  is_virtual?: boolean;
  /**
   * @Description 老师姓名，用于显示和标识。建议与系统中教师姓名保持一致
   * 注意：此字段主要用于显示，系统实际使用ID进行关联
   * @example "张老师"
   */
  name?: string;
  /**
   * @Description 用户ID，用于存储虚拟老师的ID。如果是虚拟老师，此字段存储虚拟老师的ID；如果是普通老师，此字段为空
   * 注意：当is_virtual为true时，此字段必须填写虚拟老师的ID
   * @example "virtual_teacher_001"
   */
  user_id?: string;
}

/** 综合科拆分的请求参数，支持两种方式：1.传入subject_id直接换绑现有科目 2.传入subject_data创建新科目后换绑 */
export interface ExamSplitCompositeSubjectRequest {
  /**
   * 要拆分的考试科目ID
   * @min 1
   * @example 1
   */
  exam_subject_id: number;
  /** 新科目创建数据，与subject_id二选一 */
  subject_data?: {
    /**
     * 是否为固定科目，默认false
     * @example false
     */
    is_fixed?: boolean;
    /**
     * 科目名称，必填，最大50字符
     * @maxLength 50
     * @example "数学"
     */
    name: string;
    /**
     * 学校ID，可选，null表示创建全局科目
     * @example 1
     */
    school_id?: number;
    /** 仅综合科需要，包含的单科ID列表 */
    single_subject_ids?: number[];
    /**
     * 排序号，默认0
     * @min 0
     * @example 1
     */
    sort?: number;
    /**
     * 学科代码，可选，最大20字符
     * @maxLength 20
     * @example "MATH"
     */
    subject_code?: string;
    /**
     * 科目类型，必填，枚举值：单科、综合科、选科
     * @example "单科"
     */
    type: ExamSplitCompositeSubjectRequestTypeEnum;
  };
  /**
   * 现有科目ID，与subject_data二选一
   * @example 2
   */
  subject_id?: number;
}

/** 综合科拆分的响应数据 */
export interface ExamSplitCompositeSubjectResponse {
  /** 操作结果消息 */
  message?: string;
  /** 新创建的科目信息 */
  new_subject?: ModelSubjectResponse;
  /** 原考试科目ID */
  original_exam_subject_id?: number;
  /** 更新后的考试科目信息 */
  updated_exam_subject?: ExamExamSubjectResponse;
}

/** 开始阅卷的请求参数 */
export interface ExamStartGradingRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 科目ID
   * @min 1
   */
  exam_subject_id: number;
}

/** 开始阅卷的响应结果 */
export interface ExamStartGradingResponse {
  /** 考试ID */
  exam_id?: number;
  /** 科目状态 */
  status?: number;
  /** 科目状态名称 */
  status_name?: string;
  /** 科目ID */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
}

export interface ExamStartMarkingTaskRequest {
  /** 考试科目ID */
  exam_subject_id: number;
  /** 模板ID */
  template_id: number;
}

/** 单个学生缺考操作的响应结果 */
export interface ExamStudentAbsentOperationResponse {
  /** 考试ID */
  exam_id?: number;
  /** 学生考号 */
  exam_number?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 缺考状态 */
  is_absent?: boolean;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamStudentMarkingQualityItem {
  /** 总分得分 */
  all_score?: number;
  /** 附加题得分 */
  bonus_score?: number;
  /** 班级 */
  class?: string;
  /** 满分值 */
  full_score?: number;
  /** 年级 */
  grade?: string;
  /** 信息ID */
  info_id?: number;
  /** 客观题得分 */
  objective_score?: number;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 主观题得分 */
  subjective_score?: number;
}

export interface ExamStudentMarkingQuestionResponse {
  /** AI识别题目类型 */
  ai_question_type?: string;
  /** 学生作答内容 */
  answer?: string;
  /** 试卷方向 */
  direction?: string;
  /** 考试编号 */
  exam_number?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 考试科目名称 */
  exam_subject_name?: string;
  /** 最终得分 */
  final_score?: number;
  /** 满分值 */
  full_score?: number;
  /** 半分值 */
  half_score?: number;
  /** 阅卷记录id，也就是record_id */
  id?: number;
  /** 图片完整路径数组 */
  image_urls?: string[];
  /** 阅卷状态,1:已分配（未阅）2：已阅 */
  marking_status?: number;
  /** 教师电话 */
  phone?: string;
  /** 问题卷附属说明 */
  problem_addition?: string;
  /** 问题卷类型 */
  problem_type?: string;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 题目类型 */
  question_type?: string;
  /** 备注 */
  remark?: string;
  /** 扫描答题卡信息ID */
  scan_info_id?: number;
  /** 得分 */
  score?: number;
  /** 标准答案 */
  standard_answer?: string;
  /** 教师姓名 */
  teacher_name?: string;
  /** 关联模板题目ID */
  tpl_question_id?: number;
}

export interface ExamStudentMarkingQuestionsResponse {
  /** 实际返回的题目数量 */
  count?: number;
  /** 题目列表 */
  questions?: ExamStudentMarkingQuestionResponse[];
  /** 任务ID */
  task_id?: number;
}

/** 单个学生的成绩信息 */
export interface ExamStudentScoreItem {
  /** 附加题得分 */
  bonus_score?: number;
  /** 班级名称 */
  class_name?: string;
  /** 考号 */
  exam_number?: string;
  /** 答题卡信息ID */
  info_id?: number;
  /** 客观题得分 */
  objective_score?: number;
  /** 学校名称 */
  school_name?: string;
  /** 学生ID */
  student_id?: number;
  /** 学生姓名 */
  student_name?: string;
  /** 类型：normal/absent */
  student_type?: string;
  /** 主观题得分 */
  subjective_score?: number;
  /** 总成绩 */
  total_score?: number;
}

/** 查询学生成绩列表的请求参数 */
export interface ExamStudentScoreListRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 考试科目ID
   * @min 1
   */
  exam_subject_id: number;
  /**
   * 关键词：学生姓名或考号（筛选条件）
   * @maxLength 50
   */
  keyword?: string;
  /**
   * 分页页码
   * @min 1
   */
  page?: number;
  /**
   * 分页大小
   * @min 1
   * @max 100
   */
  page_size?: number;
  /** 学校ID列表（筛选条件） */
  school_ids?: number[];
  /** 学生类型：all/normal/absent（默认all） */
  student_type?: ExamStudentScoreListRequestStudentTypeEnum;
}

/** 学生成绩列表的响应结果 */
export interface ExamStudentScoreListResponse {
  /** 学生成绩列表 */
  list?: ExamStudentScoreItem[];
  /** 当前页码 */
  page?: number;
  /** 分页大小 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

/** 单个科目的虚拟教师创建信息 */
export interface ExamSubjectCreateInfo {
  /**
   * 新增人数
   * @min 1
   */
  count: number;
  /**
   * 科目ID
   * @min 1
   */
  subject_id: number;
}

export interface ExamSubjectInfo {
  /** 字典键 */
  dictKey?: number;
  /** 字典值 */
  dictValue?: string;
  /** 科目类型：1-单科，2-综合科 */
  subjectType?: number;
}

/** 单个科目的阅卷进度信息 */
export interface ExamSubjectMarkingProgress {
  /** 阅卷进度（百分比） */
  marking_progress?: number;
  /** 阅卷状态 */
  status?: string;
  /** 科目ID */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
}

/** 单个科目的完整统计信息 */
export interface ExamSubjectOverviewStats {
  /** 综合科拆分是否完成 */
  composite_subject_split?: boolean;
  /** 阅卷进度（百分比） */
  marking_progress?: number;
  /** 客观题答案状态：0-全部未完成，1-部分完成，2-全部完成 */
  objective_answer_status?: number;
  /** 问题卷个数 */
  problem_sheet_count?: number;
  /** 已扫描答题卡数量 */
  scanned_sheet_count?: number;
  /** 科目状态 */
  status?: string;
  /** 科目ID */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
  /** 该科目考生人数 */
  subject_student_count?: number;
  /** 该科目阅卷老师人数 */
  subject_teacher_count?: number;
  /** 任务分配是否完成 */
  task_assignment_done?: boolean;
  /** 模版设置是否完成 */
  template_completed?: boolean;
  /** 整场考试考生总数 */
  total_student_count?: number;
  /** 整场考试阅卷老师总数 */
  total_teacher_count?: number;
}

/** 单个科目的扫描进度信息 */
export interface ExamSubjectScanProgress {
  /** 进度显示格式: "0/1000" */
  progress?: string;
  /** 已扫描数 */
  scanned_count?: number;
  /** 科目ID */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
  /** 总数 */
  total_count?: number;
}

/** 单个科目的虚拟教师数量统计 */
export interface ExamSubjectVirtualTeacherCount {
  /** 虚拟教师数量 */
  count?: number;
  /** 考试ID */
  exam_id?: number;
  /** 科目ID */
  subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
}

/** 主观题答案 */
export interface ExamSubjectiveAnswer {
  /** 离线查看地址 */
  away_view_url?: string;
  /** 最终得分 */
  final_score?: number;
  /** 满分 */
  full_score?: number;
  /** 是否标记为优秀 (1:是, 0:否, null:未设置) */
  is_excellent?: number;
  /** 是否标记为典型 (1:是, 0:否, null:未设置) */
  is_model?: number;
  /** 是否标记为问题卷 (1:是, 0:否, null:未设置) */
  is_problem?: number;
  /** 问题卷附属说明 */
  problem_addition?: string;
  /** 问题卷状态 */
  problem_status?: string;
  /** 问题卷类型 */
  problem_type?: string;
  /** 题目ID */
  question_id?: number;
  /** 题目大类 */
  question_major?: string;
  /** 题目小类 */
  question_minor?: string;
  /** 备注 */
  remark?: string;
  /** 标准答案 */
  standard_answer?: string;
  /** 阅卷老师 */
  teacher_name?: string;
}

export interface ExamSubjectiveQualityItem {
  /** 平均分 */
  average_score?: number;
  /** 题目统计列表 */
  question_items?: ExamSubjectiveQuestionItem[];
  /** 总分 */
  total_score?: number;
}

export interface ExamSubjectiveQuestionItem {
  /** 平均分 */
  average_score?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
  /** 总分 */
  total_score?: number;
}

export interface ExamSuspendMarkingRequest {
  /** ID：根据suspend_type不同，传递考试科目ID或题目ID */
  id: number;
  /** 暂停类型：subject-考试科目，question-题目 */
  suspend_type: ExamSuspendMarkingRequestSuspendTypeEnum;
}

export interface ExamSuspendMarkingResponse {
  /** 响应消息 */
  message?: string;
  /** 是否成功 */
  success?: boolean;
}

/** 同步答题卡状态和队列的请求参数 */
export interface ExamSyncAnswerSheetMarkingStatusAndQueueRequest {
  /**
   * 答题卡ID
   * @min 1
   */
  info_id: number;
}

/** 同步考试学生的请求参数 */
export interface ExamSyncExamStudentsRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 是否是选科同步
   * @default false
   */
  is_elective_sync?: boolean;
}

/** 同步考试学生的响应结构 */
export interface ExamSyncExamStudentsResponse {
  /** 删除的原有记录数量 */
  deleted_count?: number;
  /** 失败数量 */
  failed_count?: number;
  /** 失败的学生信息 */
  failed_students?: string[];
  /** 跳过数量（已存在） */
  skipped_count?: number;
  /** 成功同步数量 */
  synced_count?: number;
  /** 同步成功的学生列表 */
  synced_students?: ExamExamStudentResponse[];
  /** 总学生数 */
  total_students?: number;
}

export interface ExamTaskTypeProgressDetail {
  /** 已阅卷数量 */
  marked_quantity?: number;
  /** 学校列表 */
  school_list?: ExamSchoolProgressDetail[];
  /** 任务类型 */
  task_type?: string;
  /** 总数量 */
  total_quantity?: number;
}

/** 老师基本信息 */
export interface ExamTeacherInfo {
  /** 老师ID */
  id?: number;
  /** 姓名 */
  name?: string;
  /** 用户名/账号 */
  username?: string;
}

export interface ExamTeacherMarkingDetail {
  /** 是否在线 */
  is_online?: boolean;
  /** 已阅卷数量 */
  marked_quantity?: number;
  /** 手机号 */
  phone?: string;
  /** 老师ID */
  teacher_id?: number;
  /** 老师姓名 */
  teacher_name?: string;
  /** 总数量 */
  total_quantity?: number;
  /** 用户ID */
  user_id?: string;
}

export interface ExamTeacherMarkingTaskResponse {
  /** 分配方式 */
  allocation_method?: string;
  /** 创建时间 */
  created_time?: string;
  /** 评选方式 */
  evaluate_method?: string;
  /** 考试日期 */
  exam_date?: string;
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 任务ID */
  id?: number;
  /** 序号 */
  index?: number;
  /** 已批阅的数量 */
  marked_quantity?: number;
  /** 待阅数量：初评-效率优先为总剩余量；平均/定量为教师待阅数量 */
  pending_quantity?: number;
  /** 问题卷数量 */
  problem_quantity?: number;
  /** 题目ID */
  question_id?: number;
  /** 科目名称 */
  subject_name?: string;
  /** 任务量 */
  task_quantity?: number;
  /** 任务状态 */
  task_status?: string;
  /** 任务类型 */
  task_type?: string;
  /** 教师ID */
  teacher_id?: number;
  /** 教师姓名 */
  teacher_name?: string;
  /** 教师类型：normal-阅卷老师, arbitration-仲裁老师, leader-组长 */
  teacher_type?: string;
}

export interface ExamTeacherQuestionAverageScoreResponse {
  /** 平均分 */
  average_score?: number;
  /** 题目ID */
  question_id?: number;
  /** 题号主号 */
  question_major?: string;
  /** 题号次号 */
  question_minor?: string;
  /** 已打分记录数 */
  scored_count?: number;
  /** 任务ID */
  task_id?: number;
  /** 教师ID */
  teacher_id?: number;
  /** 教师姓名 */
  teacher_name?: string;
  /** 总记录数 */
  total_count?: number;
}

/** 更新答题详情标记信息请求体 */
export interface ExamUpdateAnswerDetailMarkingRequest {
  /** 答题详情ID */
  id: number;
  /** 是否标记为优秀 (1:是, 0:否, null:未设置) */
  is_excellent?: number;
  /** 是否标记为典型 (1:是, 0:否, null:未设置) */
  is_model?: number;
  /** 是否标记为问题卷 (1:是, 0:否, null:未设置) */
  is_problem?: number;
  /** 问题卷附属说明 */
  problem_addition?: string;
  /** 问题卷类型 */
  problem_type?: string;
  /** 备注 */
  remark?: string;
}

export interface ExamUpdateClientScanAnswerSheetInfoRequest {
  /** AI识别的答题卡JSON数据 */
  ai_answer_sheet_json: string;
  /** 答题卡图片地址（多张正反面） */
  answer_sheet_urls?: string[];
  /** 扫描答题卡详情ID */
  id: number;
}

export interface ExamUpdateClientScanAnswerSheetInfoResponse {
  /** 扫描答题卡详情id */
  id?: number;
  /** 是否上传成功（无任何扫描异常） */
  is_success?: boolean;
  /** 学生考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
}

export interface ExamUpdateExamAdminRequest {
  /**
   * 电话
   * @maxLength 20
   * @example "13800138000"
   */
  phone?: string;
  /**
   * 角色ID
   * @minLength 1
   * @example "1"
   */
  role_id?: string;
  /**
   * 学校ID
   * @min 1
   * @example 1
   */
  school_id?: number;
  /**
   * 科目ID
   * @max 100
   * @example 1
   */
  subject?: number;
  /**
   * 用户ID
   * @minLength 1
   * @example "1"
   */
  teacher_id?: string;
}

/** 更新考试报告发布设置的请求参数 */
export interface ExamUpdateExamReportSettingRequest {
  /** 详细配置 */
  config?: string;
  /**
   * 设置类型
   * @maxLength 50
   */
  setting_type?: string;
}

/** 更新考试的请求参数 */
export interface ExamUpdateExamRequest {
  /**
   * 考试班级列表
   * @minLength 1
   */
  exam_class?: string;
  /** 考试日期，格式：2006-01-02T15:04:05Z */
  exam_date?: string;
  /** 考试年级字典key */
  exam_grade?: string;
  /**
   * 考试名称
   * @minLength 1
   * @maxLength 50
   */
  exam_name?: string;
  /**
   * 综合科目（科目ID，逗号分隔）
   * @maxLength 100
   */
  exam_subject_comprehensive?: string;
  /**
   * 单科考试科目（科目ID，逗号分隔）
   * @maxLength 100
   */
  exam_subject_single?: string;
  /** 考试类型字典key */
  exam_type?: string;
  /** 阅卷方式字典key */
  marking_method?: string;
  /** 扫描方式字典key */
  scan_method?: string;
  /**
   * 学校ID数组
   * @minItems 1
   */
  school_ids?: number[];
}

/** 更新考试学生关联的请求参数 */
export interface ExamUpdateExamStudentRequest {
  /**
   * 班级
   * @maxLength 20
   */
  class?: string;
  /** 班级KEY */
  class_key?: number;
  /**
   * 汇总表id
   * @min 1
   */
  collect_id?: number;
  /**
   * 选考科目（字典）
   * @maxLength 200
   */
  elective_subjects?: string;
  /**
   * 考号
   * @maxLength 50
   */
  exam_number?: string;
  /**
   * 外语项目
   * @maxLength 50
   */
  foreign_language?: string;
  /**
   * 年级
   * @maxLength 20
   */
  grade?: string;
  /** 年级KEY */
  grade_key?: number;
  /** 是否被剔除统计 */
  is_excluded?: boolean;
  /** 是否为补录考生 */
  is_supplemented?: boolean;
  /**
   * 家长姓名
   * @maxLength 50
   */
  parent_name?: string;
  /**
   * 家长电话
   * @maxLength 50
   */
  parent_phone?: string;
  /**
   * 学校ID
   * @min 1
   */
  school_id?: number;
  /**
   * 学籍号
   * @maxLength 50
   */
  student_code?: string;
  /**
   * 学生姓名
   * @maxLength 50
   */
  student_name?: string;
  /**
   * 学号
   * @maxLength 50
   */
  student_number?: string;
  /**
   * 学生标签
   * @maxLength 100
   */
  student_tag?: string;
  /**
   * 系统号
   * @maxLength 50
   */
  system_number?: string;
}

/** 更新考试答题卡模板的请求体 */
export interface ExamUpdateExamSubjectAnswerSheetTemplateRequest {
  /** @minLength 1 */
  ai_template_id: string;
  /** 关联的答题卡ID，当answer_sheet_type为answer_sheet时必填 */
  answer_sheet_id?: number;
  /** 可选，如果提供则使用，否则从raw_info中提取 */
  answer_sheet_images?: string[];
  /** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
  answer_sheet_type: ExamUpdateExamSubjectAnswerSheetTemplateRequestAnswerSheetTypeEnum;
  /** 可选，如果提供则使用，否则从raw_info中提取 */
  exam_no_length?: number;
  /** @min 1 */
  exam_subject_id: number;
  /** @minLength 1 */
  raw_info: string;
  /** @minLength 1 */
  template_name: string;
}

/** 批量修改扫描答题卡归属 */
export interface ExamUpdateScanAnswerSheetRelationRequest {
  exam_id?: number;
  exam_subject_answer_sheet_template_id?: number;
  exam_subject_id?: number;
  scan_answer_sheet_info_ids?: number[];
  school_id?: number;
}

/** 批量更新扫描答题卡信息 */
export interface ExamUpdateScanAnswerSheetsRequest {
  scan_answer_sheet_infos?: ExamScanAnswerSheetInfo[];
  scan_batch_id?: number;
}

export interface ExamUpdateScoreByRecordIDResponse {
  /** 响应消息 */
  message?: string;
  /** 新评分 */
  new_score?: number;
  /** 原评分 */
  old_score?: number;
  /** 题目ID */
  question_id?: number;
  /** 扫描信息ID */
  scan_info_id?: number;
  /** 是否成功 */
  success?: boolean;
  /** 更新时间 */
  updated_at?: string;
}

/** Excel文件解析结果响应 */
export interface ExamUploadExcelResponse {
  /** 错误信息列表 */
  error_messages?: string[];
  /** 无效数据行数 */
  invalid_rows?: number;
  /** 解析出的学生数据 */
  student_data?: ExamExcelStudentData[];
  /** Excel总行数（不含表头） */
  total_rows?: number;
  /** 有效数据行数 */
  valid_rows?: number;
  /** 警告信息列表 */
  warnings?: string[];
}

/** 上传原试卷答案的请求参数 */
export interface ExamUploadPaperAnswerRequest {
  /** 试卷答案路径 */
  paper_answer_url: string;
}

/** 上传原试卷的请求参数 */
export interface ExamUploadPaperRequest {
  /** 原试卷路径 */
  paper_url: string;
}

export interface ExamStatisticsClassAnalysisGroupVO {
  /** 学校ID或班级字典key */
  group_key?: string;
  /** 学校名或班级名 */
  group_name?: string;
  /** 各档次详情 */
  levels?: ExamStatisticsClassLevelDetailVO[];
  /** 该组学生总数 */
  student_count?: number;
}

export interface ExamStatisticsClassAnalysisRequestVO {
  /** 班级字典key列表（class模式时使用） */
  class_ids?: string[];
  /** 考试ID */
  exam_id: number;
  /** 查询模式：school/class */
  query_mode: string;
  /** 学校ID列表（school模式时使用） */
  school_ids?: number[];
}

export interface ExamStatisticsClassAnalysisResponseVO {
  /** 各档次汇总统计 */
  class_levels?: ExamStatisticsClassLevelSummaryVO[];
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 各组分档统计 */
  groups?: ExamStatisticsClassAnalysisGroupVO[];
  /** 总学生数 */
  total_students?: number;
}

export interface ExamStatisticsClassLevelDetailVO {
  /** 累计人数（该档次及以上） */
  cumulative_count?: number;
  /** 累计比例 */
  cumulative_rate?: number;
  /** 档次名称 */
  level?: string;
  /** 临界生数量 */
  marginal_count?: number;
  /** 该档次学生数 */
  student_count?: number;
}

export interface ExamStatisticsClassLevelSummaryVO {
  /** 档次名称：一档、二档、三档 */
  level?: string;
  /** 占总数比例 */
  percentage?: number;
  /** 该档次总人数 */
  total_count?: number;
}

/** 获取重点学生信息列表响应结构 */
export interface ExamStatisticsGetKeyStudentInfoListResponseVO {
  /** 配置列表 */
  items?: ExamStatisticsGetKeyStudentInfoResponseVO[];
  /** 总数 */
  total?: number;
}

/** 获取重点学生信息响应结构 */
export interface ExamStatisticsGetKeyStudentInfoResponseVO {
  business_key?: string;
  param_key?: string;
  setting_content?: string;
  updated_by?: string;
  updated_time?: string;
  version?: number;
}

export interface ExamStatisticsGetSubjectQuestionsResponseVO {
  questions?: ExamStatisticsSubjectQuestionBriefVO[];
}

export interface ExamStatisticsGroupAnalysisResultVO {
  /**
   * 平均分（可选指标）
   * @example 78.5
   */
  average?: number;
  /**
   * 难度和区分度相关指标待后续实现
   * @example 0.65
   */
  difficulty?: number;
  /**
   * 难度描述（可选指标）
   * @example "中等"
   */
  difficulty_desc?: string;
  /**
   * 区分度（可选指标）
   * @example 0.35
   */
  discrimination?: number;
  /**
   * 区分度描述（可选指标）
   * @example "良好"
   */
  discrimination_desc?: string;
  /**
   * 分组标识（班级名/学校名）
   * @example "高三(1)班"
   */
  group_key?: string;
  /**
   * 分组显示名称
   * @example "高三(1)班"
   */
  group_name?: string;
  /**
   * 标准差（可选指标）
   * @example 12.3
   */
  std_dev?: number;
  /**
   * 学生数量
   * @example 45
   */
  student_count?: number;
}

export interface ExamStatisticsGroupQuestionResultVO {
  /**
   * 平均分（可选指标）
   * @example 4.2
   */
  average?: number;
  /**
   * 难度（可选指标）
   * @example 0.84
   */
  difficulty?: number;
  /**
   * 难度描述（可选指标）
   * @example "容易"
   */
  difficulty_desc?: string;
  /**
   * 区分度（可选指标）
   * @example 0.28
   */
  discrimination?: number;
  /**
   * 区分度描述（可选指标）
   * @example "一般"
   */
  discrimination_desc?: string;
  /**
   * 满分人数（可选指标）
   * @example 8
   */
  full_score_count?: number;
  /**
   * 满分人数占比（可选指标）
   * @example 17.8
   */
  full_score_rate?: number;
  /**
   * 分组标识
   * @example "高三(1)班"
   */
  group_key?: string;
  /**
   * 标准差（可选指标）
   * @example 1.1
   */
  std_dev?: number;
  /**
   * 零分人数（可选指标）
   * @example 2
   */
  zero_score_count?: number;
  /**
   * 零分人数占比（可选指标）
   * @example 4.4
   */
  zero_score_rate?: number;
}

export interface ExamStatisticsLevelStatVO {
  /** 人数 */
  count?: number;
  /** 排名 */
  rank?: number;
  /** 比例 */
  rate?: number;
}

export interface ExamStatisticsMarkingRecordItemVO {
  /** 最终得分类型 */
  final_score_source_type?: number;
  /** 评阅记录ID（record_id） */
  id?: number;
  /** 是否优秀 */
  is_excellent?: boolean;
  /** 是否典型 */
  is_model?: boolean;
  /** 是否问题卷 */
  is_problem?: boolean;
  /** 备注 */
  remark?: string;
  /**
   * 分数
   * @example 4.5
   */
  score?: number;
  /**
   * 任务类型：initial-初评 repeat-复评 final-终评 finalscore-最终得分 update_score-修改得分
   * @example "initial"
   */
  task_type?: string;
  /**
   * 评阅教师
   * @example "张三"
   */
  teacher_name?: string;
}

export interface ExamStatisticsObjectiveQuestionItemVO {
  /** 图片URL */
  images?: string[];
  /** 题目和答案 */
  question_and_answers?: ExamStatisticsQuestionAndAnswerItemVO[];
  /**
   * 大题号
   * @example "一"
   */
  question_major?: string;
}

export interface ExamStatisticsQuestionAnalysisRequestVO {
  /** 分析类型 */
  analysis_type: ExamStatisticsQuestionAnalysisRequestVoAnalysisTypeEnum;
  /** 班级字典key列表，当query_mode=class时必填 */
  class_ids?: string[];
  /**
   * 是否启用对比功能，true时返回各分组的对比数据
   * @example false
   */
  enable_comparison?: boolean;
  /**
   * 考试ID，必填
   * @min 1
   */
  exam_id: number;
  /**
   * 指标列表
   * @minItems 1
   */
  indicators: string[];
  /** 查询模式：class(按班级), school(按学校，用于联考) */
  query_mode: ExamStatisticsQuestionAnalysisRequestVoQueryModeEnum;
  /** 题目筛选参数（可选） */
  question_keyword?: string;
  /** 角色标识，用于权限过滤 */
  role_key?: number;
  /** 学校ID列表，当query_mode=school时必填 */
  school_ids?: number[];
  /**
   * 学科ID，必填，只接受单科
   * @min 1
   */
  subject_id: number;
  /** 教师权限参数（可选） */
  teacher_id?: number;
}

export interface ExamStatisticsQuestionAnalysisResponseVO {
  /**
   * 分析类型
   * @example "question"
   */
  analysis_type?: string;
  /**
   * 是否启用对比
   * @example false
   */
  enable_comparison?: boolean;
  /** 各组分析结果（仅当enable_comparison=true时返回） */
  groups?: ExamStatisticsGroupAnalysisResultVO[];
  /** 题目分析结果 */
  questions?: ExamStatisticsQuestionAnalysisResultVO[];
  /**
   * 参与统计的学生总数
   * @example 150
   */
  student_count?: number;
}

export interface ExamStatisticsQuestionAnalysisResultVO {
  /**
   * 新增统计指标
   * @example 86.5
   */
  accuracy_rate?: number;
  /**
   * 整体统计（所有筛选范围内的学生的统计）
   * @example 4.2
   */
  average?: number;
  /**
   * 正确答案（可选指标）
   * @example "A"
   */
  correct_answer?: string;
  /**
   * 难度（可选指标）
   * @example 0.84
   */
  difficulty?: number;
  /**
   * 难度描述（可选指标）
   * @example "容易"
   */
  difficulty_desc?: string;
  /**
   * 区分度（可选指标）
   * @example 0.28
   */
  discrimination?: number;
  /**
   * 区分度描述（可选指标）
   * @example "一般"
   */
  discrimination_desc?: string;
  /**
   * 满分人数（可选指标）
   * @example 23
   */
  full_score_count?: number;
  /**
   * 满分人数占比（可选指标）
   * @example 15.3
   */
  full_score_rate?: number;
  /** 分组对比数据（仅当enable_comparison=true时返回） */
  group_results?: ExamStatisticsGroupQuestionResultVO[];
  /**
   * 满分
   * @example 5
   */
  max_score?: number;
  /** 选项统计（可选指标，仅客观题） */
  option_statistics?: ExamStatisticsQuestionAnswerStatsVO;
  /**
   * 题目标识
   * @example "q_1_1"
   */
  question_key?: string;
  /**
   * 题目名称
   * @example "一.1"
   */
  question_name?: string;
  /**
   * 题目类型：客观题/主观题
   * @example "客观题"
   */
  question_type?: string;
  /**
   * 标准差（可选指标）
   * @example 1.1
   */
  std_dev?: number;
  /**
   * 零分率（可选指标，等同于零分人数占比）
   * @example 3.3
   */
  zero_rate?: number;
  /**
   * 零分人数（可选指标）
   * @example 5
   */
  zero_score_count?: number;
  /**
   * 零分人数占比（可选指标）
   * @example 3.3
   */
  zero_score_rate?: number;
}

export interface ExamStatisticsQuestionAndAnswerItemVO {
  /** 学生作答内容 */
  answer?: string;
  /** 答题卡题目详情id */
  id?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
}

export interface ExamStatisticsQuestionAnswerStatsVO {
  /** A选项人数 */
  option_a?: number;
  /** B选项人数 */
  option_b?: number;
  /** C选项人数 */
  option_c?: number;
  /** D选项人数 */
  option_d?: number;
}

export interface ExamStatisticsQuestionDetailVO {
  /**
   * 作答显示格式：作答/答案
   * @example "作答A/答案A"
   */
  answer_display?: string;
  /**
   * 正确答案
   * @example "A"
   */
  correct_answer?: string;
  /**
   * 满分
   * @example 2
   */
  max_score?: number;
  /**
   * 题目ID
   * @example 1
   */
  question_id?: number;
  /**
   * 题目名称，如：客|一.1, 主|2.2
   * @example "客|一.1"
   */
  question_name?: string;
  /**
   * 题目顺序
   * @example 1
   */
  question_order?: number;
  /**
   * 题目类型：objective(客观题), subjective(主观题)
   * @example "objective"
   */
  question_type?: string;
  /**
   * 得分
   * @example 1.5
   */
  score?: number;
  /**
   * 得分显示格式：得分/满分
   * @example "1.5/2分"
   */
  score_display?: string;
  /**
   * 学生作答
   * @example "A"
   */
  student_answer?: string;
}

export interface ExamStatisticsQuestionExcelExportRequestVO {
  /** 班级字典key列表，当query_mode=class时必填 */
  class_ids?: string[];
  /**
   * 考试ID，必填
   * @min 1
   */
  exam_id: number;
  /**
   * 指标列表
   * @minItems 1
   */
  indicators: string[];
  /**
   * 页码，默认1
   * @min 1
   * @example 1
   */
  page?: number;
  /**
   * 每页数量，默认50
   * @min 1
   * @example 50
   */
  page_size?: number;
  /** 查询模式：class(按班级), school(按学校，用于联考) */
  query_mode: ExamStatisticsQuestionExcelExportRequestVoQueryModeEnum;
  /** 角色标识，用于权限过滤 */
  role_key?: number;
  /** 学校ID列表，当query_mode=school时必填 */
  school_ids?: number[];
  /** 搜索关键词（支持学生姓名、学号、考号、系统号搜索） */
  search_keyword?: string;
  /**
   * 学科ID，必填
   * @min 1
   */
  subject_id: number;
  /** 教师权限参数（可选） */
  teacher_id?: number;
}

export interface ExamStatisticsQuestionRankingRequestVO {
  /** 班级字典key列表，当query_mode=class时必填 */
  class_ids?: string[];
  /**
   * 考试ID，必填
   * @min 1
   */
  exam_id: number;
  /**
   * 指标列表
   * @minItems 1
   */
  indicators: string[];
  /**
   * 页码，默认1
   * @min 1
   * @example 1
   */
  page?: number;
  /**
   * 每页数量，默认50
   * @min 1
   * @example 50
   */
  page_size?: number;
  /** 查询模式：class(按班级), school(按学校，用于联考) */
  query_mode: ExamStatisticsQuestionRankingRequestVoQueryModeEnum;
  /** 角色标识，用于权限过滤 */
  role_key?: number;
  /** 学校ID列表，当query_mode=school时必填 */
  school_ids?: number[];
  /** 搜索关键词（支持学生姓名、学号、考号、系统号搜索） */
  search_keyword?: string;
  /**
   * 学科ID，必填
   * @min 1
   */
  subject_id: number;
  /** 教师权限参数（可选） */
  teacher_id?: number;
}

export interface ExamStatisticsQuestionRankingResponseVO {
  /** 学生成绩列表 */
  list?: ExamStatisticsStudentQuestionScoreInfoVO[];
  /**
   * 当前页码
   * @example 1
   */
  page?: number;
  /**
   * 每页数量
   * @example 50
   */
  page_size?: number;
  /**
   * 总学生数
   * @example 170
   */
  total?: number;
}

export interface ExamStatisticsScoreAnalysisItemVO {
  /** 超均率 */
  above_avg_rate?: number;
  /** 基础统计指标 */
  average?: number;
  /** 比率指标 */
  average_score_rate?: number;
  /** 综合率 */
  comprehensive?: number;
  /** 离均差 */
  deviation_rate?: number;
  /** 报考人数 */
  exam_count?: number;
  /** 优秀 */
  excellent?: ExamStatisticsLevelStatVO;
  /** 良好 */
  good?: ExamStatisticsLevelStatVO;
  /** 等级统计 */
  high_score?: ExamStatisticsLevelStatVO;
  /** 低分 */
  low_score?: ExamStatisticsLevelStatVO;
  /** 最高分 */
  max_score?: number;
  /** 中位数 */
  median?: number;
  /** 最低分 */
  min_score?: number;
  /** 众数 */
  mode?: number;
  /** 学校名或班级名 */
  name?: string;
  /** 及格率 */
  pass_rate?: number;
  /** 及格 */
  qualified?: ExamStatisticsLevelStatVO;
  /** 排名 */
  rank?: number;
  /** 标准分 */
  standard_score?: number;
  /** 标准差 */
  std_dev?: number;
  /** 学生人数 */
  student_count?: number;
  /** 教学相关（仅班级维度） */
  teacher?: string;
  /** 比均率 */
  vs_avg_rate?: number;
}

export interface ExamStatisticsScoreAnalysisRequestVO {
  /** 班级字典key列表（class模式时必填） */
  class_ids?: string[];
  /** 考试ID */
  exam_id: number;
  filters?: {
    /** 是否排除缺考X门科目的学生（仅总分时有效） */
    exclude_missing_subjects?: boolean;
    /** 是否包含0分学生 */
    include_zero_score?: boolean;
    /** 缺考门数限制，默认1门 */
    missing_subject_limit?: number;
  };
  /** 需要的指标列表 */
  indicators: string[];
  /** 查询模式：school/class */
  query_mode: string;
  /** 角色标识，用于权限过滤 */
  role_key?: number;
  /** 学校ID列表（school模式时必填） */
  school_ids?: number[];
  /** 科目ID，0表示总分 */
  subject_id?: number;
  /** 教师权限参数（可选） */
  teacher_id?: number;
}

export interface ExamStatisticsScoreAnalysisResponseVO {
  data?: ExamStatisticsScoreAnalysisItemVO[];
  exam_id?: number;
  query_mode?: string;
}

export interface ExamStatisticsScoreConvertConfigResponseVO {
  /** 恒为1 */
  default_factor?: number;
  exam_id?: number;
  exam_subject_id?: number;
  /** 仅返回已配置（系数!=1）的题目，按题目顺序 */
  rules?: ExamStatisticsScoreConvertRuleVO[];
  /** 便于前端回显，按顺序合并的区间（同系数且相邻） */
  segments?: ExamStatisticsScoreConvertSegmentVO[];
}

export interface ExamStatisticsScoreConvertRuleVO {
  coefficient?: number;
  question_id?: number;
}

export interface ExamStatisticsScoreConvertSaveRequestVO {
  exam_id: number;
  exam_subject_id: number;
  /** OverlapStrategy 可选：override(默认) 或 error */
  overlap_strategy?: string;
  /** @minItems 1 */
  segments: ExamStatisticsScoreConvertSegmentVO[];
}

export interface ExamStatisticsScoreConvertSaveResponseVO {
  exam_id?: number;
  exam_subject_id?: number;
  mapped_question_count?: number;
  updated_student_count?: number;
}

export interface ExamStatisticsScoreConvertSegmentVO {
  coefficient: number;
  end_question_id: number;
  start_question_id: number;
}

export interface ExamStatisticsScoreDetailVO {
  /**
   * 赋分（可选指标）
   * @example 98.2
   */
  assigned_score?: number;
  /**
   * 班级排名（可选指标）
   * @example 3
   */
  class_rank?: number;
  /**
   * 选科组合联考排名（可选指标）
   * @example 18
   */
  combo_joint_exam_rank?: number;
  /**
   * 选科组合排名指标
   * @example 8
   */
  combo_school_rank?: number;
  /**
   * 选考方向班级排名（可选指标）
   * @example 2
   */
  direction_class_rank?: number;
  /**
   * 选考方向排名指标
   * @example 12
   */
  direction_grade_rank?: number;
  /**
   * 选考方向联考排名（可选指标）
   * @example 25
   */
  direction_joint_exam_rank?: number;
  /**
   * 排名指标
   * @example 15
   */
  grade_rank?: number;
  /**
   * 联考排名（可选指标）
   * @example 28
   */
  joint_exam_rank?: number;
  /**
   * 等级（可选指标）
   * @example "A"
   */
  level?: string;
  /**
   * 扫描信息ID
   * @example 2819
   */
  scan_info_id?: number;
  /**
   * 基础指标（属于学科的指标）
   * @example 95.5
   */
  score?: number;
  /**
   * 科目ID（总分时为0）
   * @example 1
   */
  subject_id?: number;
  /**
   * 科目名称（总分时为"总分"）
   * @example "数学"
   */
  subject_name?: string;
}

/** 成绩排名查询请求参数，支持按班级、学科、指标筛选，支持联考模式 */
export interface ExamStatisticsScoreRankingRequestVO {
  /** 筛选条件（根据query_mode选择使用） */
  class_ids?: string[];
  /**
   * 考试ID，必填
   * @min 1
   */
  exam_id: number;
  /**
   * 学科选择：
   * @example true
   */
  include_total_score?: boolean;
  /**
   * 指标选择
   * @minItems 1
   */
  indicators: string[];
  /**
   * 分页参数
   * @min 1
   * @example 1
   */
  page?: number;
  /**
   * 每页数量，默认50
   * @min 1
   * @example 50
   */
  page_size?: number;
  /** 查询模式：class(按班级), school(按学校，用于联考) */
  query_mode: ExamStatisticsScoreRankingRequestVoQueryModeEnum;
  /** 角色标识，用于权限过滤 */
  role_key?: number;
  /** 学校ID列表，当query_mode=school时必填 */
  school_ids?: number[];
  /** 搜索参数 */
  search_keyword?: string;
  /** 考试科目ID列表，多选 */
  subject_ids?: number[];
  /** 教师权限参数（可选） */
  teacher_id?: number;
}

export interface ExamStatisticsScoreRankingResponseVO {
  /** 学生成绩列表 */
  list?: ExamStatisticsStudentScoreInfoVO[];
  /**
   * 当前页码
   * @example 1
   */
  page?: number;
  /**
   * 每页数量
   * @example 50
   */
  page_size?: number;
  /**
   * 总学生数
   * @example 170
   */
  total?: number;
}

/** 设置重点学生信息的请求参数 */
export interface ExamStatisticsSetKeyStudentInfoRequestVO {
  /** 业务主键 */
  business_key: string;
  /** 参数主键 */
  param_key: string;
  /** 设置内容 */
  setting_content: string;
}

/** 设置重点学生信息响应结构 */
export interface ExamStatisticsSetKeyStudentInfoResponseVO {
  data?: {
    business_key?: string;
    param_key?: string;
    updated_by?: string;
    updated_time?: string;
    version?: number;
  };
  message?: string;
  success?: boolean;
}

export interface ExamStatisticsSetLevelConfigRequestVO {
  config_data: ExamStatisticsUnifiedConfigDataVO;
  config_type: string;
  exam_id: number;
  /** 要设置的科目ID列表 */
  subject_ids: number[];
}

export interface ExamStatisticsSetLevelConfigResponseVO {
  data?: {
    config_type?: string;
    exam_id?: number;
    subject_ids?: number[];
  };
  message?: string;
  success?: boolean;
}

export interface ExamStatisticsStatisticsAnalysisItemVO {
  /** 学校ID或班级ID */
  id?: number;
  /** 学校名或班级名 */
  name?: string;
  /** 统计详情 */
  statistics?: ExamStatisticsStatisticsDetailItemVO[];
  /** 总学生人数 */
  student_count?: number;
}

export interface ExamStatisticsStatisticsAnalysisRequestVO {
  /** 分析类型：rank/score/percentile */
  analysis_type: string;
  /** 班级字典key列表（class模式时使用） */
  class_ids?: string[];
  /** 考试ID */
  exam_id: number;
  /** 查询模式：school/class */
  query_mode: string;
  /** 角色标识，用于权限过滤 */
  role_key?: number;
  /** 学校ID列表（school模式时使用） */
  school_ids?: number[];
  /** 科目ID，0表示总分 */
  subject_id?: number;
  /** 教师权限参数（可选） */
  teacher_id?: number;
}

export interface ExamStatisticsStatisticsAnalysisResponseVO {
  analysis_type?: string;
  data?: ExamStatisticsStatisticsAnalysisItemVO[];
  exam_id?: number;
  query_mode?: string;
  subject_id?: number;
}

export interface ExamStatisticsStatisticsDetailItemVO {
  /** 学生人数 */
  count?: number;
  /** 结束百分比 */
  end_percent?: number;
  /** 结束名次 */
  end_rank?: number;
  /** 统计项名称（如"前10名"/"≥500分"/"前0%-10%"） */
  name?: string;
  /** 占比 */
  rate?: number;
  /** 分数区间（如"116-129"） */
  score_range?: string;
  /** 比例段统计专用 */
  start_percent?: number;
  /** 名次统计专用 */
  start_rank?: number;
  /** 分数段统计专用 */
  threshold?: number;
}

export interface ExamStatisticsStudentAnswerSheetQuestionsRequestVO {
  /**
   * 考试ID，必填
   * @min 1
   */
  exam_id: number;
  /** 考号，必填 */
  exam_number: string;
  /**
   * 考试科目ID，必填
   * @min 1
   */
  exam_subject_id: number;
}

export interface ExamStatisticsStudentAnswerSheetQuestionsResponseVO {
  /** 客观题 */
  objective_questions?: ExamStatisticsObjectiveQuestionItemVO[];
  /** ai答题卡原始数据 */
  raw_json?: string;
  /**
   * 扫描答题卡id
   * @example 1
   */
  scan_info_id?: number;
  /** 主观题 */
  subjective_questions?: ExamStatisticsSubjectiveQuestionItemVO[];
  /** 模板原始数据 */
  template_raw_json?: string;
}

export interface ExamStatisticsStudentQuestionScoreInfoVO {
  /** 班级名称 */
  class_name?: string;
  /**
   * 班级排名
   * @example 3
   */
  class_rank?: number;
  /** 考号（可选指标） */
  exam_number?: string;
  /**
   * 排名（可选指标）
   * @example 15
   */
  grade_rank?: number;
  /**
   * 联考排名
   * @example 28
   */
  joint_exam_rank?: number;
  /**
   * 客观题总分
   * @example 45
   */
  objective_score?: number;
  /** 题目详情 map[questionKey]*QuestionDetail */
  question_scores?: Record<string, ExamStatisticsQuestionDetailVO>;
  /** 扫描信息ID */
  scan_info_id?: number;
  /** 学校名称 */
  school_name?: string;
  /** 学生ID */
  student_id?: number;
  /** 学生姓名 */
  student_name?: string;
  /** 学号（可选指标） */
  student_number?: string;
  /**
   * 主观题总分
   * @example 50.5
   */
  subjective_score?: number;
  /** 系统号（可选指标） */
  system_number?: string;
  /**
   * 总分统计（可选指标）
   * @example 95.5
   */
  total_score?: number;
}

export interface ExamStatisticsStudentScoreInfoVO {
  /** 语数外史/物总分相关（当需要语数外史/物排名时返回） */
  chinese_mat_eng_direction_score?: ExamStatisticsScoreDetailVO;
  /** 语数外总分相关（当需要语数外排名时返回） */
  chinese_mat_eng_score?: ExamStatisticsScoreDetailVO;
  /**
   * 班级名称
   * @example "高三(1)班"
   */
  class_name?: string;
  /**
   * 选考方向（可选指标）
   * @example "物理方向"
   */
  elective_direction?: string;
  /**
   * 考号（可选指标）
   * @example "202401001"
   */
  exam_number?: string;
  /**
   * 等级统计（可选指标）
   * @example "A[3A1B]"
   */
  level_stats?: string;
  /**
   * 学校名称
   * @example "第一中学"
   */
  school_name?: string;
  /**
   * 学生姓名
   * @example "张三"
   */
  student_name?: string;
  /**
   * 学号（可选指标）
   * @example "20240001"
   */
  student_number?: string;
  /**
   * 选考组合（可选指标）
   * @example "物理+化学+生物"
   */
  subject_combo?: string;
  /**
   * 选考组合名称
   * @example "物理+化学+生物"
   */
  subject_combo_name?: string;
  /** 各科目成绩（根据选择的subject_ids返回） */
  subject_scores?: Record<string, ExamStatisticsScoreDetailVO>;
  /**
   * 系统号（可选指标）
   * @example "SYS001"
   */
  system_number?: string;
  /**
   * 标签（可选指标）
   * @example "优秀生"
   */
  tags?: string;
  /** 总分相关（当include_total_score为true时返回） */
  total_score?: ExamStatisticsScoreDetailVO;
}

export interface ExamStatisticsSubjectAnalysisDetailVO {
  /** 学科满分 */
  full_score?: number;
  /** 该档次该学科分数线 */
  score_line?: number;
  /** 学科ID */
  subject_id?: string;
  /** 学科名称 */
  subject_name?: string;
  /** 该学科总贡献率 */
  total_contribution_rate?: number;
  /** 该学科总双上线人数 */
  total_double_online_count?: number;
  /** 该学科总命中率 */
  total_hit_rate?: number;
  /** 该学科总上线人数 */
  total_online_count?: number;
}

export interface ExamStatisticsSubjectClassAnalysisExcelExportRequestVO {
  /** 班级字典key列表（class模式时使用） */
  class_ids?: string[];
  /** 考试ID */
  exam_id: number;
  /**
   * 文件名，可选
   * @example "学科分档分析表"
   */
  file_name?: string;
  /** 档次级别（如"一档"、"二档"、"三档"） */
  level: string;
  /** 查询模式：school/class */
  query_mode: string;
  /** 学校ID列表（school模式时使用） */
  school_ids?: number[];
}

export interface ExamStatisticsSubjectClassAnalysisGroupVO {
  /** 学校ID或班级字典key */
  group_key?: string;
  /** 学校名或班级名 */
  group_name?: string;
  /** 该组学生总数 */
  student_count?: number;
  /** 各学科统计 */
  subjects?: ExamStatisticsSubjectGroupAnalysisItemVO[];
}

export interface ExamStatisticsSubjectClassAnalysisRequestVO {
  /** 班级字典key列表（class模式时使用） */
  class_ids?: string[];
  /** 考试ID */
  exam_id: number;
  /** 档次级别（如"一档"、"二档"、"三档"） */
  level: string;
  /** 查询模式：school/class */
  query_mode: string;
  /** 学校ID列表（school模式时使用） */
  school_ids?: number[];
}

export interface ExamStatisticsSubjectClassAnalysisResponseVO {
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 各组学科分档统计 */
  groups?: ExamStatisticsSubjectClassAnalysisGroupVO[];
  /** 当前查询的档次 */
  level?: string;
  /** 各学科汇总统计 */
  subjects?: ExamStatisticsSubjectAnalysisDetailVO[];
  /** 总分档次信息 */
  total_score_info?: ExamStatisticsTotalScoreInfoVO;
  /** 总学生数 */
  total_students?: number;
}

export interface ExamStatisticsSubjectGroupAnalysisItemVO {
  /** 命中率 */
  contrib_rate?: number;
  /** 双上线 */
  double_online?: number;
  /** 贡献率 */
  pass_rate?: number;
  /** 单科上线 */
  single_online?: number;
  /** 上线人数 */
  student_count?: number;
  /** 科目名称 */
  subject_name?: string;
}

export interface ExamStatisticsSubjectQuestionBriefVO {
  /** 满分 */
  full_score?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major?: string;
  /** 小题号 */
  question_minor?: string;
}

export interface ExamStatisticsSubjectiveQuestionItemVO {
  /**
   * 是否能修改得分
   * @example true
   */
  can_modify_score?: boolean;
  /** 图片URL */
  images?: string[];
  /** 评阅记录 */
  marking_records?: ExamStatisticsMarkingRecordItemVO[];
  /** 题目ID */
  question_id?: number;
  /**
   * 大题号
   * @example "二"
   */
  question_major?: string;
  /**
   * 小题号
   * @example "1"
   */
  question_minor?: string;
}

export interface ExamStatisticsTotalScoreInfoVO {
  /** 总分满分 */
  full_score?: number;
  /** 该档次总分上线人数 */
  online_count?: number;
  /** 该档次总分分数线 */
  score_line?: number;
}

export interface ExamStatisticsUnifiedConfigDataVO {
  /** 额外配置（用于特殊配置类型） */
  extra_config?: Record<string, any>;
  /** 等级数量 */
  level_count?: number;
  /** 等级配置列表 */
  levels?: ExamStatisticsUnifiedLevelItemVO[];
  /** 规则类型 */
  rule_type?: string;
}

export interface ExamStatisticsUnifiedLevelItemVO {
  /** 描述 */
  description?: string;
  /** 等级名称 A/B/C/D/E 或 优秀/良好等 */
  level?: string;
  /** 排序 */
  order?: number;
  /** 范围最大值 */
  range_max?: number;
  /** 范围最小值 */
  range_min?: number;
  /** 单一值（百分比/分数等） */
  value?: number;
}

export interface ExamStatisticsUpdateStudentObjectiveQuestionRequestVO {
  /** 答题卡ID */
  id: number;
  /** 异常题或者全部题列表 */
  list: ExamStatisticsUpdateStudentObjectiveQuestionRequestVOItem[];
}

export interface ExamStatisticsUpdateStudentObjectiveQuestionRequestVOItem {
  /** 更正的答案 */
  answer: string;
  /** 答题卡题目详情id */
  id: number;
}

export interface FileServiceBatchFileUploadResponseVO {
  /** 失败的错误信息列表 */
  errors?: string[];
  /** 失败的文件数量 */
  failed_count?: number;
  /** 成功上传的文件列表 */
  files?: FileServiceFileResponseVO[];
  /** 成功上传的文件数量 */
  success_count?: number;
}

export interface FileServiceFileInfoVO {
  created_at?: string;
  /** 文件扩展名 */
  extension?: string;
  /** 原始文件名 */
  filename?: string;
  /** 文件哈希值 */
  hash?: string;
  id?: number;
  /** MIME类型 */
  mime_type?: string;
  /** 文件大小 */
  size?: number;
  /** 文件状态：active, deleted */
  status?: string;
  /** 存储文件名 */
  storage_name?: string;
  /** 存储类型：local, s3, oss等 */
  storage_type?: string;
  updated_at?: string;
  /** 上传者名称 */
  uploader?: string;
  /** 上传者ID */
  uploader_id?: number;
  /** 文件访问URL */
  url?: string;
}

export interface FileServiceFileListResponseVO {
  files?: FileServiceFileResponseVO[];
  page?: number;
  page_size?: number;
  pages?: number;
  total?: number;
}

export interface FileServiceFileResponseVO {
  created_at?: string;
  extension?: string;
  filename?: string;
  hash?: string;
  id?: number;
  mime_type?: string;
  size?: number;
  status?: string;
  storage_name?: string;
  storage_type?: string;
  updated_at?: string;
  uploader?: string;
  uploader_id?: number;
  url?: string;
}

export interface FileServiceFileStatsVO {
  active_files?: number;
  deleted_files?: number;
  month_uploads?: number;
  today_uploads?: number;
  total_files?: number;
  total_size?: number;
  week_uploads?: number;
}

export interface MessageQueueMessageVO {
  /** 创建时间 */
  created_at?: string;
  /** 消息数据 */
  data?: Record<string, any>;
  /** 过期时间 */
  expires_at?: string;
  /** 消息头 */
  headers?: Record<string, string>;
  /** 消息ID */
  id?: string;
  /** 最大重试次数 */
  max_retries?: number;
  /** 优先级 (0-9, 0最高) */
  priority?: number;
  /** 处理时间 */
  processed_at?: string;
  /** 重试次数 */
  retry_count?: number;
  /** 消息状态 */
  status?: MessageQueueMessageVOStatus;
  /** 主题 */
  topic?: string;
}

export enum MessageQueueMessageVOStatus {
  MessageStatusPending = 'pending',
  MessageStatusProcessing = 'processing',
  MessageStatusCompleted = 'completed',
  MessageStatusFailed = 'failed',
  MessageStatusRetry = 'retry',
  MessageStatusExpired = 'expired'
}

export interface MessageQueueQueueStatsVO {
  /** 已完成消息数 */
  completed_messages?: number;
  /** 消费者数量 */
  consumers?: number;
  /** 过期消息数 */
  expired_messages?: number;
  /** 失败消息数 */
  failed_messages?: number;
  /** 待处理消息数 */
  pending_messages?: number;
  /** 处理中消息数 */
  processing_messages?: number;
  /** 重试消息数 */
  retry_messages?: number;
  /** 主题数量 */
  topics?: number;
  /** 总消息数 */
  total_messages?: number;
}

export interface ModelAnswerSheet {
  component_id?: string;
  component_info?: string;
  created_by?: string;
  created_id?: string;
  created_time?: string;
  id?: number;
  image_url?: string;
  is_deleted?: number;
  is_enable?: number;
  is_shared?: boolean;
  name?: string;
  pdf_url?: string;
  recognition_info?: string;
  schools?: string;
  tpl_url?: string;
  updated_by?: string;
  updated_time?: string;
}

/** 分配菜单的请求参数 */
export interface ModelAssignMenuRequest {
  /**
   * 菜单ID列表（逗号分隔）
   * @example "1,2,3"
   */
  menu_ids: string;
}

/** 分配角色的请求参数 */
export interface ModelAssignSysRoleRequest {
  /**
   * 角色ID列表
   * @example [1,2]
   */
  role_ids: number[];
}

/** 管理员直接修改用户密码 */
export interface ModelChangePasswordRequest {
  /**
   * @minLength 6
   * @example "newpassword"
   */
  new_password: string;
}

/** 修改学生密码的请求参数 */
export interface ModelChangeStudentPasswordRequest {
  /**
   * 新密码
   * @minLength 6
   * @example "newpassword"
   */
  new_password: string;
}

/** 修改教师密码的请求参数 */
export interface ModelChangeTeacherPasswordRequest {
  /**
   * 新密码
   * @minLength 6
   * @example "newpassword"
   */
  new_password: string;
}

/** 班级平均分走势信息 */
export interface ModelClassScoreInfo {
  /** 平均分数组 */
  average_scores?: number[];
  /** 班级名称 */
  class?: string;
  /** 班级KEY */
  class_key?: number;
  /** 年级KEY */
  grade_key?: number;
}

/** 班级学生成绩信息 */
export interface ModelClassStudentScoreInfo {
  /** 总得分 */
  all_score?: number;
  /** 班级排名变化方向 */
  class_diff_direction?: string;
  /** 班级排名变化 */
  class_diff_rank?: number;
  /** 班级排名 */
  class_rank?: number;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 总分 */
  full_score?: number;
  /** 年级排名变化方向 */
  grade_diff_direction?: string;
  /** 年级排名变化 */
  grade_diff_rank?: number;
  /** 年级排名 */
  grade_rank?: number;
  /** 是否缺考 */
  is_absent?: boolean;
  /** 学生考试号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 学生学号 */
  student_number?: string;
  /** 科目ID */
  subject_id?: number;
}

export interface ModelCreateDownloadSessionRequest {
  /** 切片大小 */
  chunk_size: number;
  /** 文件ID */
  file_id: number;
}

/** 创建成绩分析设置的请求参数 */
export interface ModelCreateExamAnalysisSettingRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 多个考试科目ID，逗号分隔（新） */
  exam_subject_ids?: string;
  /** 是否去掉缺考一门以上学生 */
  exclude_absent_students?: boolean;
  /** 排除的班级ID列表，逗号分隔 */
  excluded_classes?: string;
  /** 排除条件设置 */
  excluded_schools?: string;
  /** 排除的学生标签列表，逗号分隔 */
  excluded_student_tags?: string;
  /** 考生筛选条件 */
  min_total_score?: number;
  /**
   * 取各班级总分前x%的学生
   * @min 1
   * @max 100
   */
  top_class_percent?: number;
  /**
   * 取各学科均在前x%的学生
   * @min 1
   * @max 100
   */
  top_subject_percent?: number;
  /**
   * 考生范围筛选
   * @min 1
   * @max 100
   */
  top_total_percent?: number;
  /** 权限设置 */
  visibility: ModelCreateExamAnalysisSettingRequestVisibilityEnum;
}

export interface ModelCreateExamMarkingSettingRequest {
  /** AI识别模板ID */
  ai_template_id: string;
  /** 答题卡组件信息 */
  component_info?: string;
  /** 考试ID */
  exam_id: number;
  exam_subject_id?: number;
  /** 答题卡图片模版ID */
  image_url?: string;
  /** 答题卡AI识别信息 */
  recognition_info?: string;
  /** 考试科目答题卡模板ID */
  template_id: string;
  /** 题目设置列表 */
  topics?: ModelCreateExamMarkingSettingTopicRequest[];
}

export interface ModelCreateExamMarkingSettingTopicRequest {
  /** 排序权重 */
  order?: number;
  /** 题目ID */
  question_id?: number;
  /** 大题号 */
  question_major: string;
  /** 小题号 */
  question_minor: string;
  /** 题目类型 */
  question_type: string;
  /** 打分模式 */
  scoring_mode: string;
}

/** 创建学生的请求参数 */
export interface ModelCreateStudentRequest {
  /**
   * 班级
   * @example "1班"
   */
  class: string;
  /**
   * 班级Key
   * @example 1
   */
  class_key?: number;
  /** 学籍号 */
  code?: string;
  /**
   * 考号
   * @example "2024001001"
   */
  exam_number: string;
  /**
   * 选考科目
   * @example "物理,化学"
   */
  exam_subject?: string;
  /**
   * 外语科目
   * @example "英语"
   */
  foreign_language_subject?: string;
  /**
   * 年级
   * @example "高一"
   */
  grade: string;
  /**
   * 年级Key
   * @example 1
   */
  grade_key: number;
  /**
   * 标签
   * @example "优秀"
   */
  label?: string;
  /**
   * 姓名
   * @example "张三"
   */
  name: string;
  /** 学号 */
  number?: string;
  /**
   * 家长姓名
   * @example "张父"
   */
  parent_name?: string;
  /**
   * 家长电话
   * @example "13800138000"
   */
  parent_telphone?: string;
}

/** 创建科目的请求参数，包含科目基本信息和类型相关配置 */
export interface ModelCreateSubjectRequest {
  /**
   * 是否为固定科目，默认false
   * @example false
   */
  is_fixed?: boolean;
  /**
   * 科目名称，必填，最大50字符
   * @maxLength 50
   * @example "数学"
   */
  name: string;
  /**
   * 学校ID，可选，null表示创建全局科目
   * @example 1
   */
  school_id?: number;
  /** 仅综合科需要，包含的单科ID列表 */
  single_subject_ids?: number[];
  /**
   * 排序号，默认0
   * @min 0
   * @example 1
   */
  sort?: number;
  /**
   * 学科代码，可选，最大20字符
   * @maxLength 20
   * @example "MATH"
   */
  subject_code?: string;
  /**
   * 科目类型，必填，枚举值：单科、综合科、选科
   * @example "单科"
   */
  type: ModelCreateSubjectRequestTypeEnum;
}

/** 创建菜单的请求参数 */
export interface ModelCreateSysMenuRequest {
  /**
   * 组件地址
   * @example "UserManagement"
   */
  component?: string;
  /**
   * 菜单图标
   * @example "user"
   */
  icon?: string;
  /**
   * 元数据信息
   * @example "{"title":"用户管理","hidden":false}"
   */
  meta?: string;
  /**
   * 菜单名称
   * @example "用户管理"
   */
  name: string;
  /**
   * 上级菜单ID（0表示顶级菜单）
   * @example 0
   */
  parent_id?: number;
  /**
   * 菜单路由
   * @example "/users"
   */
  route: string;
  /**
   * 排序字段
   * @example 0
   */
  sort?: number;
}

/** 创建角色的请求参数 */
export interface ModelCreateSysRoleRequest {
  /**
   * 角色编码
   * @example "EDITOR"
   */
  code: string;
  /**
   * 角色名称
   * @example "editor"
   */
  name: string;
}

/** 创建系统用户的请求参数 */
export interface ModelCreateSysUserRequest {
  /**
   * 系统用户昵称
   * @example "新用户"
   */
  nickname: string;
  /**
   * 系统用户密码
   * @minLength 6
   * @example "password"
   */
  password: string;
  /** 系统用户手机号 */
  phone?: string;
  /**
   * 用户角色ID
   * @example 1
   */
  role_id: number;
  /**
   * 学校ID列表
   * @example [1,2]
   */
  school_ids?: number[];
  /**
   * 系统用户名
   * @example "newuser"
   */
  username: string;
}

export interface ModelCreateTeacherAttentionStudentRequest {
  /**
   * 学生学号
   * @example "2023001"
   */
  student_number: string;
  /**
   * 是否关注传入的学生
   * @example true
   */
  is_attention: boolean;
}

/** 创建教师的请求参数 */
export interface ModelCreateTeacherRequest {
  /**
   * 姓名
   * @example "张老师"
   */
  name: string;
  /** 角色详情数组 */
  role_details: ModelTeacherRoleDetail[];
  /**
   * 手机号
   * @example "13800138000"
   */
  telphone: string;
}

export interface ModelCreateUploadSessionRequest {
  /** 文件分类 */
  category?: string;
  /** 切片大小 */
  chunk_size: number;
  /** 文件名 */
  filename: string;
  /** 文件标签 */
  tags?: string[];
  /** 文件总大小 */
  total_size: number;
}

/** 删除教师的请求参数 */
export interface ModelDeleteTeacherRequest {
  /** 班级Key */
  class_key?: number;
  /** 年级Key */
  grade_key?: number;
  /**
   * 教师ID
   * @example 1
   */
  id: number;
  /** 角色Key */
  role_key?: number;
  /** 学科ID */
  subject_id?: number;
}

export interface ModelDictionaryItem {
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  /** 字典类型id */
  dict_id?: number;
  /** 主键id */
  id?: number;
  /** 是否删除 */
  is_deleted?: number;
  /** KEY */
  key?: string;
  /** 父级KEY */
  parent_key?: string;
  /** 排序值 */
  sort_order?: number;
  /** 更新人 */
  updated_by?: string;
  /** 更新时间 */
  updated_time?: string;
  /** VALUE */
  value?: string;
}

export interface ModelDictionaryType {
  /** 编码 */
  code?: string;
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  /** 主键id */
  id?: number;
  /** 是否删除 */
  is_deleted?: number;
  /** 明细 */
  items?: ModelDictionaryItem[];
  /** 名称 */
  name?: string;
  /** 更新人 */
  updated_by?: string;
  /** 更新时间 */
  updated_time?: string;
}

export interface ModelDifficultyAnalysis {
  /**
   * 满分
   * @example 30
   */
  full_score?: number;
  /**
   * 难度等级
   * @example "容易题"
   */
  level?: string;
  /**
   * 失分比重
   * @example 23
   */
  miss_percent?: number;
  /** 题目ID列表 */
  question_ids?: number[];
  /** 题号列表 */
  question_numbers?: string[];
  /**
   * 得分
   * @example 13
   */
  score?: number;
}

/** 成绩分析设置列表响应结构 */
export interface ModelExamAnalysisSettingListResponse {
  /** 设置列表 */
  items?: ModelExamAnalysisSettingResponse[];
  /** 总数 */
  total?: number;
}

/** 成绩分析设置响应结构 */
export interface ModelExamAnalysisSettingResponse {
  /** 系统字段 */
  created_at?: string;
  /** 创建人ID */
  creator_id?: string;
  /** 创建人姓名 */
  creator_name?: string;
  /** 考试ID */
  exam_id?: number;
  /** 考试完整信息（从exam service获取） */
  exam_info?: any;
  /** 考试名称 */
  exam_name?: string;
  /** 是否去掉缺考一门以上学生 */
  exclude_absent_students?: boolean;
  /** 排除的班级ID列表，逗号分隔 */
  excluded_classes?: string;
  /** 排除条件设置 */
  excluded_schools?: string;
  /** 排除的学生标签列表，逗号分隔 */
  excluded_student_tags?: string;
  /** 主键ID */
  id?: number;
  /** 考生筛选条件 */
  min_total_score?: number;
  /** 考试科目列表（考试科目ID与科目名称） */
  subjects?: ModelExamAnalysisSettingSubject[];
  /** 取各班级总分前x%的学生 */
  top_class_percent?: number;
  /** 取各学科均在前x%的学生 */
  top_subject_percent?: number;
  /** 考生范围筛选 */
  top_total_percent?: number;
  /** 更新时间 */
  updated_at?: string;
  /** 权限设置 */
  visibility?: string;
}

/** 返回给前端的考试科目信息（ID与名称） */
export interface ModelExamAnalysisSettingSubject {
  /** 考试科目ID（exam_subject.id） */
  exam_subject_id?: number;
  /** 科目名称 */
  subject_name?: string;
}

/** 考试包含的班级信息 */
export interface ModelExamClassInfo {
  /**
   * 班级KEY
   * @example 1
   */
  class_key?: number;
  /**
   * 班级名称
   * @example "1班"
   */
  class_name?: string;
  /**
   * 年级KEY（从考试信息获取）
   * @example "10"
   */
  grade_key?: string;
  /**
   * 年级名称
   * @example "高一"
   */
  grade_name?: string;
}

export interface ModelExamMarkingSettingResponse {
  ai_template_id?: string;
  component_info?: string;
  created_by?: string;
  created_time?: string;
  exam_id?: number;
  id?: number;
  image_url?: string;
  is_enable?: number;
  recognition_info?: string;
  template_id?: number;
  tpl_url?: string;
  updated_by?: string;
  updated_time?: string;
}

export interface ModelExamMarkingSettingTopicResponse {
  allocation_method?: string;
  /** 阅卷分配方式名称 */
  allocation_method_name?: string;
  answer_score_type?: string;
  /** 答案得分类型名称 */
  answer_score_type_name?: string;
  arbitration_teacher?: ModelSimpleTeacherInfo[];
  branch_task_allocation?: any;
  created_by?: string;
  created_time?: string;
  evaluate_method?: string;
  /** 评选方式名称 */
  evaluate_method_name?: string;
  /** 评阅规则JSON字符串 */
  evaluate_rules?: string;
  full_score?: number;
  group_leader?: ModelSimpleTeacherInfo[];
  half_score?: number;
  id?: number;
  is_enable?: number;
  is_wrong_correction?: boolean;
  joint_mode?: string;
  /** 联考模式名称 */
  joint_mode_name?: string;
  marking_teacher?: ModelSimpleTeacherInfo[];
  /** 选项个数 */
  options_count?: number;
  /** 排序权重 */
  order?: number;
  quantity_task_allocation?: any;
  question_major?: string;
  question_minor?: string;
  question_type?: string;
  /** 题目类型名称 */
  question_type_name?: string;
  review_time?: number;
  score_distribution?: string;
  score_type?: string;
  /** 得分类型名称 */
  score_type_name?: string;
  scoring_mode?: string;
  /** 打分模式名称 */
  scoring_mode_name?: string;
  setting_id?: number;
  standard_answer?: string;
  subject_id?: number;
  /** 总任务数 */
  task_quantity?: number;
  updated_by?: string;
  updated_time?: string;
}

/** 考试包含的科目信息 */
export interface ModelExamSubjectInfo {
  /**
   * 考试科目ID
   * @example 2
   */
  exam_subject_id?: number;
  /**
   * 科目ID
   * @example 1
   */
  subject_id?: number;
  /**
   * 科目名称
   * @example "数学"
   */
  subject_name?: string;
}

export interface ModelExamSummary {
  /**
   * 总分
   * @example 90
   */
  all_score?: number;
  /**
   * 班级平均分
   * @example 79
   */
  class_average_score?: number;
  /**
   * 班级最高分
   * @example 81
   */
  class_max_score?: number;
  /**
   * 班级排名
   * @example 1
   */
  class_rank?: number;
  /**
   * 满分
   * @example 100
   */
  full_score?: number;
  /**
   * 年级平均分
   * @example 82
   */
  grade_average_score?: number;
  /**
   * 年级最高分
   * @example 89
   */
  grade_max_score?: number;
  /**
   * 年级排名
   * @example 1
   */
  grade_rank?: number;
}

/** 导出成绩单的请求参数 */
export interface ModelExportScoreSheetRequest {
  /** 查询班级 */
  class_key: number;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 查询年级 */
  grade_key: number;
  /** 关键字搜索(搜索学生名字) */
  keyword?: string;
  /** 科目ID（0表示所有科目） */
  subject_id?: number;
}

export interface ModelFileDownloadSession {
  /** 切片大小 */
  chunk_size?: number;
  created_at?: string;
  /** 已下载切片数 */
  downloaded_chunks?: number;
  /** 下载者名称 */
  downloader?: string;
  /** 下载者ID */
  downloader_id?: number;
  /** 会话过期时间 */
  expires_at?: string;
  /** 关联的文件ID */
  file_id?: number;
  id?: number;
  /** 会话ID */
  session_id?: string;
  /** 会话状态：downloading, completed, failed, expired */
  status?: string;
  /** 总切片数 */
  total_chunks?: number;
  updated_at?: string;
}

export interface ModelFileUploadSession {
  /** 文件分类 */
  category?: string;
  /** 切片大小 */
  chunk_size?: number;
  created_at?: string;
  /** 会话过期时间 */
  expires_at?: string;
  /** 文件扩展名 */
  extension?: string;
  /** 文件哈希值 */
  file_hash?: string;
  /** 原始文件名 */
  filename?: string;
  id?: number;
  /** MIME类型 */
  mime_type?: string;
  /** 会话ID */
  session_id?: string;
  /** 会话状态：uploading, completed, failed, expired */
  status?: string;
  /** 文件标签（JSON格式） */
  tags?: string;
  /** 总切片数 */
  total_chunks?: number;
  /** 文件总大小 */
  total_size?: number;
  updated_at?: string;
  /** 已上传切片数 */
  uploaded_chunks?: number;
  /** 上传者名称 */
  uploader?: string;
  /** 上传者ID */
  uploader_id?: number;
}

/** 获取班级下所有学生成绩列表的请求参数 */
export interface ModelGetClassStudentScoreListRequest {
  /** 查询班级 */
  class_key: number;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 查询年级 */
  grade_key: number;
  /** 是否隐藏缺考，默认false */
  hide_absent?: boolean;
  /** 学生姓名模糊搜索 */
  keyword?: string;
  /**
   * 页码
   * @min 1
   */
  page: number;
  /**
   * 页码大小
   * @min 1
   * @max 100
   */
  page_size: number;
  /** 考试科目ID */
  subject_id?: number;
}

/** 获取班级下所有学生成绩列表的响应数据 */
export interface ModelGetClassStudentScoreListResponse {
  /** 学生成绩列表 */
  list?: ModelClassStudentScoreInfo[];
  /** 页码 */
  page?: number;
  /** 每页大小 */
  page_size?: number;
  /** 总记录数 */
  total?: number;
}

/** 获取重点学生情况的请求参数 */
export interface ModelGetKeyStudentRequest {
  /** 查询班级 */
  class_key: number;
  /** 显著类型：up-上升，down-下降，key-重点学生，wave-成绩波动                                                                // 是否隐藏缺考，默认false */
  emphasis_type: ModelGetKeyStudentRequestEmphasisTypeEnum;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 查询年级 */
  grade_key: number;
  /**
   * 页码
   * @min 1
   */
  page: number;
  /**
   * 每页大小
   * @min 1
   * @max 100
   */
  page_size: number;
  /** 考试科目ID */
  subject_id?: number;
}

/** 获取重点学生情况的响应数据 */
export interface ModelGetKeyStudentResponse {
  /** 学生列表 */
  list?: ModelKeyStudentInfo[];
  /** 页码 */
  page?: number;
  /** 每页大小 */
  page_size?: number;
  /** 总记录数 */
  total?: number;
}

export interface ModelGetPersonalReportRequest {
  /**
   * 班级KEY
   * @example 1
   */
  class_key: number;
  /**
   * 考试科目ID
   * @example 1
   */
  exam_subject_id: number;
  /**
   * 年级KEY
   * @example 1
   */
  grade_key: number;
  /**
   * 学号
   * @example "2023001"
   */
  student_number: string;
}

export interface ModelGetPersonalReportResponse {
  /** 难度分析 */
  difficulty_analysis?: ModelDifficultyAnalysis[];
  /** 考试总结 */
  exam_summary?: ModelExamSummary;
  /** 学习情况分析 */
  learning_situation_analysis?: ModelLearningSituationAnalysis;
}

/** 获取最近考试情况的请求参数 */
export interface ModelGetRecentExamStatsRequest {
  /** 查询班级 */
  class_key: number;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /**
   * 优秀分数线
   * @min 0
   */
  excellent_scoring_rate?: number;
  /**
   * 良好分数线
   * @min 0
   */
  good_scoring_rate?: number;
  /** 查询年级 */
  grade_key: number;
  /**
   * 及格分数线
   * @min 0
   */
  pass_scoring_rate?: number;
  /** 考试科目ID */
  subject_id?: number;
  /**
   * 查看年级前N名人数
   * @min 1
   */
  top_n: number;
}

/** 获取最近考试情况的响应数据 */
export interface ModelGetRecentExamStatsResponse {
  /** 平均分排名 */
  average_score_rank?: number;
  /** 班级平均分 */
  class_average_score?: number;
  /** 班级数量 */
  class_count?: number;
  /** 班级优秀率 */
  excellent_class_scoring_rate?: number;
  /** 年级优秀率 */
  excellent_grade_scoring_rate?: number;
  /** 班级良好率 */
  good_class_scoring_rate?: number;
  /** 年级良好率 */
  good_grade_scoring_rate?: number;
  /** 年级平均分 */
  grade_average_score?: number;
  /** 年级前N名人数 */
  grade_top_n?: number;
  /** 班级及格率 */
  pass_class_scoring_rate?: number;
  /** 年级及格率 */
  pass_grade_scoring_rate?: number;
}

/** 获取成绩单的请求参数 */
export interface ModelGetScoreSheetRequest {
  /** 查询班级 */
  class_key: number;
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 查询年级 */
  grade_key: number;
  /** 关键字搜索(搜索学生名字) */
  keyword?: string;
  /**
   * 页码
   * @min 1
   */
  page: number;
  /**
   * 页码大小
   * @min 1
   * @max 100
   */
  page_size: number;
  /** 科目ID（0表示所有科目） */
  subject_id?: number;
}

/** 获取成绩单的响应数据 */
export interface ModelGetScoreSheetResponse {
  /** 学生成绩列表 */
  list?: ModelStudentScoreInfo[];
  /** 页码 */
  page?: number;
  /** 页码大小 */
  page_size?: number;
  /** 总记录数 */
  total?: number;
}

/** 获取个人历次考试详情的请求参数 */
export interface ModelGetStudentExamHistoryRequest {
  /**
   * 页码
   * @min 1
   */
  page: number;
  /**
   * 页码大小
   * @min 1
   * @max 100
   */
  page_size: number;
  /** 学生学号 */
  student_number: string;
  /**
   * 科目ID
   * @min 1
   */
  subject_id: number;
}

/** 获取个人历次考试详情的响应数据 */
export interface ModelGetStudentExamHistoryResponse {
  /** 考试详情列表 */
  list?: ModelStudentExamHistoryInfo[];
  /** 页码 */
  page?: number;
  /** 每页大小 */
  page_size?: number;
  /** 总记录数 */
  total?: number;
}

export interface ModelGetStudentListRequest {
  /**
   * 班级ID
   * @example 1
   */
  class_id: number;
  /**
   * 考试科目ID
   * @example 1
   */
  exam_subject_id: number;
  /**
   * 年级ID
   * @example 1
   */
  grade_id: number;
}

export interface ModelGetStudentListResponse {
  /** 已关注的学生列表 */
  attentioned_students?: ModelStudentInfo[];
  /** 其他学生列表 */
  other_students?: ModelStudentInfo[];
}

/** 获取班级和年级平均分走势的请求参数 */
export interface ModelGetTrendRequest {
  /** 查询班级 */
  class_key: number;
  /** 查询年级 */
  grade_key: number;
  /** 考试科目ID */
  subject_id?: number;
}

/** 获取班级和年级平均分走势的响应数据 */
export interface ModelGetTrendResponse {
  /** 班级分数信息 */
  class_scores?: ModelClassScoreInfo[];
  /** 考试名称轴 */
  exam_axis?: string[];
  /** 年级分数信息 */
  grade_scores?: ModelGradeScoreInfo[];
}

/** 年级平均分走势信息 */
export interface ModelGradeScoreInfo {
  /** 平均分数组 */
  average_scores?: number[];
  /** 年级名称 */
  grade?: string;
  /** 年级KEY */
  grade_key?: number;
}

export interface ModelItemList {
  /** 扩展信息，后端和前端约定好格式 */
  ext_info?: any;
  /** 下拉列表项ID，当id为字符串时使用IdStr字段，该字段没有值 */
  id?: number;
  /** 下拉列表项ID字符串形式,有的id是字符串形式所以加上这个字段（比如扫描人id） */
  id_str?: string;
  /** 下拉列表项名称 */
  name?: string;
}

export interface ModelItemListRequest {
  /** 拓展请求参数 */
  extra: string;
  /** 下拉列表类型 1：批次下拉 2：扫描人下拉 3:学校下拉 */
  item_type: number;
  /** 关键字搜索 */
  kw?: string;
  /** 当前页码 */
  page: number;
  /** 每页大小 */
  page_size: number;
}

export interface ModelItemListResponse {
  /** 是否有更多数据 */
  has_more?: boolean;
  /** 下拉列表数据 */
  list?: ModelItemList[];
  /** 当前页 */
  page?: number;
}

/** 重点学生详细信息 */
export interface ModelKeyStudentInfo {
  /** 总得分 */
  all_score?: number;
  /** 班级排名变化方向 */
  class_diff_direction?: string;
  /** 班级排名变化 */
  class_diff_rank?: number;
  /** 班级排名 */
  class_rank?: number;
  /** 总分 */
  full_score?: number;
  /** 年级排名变化方向 */
  grade_diff_direction?: string;
  /** 年级排名变化 */
  grade_diff_rank?: number;
  /** 年级排名 */
  grade_rank?: number;
  /** 学生考试号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 学生学号 */
  student_number?: string;
  /** 是否被关注 */
  is_attention?: boolean;
}

export interface ModelLearningSituationAnalysis {
  /**
   * 总分
   * @example 109
   */
  all_score?: number;
  /**
   * 班级总人数
   * @example 90
   */
  class_member_count?: number;
  /**
   * 班级排名
   * @example 1
   */
  class_rank?: number;
  /** 分数段数据 */
  data?: ModelScoreScopeData[];
  /**
   * 年级总人数
   * @example 1200
   */
  grade_member_count?: number;
  /**
   * 年级排名
   * @example 123
   */
  grade_rank?: number;
}

export interface ModelLoginRequest {
  password: string;
  username: string;
}

export interface ModelLoginResponse {
  access_token?: string;
  expire_time?: number;
  refresh_token?: string;
  request_id?: string;
}

export interface ModelPageResponse {
  /** 是否有更多数据 */
  has_more?: boolean;
  /** 当前页数据列表 */
  list?: any[];
  /** 当前页 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总记录数 */
  total?: number;
}

export interface ModelQuestionAnalysisRequest {
  /** 班级字典key列表，当query_mode=class时必填 */
  class_key?: string;
  /**
   * 考试ID，必填
   * @min 1
   */
  exam_id: number;
  /** 搜索关键词（支持学生姓名、学号、考号、系统号搜索） */
  keyword?: string;
  /**
   * 学科ID，必填，只接受单科
   * @min 1
   */
  subject_id: number;
}

export interface ModelRegisterRequest {
  /** @example "user@example.com" */
  email: string;
  /**
   * @minLength 6
   * @example "password"
   */
  password: string;
  /** @example "newuser" */
  username: string;
}

/** 重置密码的请求参数 */
export interface ModelResetPasswordRequest {
  /**
   * 确认密码
   * @example "newpassword"
   */
  confirm_password: string;
  /**
   * 新密码
   * @minLength 6
   * @example "newpassword"
   */
  new_password: string;
  /**
   * 手机号
   * @example "13800138000"
   */
  phone: string;
  /**
   * 用户名
   * @example "admin"
   */
  username: string;
  /**
   * 验证码
   * @example "123456"
   */
  verify_code: string;
}

export interface ModelSchool {
  /** 学校编码 */
  code?: string;
  /** 创建人 */
  created_by?: string;
  /** 创建时间 */
  created_time?: string;
  /** 主键id */
  id?: number;
  /** 是否删除 */
  is_deleted?: number;
  /** 是否启用 */
  is_enable?: number;
  /** 是否联盟学校 */
  is_union?: number;
  /** 学校名称 */
  name?: string;
  /** 学阶 */
  stage?: string;
  /** 更新人 */
  updated_by?: string;
  /** 更新时间 */
  updated_time?: string;
}

export interface ModelScoreAnalysisRequest {
  /** 班级字典key列表（class模式时必填） */
  class_key?: string;
  /** 考试ID */
  exam_id: number;
  /** 科目ID，0表示总分 */
  subject_id?: number;
}

/** 单个科目的成绩信息 */
export interface ModelScoreInfo {
  /** 赋分 */
  assignment_score?: number;
  /** 班级排名 */
  class_rank?: number;
  /** 年级排名 */
  grade_rank?: number;
  /** 等级 */
  level?: string;
  /** 得分（all_score） */
  score?: number;
  /** 科目名称 */
  subject_name?: string;
}

export interface ModelScoreScopeData {
  /**
   * 分数段
   * @example "0-9"
   */
  score_scope?: string;
  /**
   * 学生数量
   * @example 2
   */
  student_num?: number;
}

export interface ModelSetReviewTimeRequest {
  /** 题目ID */
  question_id: number;
  /** 批阅时长，单位：秒 */
  timeout: number;
}

/** 设置或取消教师管理员权限的请求参数 */
export interface ModelSetTeacherAdminRequest {
  /**
   * 是否设置为管理员
   * @example true
   */
  is_admin?: boolean;
  /**
   * 教师ID
   * @example 1
   */
  teacher_id: number;
}

/** 老师基本信息 */
export interface ModelSimpleTeacherInfo {
  /** 老师ID */
  id?: number;
  /** 是否为虚拟老师 */
  is_virtual?: boolean;
  /** 姓名 */
  name?: string;
  /** 虚拟老师ID，当is_virtual为true时存储虚拟老师ID */
  user_id?: string;
}

/** 单科基本信息响应结构，用于在综合科详情中展示包含的单科 */
export interface ModelSingleSubjectResponse {
  /**
   * 单科ID
   * @example 1
   */
  id?: number;
  /**
   * 单科名称
   * @example "数学"
   */
  name?: string;
  /**
   * 单科代码
   * @example "MATH"
   */
  subject_code?: string;
}

export interface ModelStatisticsAnalysisRequest {
  /** 分析类型：rank/score/percentile */
  analysis_type: string;
  /** 班级字典key列表（class模式时使用） */
  class_key?: string;
  /** 考试ID */
  exam_id: number;
  /** 科目ID，0表示总分 */
  subject_id?: number;
}

/** 学生信息模型 */
export interface ModelStudent {
  /**
   * 班级
   * @example "1班"
   */
  class?: string;
  /**
   * 班级Key
   * @example 1
   */
  class_key?: number;
  /**
   * 学籍号
   * @example "20240001"
   */
  code?: string;
  /**
   * 创建人
   * @example "system"
   */
  created_by?: string;
  /**
   * 创建时间
   * @example "2023-01-01T00:00:00Z"
   */
  created_time?: string;
  /**
   * 考号
   * @example "2024001001"
   */
  exam_number?: string;
  /**
   * 选考科目
   * @example "物理,化学"
   */
  exam_subject?: string;
  /**
   * 外语科目
   * @example "英语"
   */
  foreign_language_subject?: string;
  /**
   * 年级
   * @example "高一"
   */
  grade?: string;
  /**
   * 年级Key
   * @example 1
   */
  grade_key?: number;
  /**
   * 主键ID（自增）
   * @example 1
   */
  id?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 标签
   * @example "优秀"
   */
  label?: string;
  /**
   * 姓名
   * @example "张三"
   */
  name?: string;
  /**
   * 学号
   * @example "20240001"
   */
  number?: string;
  /**
   * 家长姓名
   * @example "张父"
   */
  parent_name?: string;
  /**
   * 家长电话
   * @example "13800138000"
   */
  parent_telphone?: string;
  /**
   * 学校ID
   * @example 1
   */
  school_id?: number;
  /**
   * 学校名称
   * @example "某某中学"
   */
  school_name?: string;
  /**
   * 序列号
   * @example 1
   */
  sequence?: number;
  /**
   * 科目ID
   * @example 1
   */
  subject_id?: number;
  /**
   * 更新人
   * @example "admin"
   */
  updated_by?: string;
  /**
   * 更新时间
   * @example "2023-01-01T00:00:00Z"
   */
  updated_time?: string;
  /**
   * 象乐学ID
   * @example "20240001"
   */
  xlx_id?: string;
  /**
   * 入学年
   * @example 2024
   */
  year?: number;
}

/** 个人历次考试详情信息 */
export interface ModelStudentExamHistoryInfo {
  /** 总得分 */
  all_score?: number;
  /** 班级人数 */
  class_member_count?: number;
  /** 班级排名 */
  class_rank?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 考试科目ID */
  exam_subject_id?: number;
  /** 满分 */
  full_score?: number;
  /** 年级人数 */
  grade_member_count?: number;
  /** 年级排名 */
  grade_rank?: number;
  /** 信息ID */
  info_id?: number;
  /** 考试ID */
  exam_id?: number;
}

export interface ModelStudentInfo {
  /**
   * 答题卡信息ID
   * @example 1
   */
  info_id?: number;
  /**
   * 学生姓名
   * @example "张三"
   */
  student_name?: string;
  /**
   * 学生学号
   * @example "2023001"
   */
  student_number?: string;
}

/** 学生的成绩信息 */
export interface ModelStudentScoreInfo {
  /** 班级 */
  class?: string;
  /** 年级 */
  grade?: string;
  /** 成绩列表 */
  scores?: ModelScoreInfo[];
  /** 考号 */
  student_exam_number?: string;
  /** 学生姓名 */
  student_name?: string;
  /** 学号 */
  student_number?: string;
}

/** 科目详细信息响应结构，包含完整的科目信息和关联数据 */
export interface ModelSubjectResponse {
  /**
   * 创建者用户ID
   * @example "admin"
   */
  created_user_id?: string;
  /**
   * 科目ID
   * @example 1
   */
  id?: number;
  /**
   * 是否可编辑：1-可编辑，0-不可编辑
   * @example 1
   */
  is_enable?: number;
  /**
   * 是否为固定科目
   * @example false
   */
  is_fixed?: boolean;
  /**
   * 科目名称
   * @example "数学"
   */
  name?: string;
  /**
   * 学校ID，null表示全局科目
   * @example 1
   */
  school_id?: number;
  /**
   * 学校名称，仅非全局科目包含
   * @example "示例学校"
   */
  school_name?: string;
  /** 仅综合科包含的单科列表 */
  single_subjects?: ModelSingleSubjectResponse[];
  /**
   * 排序号
   * @example 1
   */
  sort?: number;
  /**
   * 学科代码
   * @example "MATH"
   */
  subject_code?: string;
  /**
   * 科目类型：单科、综合科、选科
   * @example "单科"
   */
  type?: string;
}

/** 系统菜单信息模型 */
export interface ModelSysMenu {
  /**
   * 组件地址
   * @example "UserManagement"
   */
  component?: string;
  /**
   * 创建人
   * @example "system"
   */
  created_by?: string;
  /**
   * 创建时间
   * @example "2023-01-01 00:00:00"
   */
  created_time?: string;
  /**
   * 菜单图标
   * @example "user"
   */
  icon?: string;
  /**
   * 菜单ID
   * @example 1
   */
  id?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 元数据信息
   * @example "{"title":"用户管理","hidden":false}"
   */
  meta?: string;
  /**
   * 菜单名称
   * @example "用户管理"
   */
  name?: string;
  /**
   * 上级菜单ID
   * @example 0
   */
  parent_id?: number;
  /** 关联关系 */
  roles?: ModelSysRole[];
  /**
   * 菜单路由
   * @example "/users"
   */
  route?: string;
  /**
   * 排序字段
   * @example 0
   */
  sort?: number;
  /**
   * 更新人
   * @example "system"
   */
  updated_by?: string;
  /**
   * 更新时间
   * @example "2023-01-01 00:00:00"
   */
  updated_time?: string;
}

/** 系统角色信息模型 */
export interface ModelSysRole {
  /**
   * 角色编码
   * @example "ADMIN"
   */
  code?: string;
  /**
   * 创建人
   * @example "system"
   */
  created_by?: string;
  /** 创建时间 (yyyy-mm-dd格式) */
  created_time?: string;
  /**
   * 角色ID
   * @example 1
   */
  id?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 是否关联学校
   * @example 0
   */
  is_relation?: number;
  /**
   * 角色名称
   * @example "admin"
   */
  name?: string;
  permissions?: ModelSysMenu[];
  /**
   * 更新人
   * @example "admin"
   */
  updated_by?: string;
  /** 更新时间 (yyyy-mm-dd格式) */
  updated_time?: string;
  /** 关联关系 */
  users?: ModelSysUser[];
}

/** 系统用户信息模型 */
export interface ModelSysUser {
  /**
   * 创建人ID
   * @example "system"
   */
  created_by?: string;
  /**
   * 创建时间
   * @example "2023-01-01T00:00:00Z"
   */
  created_time?: string;
  /**
   * 系统用户ID
   * @example "U001"
   */
  id?: string;
  /** 是否是系统管理员 */
  is_admin?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 系统用户昵称
   * @example "管理员"
   */
  nickname?: string;
  /**
   * 系统用户手机号
   * @example "13800138000"
   */
  phone?: string;
  /** 关联关系 */
  roles?: ModelSysRole[];
  schools?: ModelSchool[];
  /**
   * 修改人ID
   * @example "admin"
   */
  updated_by?: string;
  /**
   * 修改时间
   * @example "2023-01-01T00:00:00Z"
   */
  updated_time?: string;
  /**
   * 系统用户名
   * @example "admin"
   */
  username?: string;
}

/** 系统用户列表响应结构 */
export interface ModelSysUserListResponse {
  /** 用户列表 */
  items?: ModelSysUser[];
  /** 当前页码 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总数 */
  total?: number;
}

/** 教师信息模型 */
export interface ModelTeacher {
  /** 教师班级关联 */
  classes?: ModelTeacherClass[];
  /**
   * 创建人
   * @example "system"
   */
  created_by?: string;
  /**
   * 创建时间
   * @example "2023-01-01T00:00:00Z"
   */
  created_time?: string;
  /**
   * 主键id
   * @example 1
   */
  id?: number;
  /**
   * 是否是管理员
   * @example false
   */
  is_admin?: boolean;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 姓名
   * @example "张老师"
   */
  name?: string;
  /** 教师角色 */
  roles?: ModelTeacherRole[];
  /**
   * 学校ID
   * @example 1
   */
  school_id?: number;
  /** 关联的学校 */
  schools?: ModelSchool[];
  /**
   * 更新人
   * @example "admin"
   */
  updated_by?: string;
  /**
   * 更新时间
   * @example "2023-01-01T00:00:00Z"
   */
  updated_time?: string;
  /** 关联关系 */
  user?: ModelSysUser;
  /**
   * 关联的系统用户ID
   * @example "T00000001"
   */
  user_id?: string;
}

/** 老师所带的班级信息 */
export interface ModelTeacherAnalysisClassInfo {
  /**
   * 班级名称
   * @example "1班"
   */
  class?: string;
  /**
   * 班级KEY
   * @example 1
   */
  class_key?: number;
  /**
   * 年级名称
   * @example "高一"
   */
  grade?: string;
  /**
   * 年级KEY
   * @example 10
   */
  grade_key?: number;
}

/** 老师所带科目的考试信息 */
export interface ModelTeacherAnalysisExamInfo {
  /** 考试包含的班级列表 */
  classes?: ModelExamClassInfo[];
  /**
   * 考试ID
   * @example 1
   */
  exam_id?: number;
  /**
   * 考试名称
   * @example "测试"
   */
  exam_name?: string;
  /** 考试包含的科目列表 */
  subjects?: ModelExamSubjectInfo[];
}

/** 老师成绩分析接口响应 */
export interface ModelTeacherAnalysisResponse {
  /** 班级列表 */
  class_list?: ModelTeacherAnalysisClassInfo[];
  /** 考试列表 */
  exam_list?: ModelTeacherAnalysisExamInfo[];
  /** 科目列表 */
  subject_list?: ModelTeacherAnalysisSubjectInfo[];
}

/** 老师所带的科目信息 */
export interface ModelTeacherAnalysisSubjectInfo {
  /**
   * 科目ID
   * @example 255
   */
  subject_id?: number;
  /**
   * 科目名称
   * @example "语文"
   */
  subject_name?: string;
}

/** 教师所带班级信息模型 */
export interface ModelTeacherClass {
  /**
   * 班级
   * @example "1班"
   */
  class?: string;
  /**
   * 班级KEY
   * @example 1
   */
  class_key?: number;
  /**
   * 年级
   * @example "高一"
   */
  grade?: string;
  /**
   * 年级KEY
   * @example 1
   */
  grade_key?: number;
  /**
   * 主键id
   * @example 1
   */
  id?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 学科
   * @example "数学"
   */
  subject?: string;
  /**
   * 学科ID
   * @example 1
   */
  subject_id?: number;
  /**
   * 教师id
   * @example 1
   */
  teacher_id?: number;
}

/** 教师列表查询的响应数据 */
export interface ModelTeacherListResponse {
  /**
   * 创建时间
   * @example "2023-01-01T00:00:00Z"
   */
  created_time?: string;
  /**
   * 教师ID
   * @example 1
   */
  id?: number;
  /**
   * 是否是管理员
   * @example false
   */
  is_admin?: boolean;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 姓名
   * @example "张老师"
   */
  name?: string;
  /**
   * 手机号
   * @example "13800138000"
   */
  phone?: string;
  /** 角色班级列表 */
  role_class_list?: ModelTeacherRoleClassInfo[];
  /**
   * 关联的系统用户ID
   * @example "T00000001"
   */
  user_id?: string;
}

/** 教师角色信息模型 */
export interface ModelTeacherRole {
  /**
   * 主键id
   * @example 1
   */
  id?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 角色
   * @example "班主任,任课教师"
   */
  role?: string;
  /**
   * 角色key
   * @example 1
   */
  role_key?: number;
  /**
   * 教师id
   * @example 1
   */
  teacher_id?: number;
}

/** 教师角色班级组合信息 */
export interface ModelTeacherRoleClassInfo {
  /**
   * 班级
   * @example "1班"
   */
  class?: string;
  /**
   * 班级KEY
   * @example 1
   */
  class_key?: number;
  /**
   * 年级
   * @example "高一"
   */
  grade?: string;
  /**
   * 年级KEY
   * @example 1
   */
  grade_key?: number;
  /**
   * 角色
   * @example "任课老师"
   */
  role?: string;
  /**
   * 角色KEY
   * @example 1
   */
  role_key?: number;
  /**
   * 学科
   * @example "数学"
   */
  subject?: string;
  /**
   * 学科ID
   * @example 1
   */
  subject_id?: number;
}

/** 教师角色详情，包含角色、年级、学科和班级信息 */
export interface ModelTeacherRoleDetail {
  /**
   * 班级（多个班级用逗号隔开）
   * @example "1班,2班"
   */
  class: string;
  /**
   * 班级Key（多个班级，使用逗号隔开）
   * @example "1,2"
   */
  class_key?: string;
  /**
   * 年级
   * @example "高一"
   */
  grade: string;
  /**
   * 年级Key
   * @example "1"
   */
  grade_key?: string;
  /**
   * 角色（多个角色用逗号隔开）
   * @example "班主任,任课教师"
   */
  role: string;
  /**
   * 角色Key（多个角色，使用逗号隔开）
   * @example "1,2"
   */
  role_key?: string;
  /**
   * 学科
   * @example "数学"
   */
  subject: string;
  /**
   * 学科ID
   * @example "1"
   */
  subject_id?: string;
}

/** 更新成绩分析设置的请求参数 */
export interface ModelUpdateExamAnalysisSettingRequest {
  /**
   * 考试ID
   * @min 1
   */
  exam_id: number;
  /** 多个考试科目ID，逗号分隔（新） */
  exam_subject_ids?: string;
  /** 是否去掉缺考一门以上学生 */
  exclude_absent_students?: boolean;
  /** 排除的班级ID列表，逗号分隔 */
  excluded_classes?: string;
  /** 排除条件设置 */
  excluded_schools?: string;
  /** 排除的学生标签列表，逗号分隔 */
  excluded_student_tags?: string;
  /**
   * 设置ID
   * @min 1
   */
  id: number;
  /** 考生筛选条件 */
  min_total_score?: number;
  /**
   * 取各班级总分前x%的学生
   * @min 1
   * @max 100
   */
  top_class_percent?: number;
  /**
   * 取各学科均在前x%的学生
   * @min 1
   * @max 100
   */
  top_subject_percent?: number;
  /**
   * 考生范围筛选
   * @min 1
   * @max 100
   */
  top_total_percent?: number;
  /** 权限设置 */
  visibility: ModelUpdateExamAnalysisSettingRequestVisibilityEnum;
}

/** 更新学生的请求参数 */
export interface ModelUpdateStudentRequest {
  /**
   * 班级
   * @example "1班"
   */
  class?: string;
  /**
   * 学籍号
   * @example "20240001"
   */
  code?: string;
  /**
   * 考号
   * @example "2024001001"
   */
  exam_number?: string;
  /**
   * 选考科目
   * @example "物理,化学"
   */
  exam_subject?: string;
  /**
   * 外语科目
   * @example "英语"
   */
  foreign_language_subject?: string;
  /**
   * 年级
   * @example "高一"
   */
  grade?: string;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 标签
   * @example "优秀"
   */
  label?: string;
  /**
   * 姓名
   * @example "张三"
   */
  name?: string;
  /**
   * 学号
   * @example "20240001"
   */
  number?: string;
  /**
   * 家长姓名
   * @example "张父"
   */
  parent_name?: string;
  /**
   * 家长电话
   * @example "13800138000"
   */
  parent_telphone?: string;
}

/** 更新科目的请求参数，支持部分字段更新，未传递的字段保持原值 */
export interface ModelUpdateSubjectRequest {
  /**
   * 是否为固定科目，可选
   * @example false
   */
  is_fixed?: boolean;
  /**
   * 科目名称，可选，最大50字符
   * @maxLength 50
   * @example "数学"
   */
  name?: string;
  /** 仅综合科需要，包含的单科ID列表 */
  single_subject_ids?: number[];
  /**
   * 排序号，可选，最小值0
   * @min 0
   * @example 1
   */
  sort?: number;
  /**
   * 学科代码，可选，最大20字符
   * @maxLength 20
   * @example "MATH"
   */
  subject_code?: string;
  /**
   * 科目类型，可选，枚举值：单科、综合科、选科
   * @example "单科"
   */
  type?: ModelUpdateSubjectRequestTypeEnum;
}

/** 更新菜单的请求参数 */
export interface ModelUpdateSysMenuRequest {
  /**
   * 组件地址
   * @example "UserManagement"
   */
  component?: string;
  /**
   * 菜单图标
   * @example "user"
   */
  icon?: string;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 元数据信息
   * @example "{"title":"用户管理","hidden":false}"
   */
  meta?: string;
  /**
   * 菜单名称
   * @example "用户管理"
   */
  name?: string;
  /**
   * 上级菜单ID
   * @example 0
   */
  parent_id?: number;
  /**
   * 菜单路由
   * @example "/users"
   */
  route?: string;
  /**
   * 排序字段
   * @example 0
   */
  sort?: number;
}

/** 更新角色的请求参数 */
export interface ModelUpdateSysRoleRequest {
  /**
   * 角色编码
   * @example "UPDATED_ROLE"
   */
  code?: string;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 角色名称
   * @example "updated_role"
   */
  name?: string;
  /**
   * 修改人
   * @example "admin"
   */
  updated_by: string;
}

/** 更新系统用户的请求参数 */
export interface ModelUpdateSysUserRequest {
  /**
   * 是否是系统管理员
   * @example false
   */
  is_admin?: boolean;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 系统用户昵称
   * @example "更新用户"
   */
  nickname?: string;
  /**
   * 系统用户手机号
   * @example "13800138000"
   */
  phone?: string;
  /**
   * 学校ID列表
   * @example [1,2]
   */
  school_ids?: number[];
  /**
   * 系统用户名
   * @example "updateduser"
   */
  username?: string;
}

/** 更新教师的请求参数 */
export interface ModelUpdateTeacherRequest {
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 姓名
   * @example "张老师"
   */
  name?: string;
  /**
   * 昵称
   * @example "张老师"
   */
  nickname?: string;
  /**
   * 手机号
   * @example "13800138000"
   */
  phone?: string;
  /** 角色详情数组 */
  role_details?: ModelTeacherRoleDetail[];
  /** 关联的学校ID列表 */
  school_ids?: number[];
}

/** 用户个人信息响应，包含系统用户信息和教师信息（如果是教师） */
export interface ModelUserProfileResponse {
  /** 系统用户信息 */
  sys_user?: ModelSysUser;
  /** 教师信息（如果是教师） */
  teacher?: ModelTeacherListResponse;
}

export interface SchedulerSchedulerStatus {
  /** 是否运行中 */
  running?: boolean;
  /** 正在运行的任务数 */
  running_task?: number;
  /** 启动时间 */
  start_time?: string;
  /** 任务总数 */
  task_count?: number;
  /** 运行时长 */
  uptime?: string;
}

export interface SchedulerTask {
  /** 创建时间 */
  created_at?: string;
  /** 任务数据 */
  data?: Record<string, any>;
  /** 任务描述 */
  description?: string;
  /** 是否启用 */
  enabled?: boolean;
  /** 错误次数 */
  error_count?: number;
  /** 处理器名称 */
  handler?: string;
  /** 任务ID */
  id?: string;
  /** 上次执行时间 */
  last_run?: string;
  /** 最大重试次数 */
  max_retries?: number;
  /** 任务名称 */
  name?: string;
  /** 下次执行时间 */
  next_run?: string;
  /** 执行次数 */
  run_count?: number;
  /** 调度表达式 */
  schedule?: string;
  /** 任务状态 */
  status?: SchedulerTaskStatus;
  /**
   * 超时时间
   * @example "5m"
   */
  timeout?: string;
  /** 任务类型 */
  type?: SchedulerTaskType;
  /** 更新时间 */
  updated_at?: string;
}

export interface SchedulerTaskResult {
  /** 执行时长 */
  duration?: string;
  /** 结束时间 */
  end_time?: string;
  /** 错误信息 */
  error?: string;
  /** 输出信息 */
  output?: string;
  /** 重试次数 */
  retry_count?: number;
  /** 开始时间 */
  start_time?: string;
  /** 执行状态 */
  status?: SchedulerTaskStatus;
  /** 任务ID */
  task_id?: string;
}

export enum SchedulerTaskStatus {
  TaskStatusPending = 'pending',
  TaskStatusRunning = 'running',
  TaskStatusCompleted = 'completed',
  TaskStatusFailed = 'failed',
  TaskStatusStopped = 'stopped'
}

export enum SchedulerTaskType {
  TaskTypeCron = 'cron',
  TaskTypeInterval = 'interval',
  TaskTypeOnce = 'once'
}

export interface ScoreReportClassExamComparisonDataVO {
  /** 考试对比列表 */
  exam_list?: ScoreReportExamComparisonItemVO[];
}

export interface ScoreReportClassExamComparisonRequestVO {
  /** 班级 */
  class_key: number;
  /** 年级 */
  grade_key: number;
  /** 角色ID */
  role_id: number;
  /** 科目ID（可选，0表示总分） */
  subject_id?: number;
  /** 教师ID */
  teacher_id: number;
}

export interface ScoreReportExamComparisonItemVO {
  /** 平均分排名 */
  average_rank?: number;
  /** 班级平均分 */
  class_average?: number;
  /** 班级标准分 */
  class_standard?: number;
  /** 考试ID */
  exam_id?: number;
  /** 考试名称 */
  exam_name?: string;
  /** 年级前50名人数 */
  grade_top50_count?: number;
}

export interface ServiceCopyAnswerSheetRequest {
  /** 新答题卡组件ID */
  component_id?: string;
  /** 新答题卡名称 */
  name: string;
}

export interface ServiceCreateAnswerSheetRequest {
  /** 答题卡组件ID */
  component_id?: string;
  /** 答题卡组件信息 */
  component_info?: string;
  /** 答题卡图片相对路径 */
  image_url?: string;
  /** 答题卡名称 */
  name: string;
  /** 答题卡PDF相对路径 */
  pdf_url?: string;
  /** 答题卡AI识别信息 */
  recognition_info?: string;
  /** 答题卡图片模版ID */
  tpl_url?: string;
}

export interface ServiceGetAnswerSheetListResponse {
  /** 答题卡列表 */
  list?: ModelAnswerSheet[];
  /** 当前页 */
  page?: number;
  /** 每页数量 */
  page_size?: number;
  /** 总页数 */
  pages?: number;
  /** 总数 */
  total?: number;
}

export interface ServiceIntelligentMarkingRequest {
  full_score?: number;
  id?: number;
  score_type?: string;
  standard_answer?: string;
}

export interface ServiceObjectiveAnswerSettingRequest {
  allocation_method?: string;
  answer_score_type?: string;
  evaluate_method?: string;
  evaluate_rules?: string;
  full_score?: number;
  half_score?: number;
  id?: number;
  is_wrong_correction?: boolean;
  question_type?: string;
  score_distribution?: string;
  score_type?: string;
  standard_answer?: string;
}

export interface ServicePresignedURLResponse {
  expires?: number;
  key?: string;
  upload_url?: string;
}

export interface ServiceScoreCalculateRequest {
  /** @minItems 1 */
  exam_subject_ids: number[];
}

export interface ServiceScoreCalculateResponse {
  affected_details?: number;
  affected_infos?: number;
}

export interface ServiceScoreCancelRequest {
  /** @minItems 1 */
  exam_subject_ids: number[];
}

export interface ServiceScoreCancelResponse {
  cancelled_subjects?: number;
  deleted_statistics?: number;
  reset_answer_details?: number;
  reset_answer_sheets?: number;
}

export interface ServiceScorePublishRequest {
  /** @minItems 1 */
  exam_subject_ids: number[];
}

export interface ServiceScorePublishResponse {
  affected_infos?: number;
}

export interface ServiceStudentWithSubjectName {
  /**
   * 班级
   * @example "1班"
   */
  class?: string;
  /**
   * 班级Key
   * @example 1
   */
  class_key?: number;
  /**
   * 学籍号
   * @example "20240001"
   */
  code?: string;
  /**
   * 创建人
   * @example "system"
   */
  created_by?: string;
  /**
   * 创建时间
   * @example "2023-01-01T00:00:00Z"
   */
  created_time?: string;
  /** 选考科目名称 */
  elective_subject_name?: string;
  /**
   * 考号
   * @example "2024001001"
   */
  exam_number?: string;
  /**
   * 选考科目
   * @example "物理,化学"
   */
  exam_subject?: string;
  /**
   * 外语科目
   * @example "英语"
   */
  foreign_language_subject?: string;
  /**
   * 年级
   * @example "高一"
   */
  grade?: string;
  /**
   * 年级Key
   * @example 1
   */
  grade_key?: number;
  /**
   * 主键ID（自增）
   * @example 1
   */
  id?: number;
  /**
   * 是否删除
   * @example 0
   */
  is_deleted?: number;
  /**
   * 是否启用
   * @example 1
   */
  is_enable?: number;
  /**
   * 标签
   * @example "优秀"
   */
  label?: string;
  /**
   * 姓名
   * @example "张三"
   */
  name?: string;
  /**
   * 学号
   * @example "20240001"
   */
  number?: string;
  /**
   * 家长姓名
   * @example "张父"
   */
  parent_name?: string;
  /**
   * 家长电话
   * @example "13800138000"
   */
  parent_telphone?: string;
  /**
   * 学校ID
   * @example 1
   */
  school_id?: number;
  /**
   * 学校名称
   * @example "某某中学"
   */
  school_name?: string;
  /**
   * 序列号
   * @example 1
   */
  sequence?: number;
  /**
   * 科目ID
   * @example 1
   */
  subject_id?: number;
  /**
   * 更新人
   * @example "admin"
   */
  updated_by?: string;
  /**
   * 更新时间
   * @example "2023-01-01T00:00:00Z"
   */
  updated_time?: string;
  /**
   * 象乐学ID
   * @example "20240001"
   */
  xlx_id?: string;
  /**
   * 入学年
   * @example 2024
   */
  year?: number;
}

/** 任务分配请求结构体，用于批量更新题目的任务分配信息。包含基础信息、教师分配、任务分配配置等完整信息 */
export interface ServiceTaskAllocationRequest {
  /**
   * efficiency-效率优先,quantity-定量分配,average-平均分配
   * 注意：选择quantity时必须提供quantity_task_allocation配置，选择其他方式时必须提供branch_task_allocation配置
   * @example "quantity"
   */
  allocation_method?: ServiceTaskAllocationRequestAllocationMethodEnum;
  /**
   * @Description 仲裁老师列表，可选字段。仲裁老师负责处理阅卷争议和最终评分裁定。
   * 每个仲裁老师包含id(教师ID)、name(教师姓名)、is_virtual(是否为虚拟老师)和user_id(虚拟老师ID)四个字段
   * 系统会自动为仲裁老师设置teacher_type=2
   * 注意：如果是虚拟老师，user_id字段必须填写虚拟老师的ID
   */
  arbitration_teacher?: ExamSimpleTeacherInfo[];
  /**
   * @Description 分校分配配置列表，当allocation_method不为quantity时必填，quantity方式不需要。
   * 每个配置项包含school_id(学校ID)、allocation_method(分配类型)、average(平均分配数量)
   * 分配类型：average-平均分配，proportional-按比例分配
   * 系统会根据此配置将任务按学校进行分配
   */
  branch_task_allocation?: ExamBranchTaskAllocation[];
  /**
   * @Description 评选方式，决定题目如何被评阅：
   * - single: 单评，每个题目只由一位教师评阅
   * - double: 双评，每个题目由两位教师评阅，系统会计算平均分或取最高分
   * - part: 部分评，每个题目由一位教师评阅，系统会计算部分得分
   * - multi: 多评，每个题目由多位教师评阅，系统会计算平均分或取最高分
   * - none: 无仲裁多评
   * 注意：双评模式下需要确保有足够的阅卷老师
   * @example "double"
   */
  evaluate_method?: ServiceTaskAllocationRequestEvaluateMethodEnum;
  /**
   * @Description 评阅规则JSON字符串，用于存储具体的评阅规则配置
   * 注意：此字段为可选字段，用于存储复杂的评阅规则配置，如评分标准、容错范围等
   * @example "{"tolerance": 0.5, "max_diff": 2.0}"
   */
  evaluate_rules?: string;
  /**
   * @Description 题目满分值，用于计算得分比例和统计。必须是正数，建议与题目实际满分保持一致
   * @example 10
   */
  full_score?: number;
  /**
   * @Description 组长列表，可选字段。组长负责监督阅卷质量和进度。
   * 每个组长包含id(教师ID)、name(教师姓名)、is_virtual(是否为虚拟老师)和user_id(虚拟老师ID)四个字段
   * 系统会自动为组长设置teacher_type=3
   * 注意：如果是虚拟老师，user_id字段必须填写虚拟老师的ID
   */
  group_leader?: ExamSimpleTeacherInfo[];
  /**
   * @Description 题目ID，用于标识要更新的具体题目。必须是已存在的题目ID，系统会根据此ID查找对应的题目记录进行更新
   * @example 1001
   */
  id?: number;
  /**
   * @Description 联考模式，决定考试的组织方式：
   * - single: 单校模式，适用于单个学校的考试
   * - branch: 分校模式，适用于分校考试
   * - mixed: 混合模式，适用于分校和单校混合考试
   * 联考模式下必须提供branch_task_allocation配置
   * @example "mixed"
   */
  joint_mode?: ServiceTaskAllocationRequestJointModeEnum;
  /**
   * @Description 阅卷老师列表，必填字段。阅卷老师负责具体的题目评阅工作。
   * 每个阅卷老师包含id(教师ID)、name(教师姓名)、is_virtual(是否为虚拟老师)和user_id(虚拟老师ID)四个字段
   * 系统会自动为阅卷老师设置teacher_type=1
   * 注意：阅卷老师数量必须满足评选方式的要求，双评模式下至少需要2位阅卷老师
   * 注意：如果是虚拟老师，user_id字段必须填写虚拟老师的ID
   */
  marking_teacher?: ExamSimpleTeacherInfo[];
  /**
   * @Description 数量分配配置列表，当allocation_method为quantity时必填，其他情况不需要。
   * 每个配置项包含school_id(学校ID)、teacher_id(教师ID)、teacher_name(教师姓名)、task_quantity(分配数量)
   * 系统会根据此配置将指定数量的任务分配给对应教师
   * 注意：所有配置的task_quantity总和应该等于或接近总任务数
   */
  quantity_task_allocation?: ExamQuantityTaskAllocation[];
}

export interface ServiceTaskAllocationReuseRequest {
  /**
   * efficiency-效率优先,quantity-定量分配,average-平均分配
   * 注意：选择quantity时必须提供quantity_task_allocation配置，选择其他方式时必须提供branch_task_allocation配置
   * @example "quantity"
   */
  allocation_method?: ServiceTaskAllocationReuseRequestAllocationMethodEnum;
  /**
   * @Description 仲裁老师列表，可选字段。仲裁老师负责处理阅卷争议和最终评分裁定。
   * 每个仲裁老师包含id(教师ID)、name(教师姓名)、is_virtual(是否为虚拟老师)和user_id(虚拟老师ID)四个字段
   * 系统会自动为仲裁老师设置teacher_type=2
   * 注意：如果是虚拟老师，user_id字段必须填写虚拟老师的ID
   */
  arbitration_teacher?: ExamSimpleTeacherInfo[];
  /**
   * @Description 分校分配配置列表，当allocation_method不为quantity时必填，quantity方式不需要。
   * 每个配置项包含school_id(学校ID)、allocation_method(分配类型)、average(平均分配数量)
   * 分配类型：average-平均分配，proportional-按比例分配
   * 系统会根据此配置将任务按学校进行分配
   */
  branch_task_allocation?: ExamBranchTaskAllocation[];
  /**
   * @Description 评选方式，决定题目如何被评阅：
   * - single: 单评，每个题目只由一位教师评阅
   * - double: 双评，每个题目由两位教师评阅，系统会计算平均分或取最高分
   * - part: 部分评，每个题目由一位教师评阅，系统会计算部分得分
   * - multi: 多评，每个题目由多位教师评阅，系统会计算平均分或取最高分
   * - none: 无仲裁多评
   * 注意：双评模式下需要确保有足够的阅卷老师
   * @example "double"
   */
  evaluate_method?: ServiceTaskAllocationReuseRequestEvaluateMethodEnum;
  /**
   * @Description 评阅规则JSON字符串，用于存储具体的评阅规则配置
   * 注意：此字段为可选字段，用于存储复杂的评阅规则配置，如评分标准、容错范围等
   * @example "{"tolerance": 0.5, "max_diff": 2.0}"
   */
  evaluate_rules?: string;
  /**
   * @Description 题目满分值，用于计算得分比例和统计。必须是正数，建议与题目实际满分保持一致
   * @example 10
   */
  full_score?: number;
  /**
   * @Description 组长列表，可选字段。组长负责监督阅卷质量和进度。
   * 每个组长包含id(教师ID)、name(教师姓名)、is_virtual(是否为虚拟老师)和user_id(虚拟老师ID)四个字段
   * 系统会自动为组长设置teacher_type=3
   * 注意：如果是虚拟老师，user_id字段必须填写虚拟老师的ID
   */
  group_leader?: ExamSimpleTeacherInfo[];
  /**
   * @Description 题目ID，用于标识要更新的具体题目。必须是已存在的题目ID，系统会根据此ID查找对应的题目记录进行更新
   * @example 1001
   */
  id?: number;
  /**
   * @Description 联考模式，决定考试的组织方式：
   * - single: 单校模式，适用于单个学校的考试
   * - branch: 分校模式，适用于分校考试
   * - mixed: 混合模式，适用于分校和单校混合考试
   * 联考模式下必须提供branch_task_allocation配置
   * @example "mixed"
   */
  joint_mode?: ServiceTaskAllocationReuseRequestJointModeEnum;
  /**
   * @Description 阅卷老师列表，必填字段。阅卷老师负责具体的题目评阅工作。
   * 每个阅卷老师包含id(教师ID)、name(教师姓名)、is_virtual(是否为虚拟老师)和user_id(虚拟老师ID)四个字段
   * 系统会自动为阅卷老师设置teacher_type=1
   * 注意：阅卷老师数量必须满足评选方式的要求，双评模式下至少需要2位阅卷老师
   * 注意：如果是虚拟老师，user_id字段必须填写虚拟老师的ID
   */
  marking_teacher?: ExamSimpleTeacherInfo[];
  options?: number[];
  /**
   * @Description 数量分配配置列表，当allocation_method为quantity时必填，其他情况不需要。
   * 每个配置项包含school_id(学校ID)、teacher_id(教师ID)、teacher_name(教师姓名)、task_quantity(分配数量)
   * 系统会根据此配置将指定数量的任务分配给对应教师
   * 注意：所有配置的task_quantity总和应该等于或接近总任务数
   */
  quantity_task_allocation?: ExamQuantityTaskAllocation[];
  question_ids?: number[];
}

export interface ServiceUpdateAnswerSheetRequest {
  /** 答题卡组件ID */
  component_id?: string;
  /** 答题卡组件信息 */
  component_info?: string;
  /** 答题卡图片相对路径 */
  image_url?: string;
  /** 答题卡名称 */
  name?: string;
  /** 答题卡PDF相对路径 */
  pdf_url?: string;
  /** 答题卡AI识别信息 */
  recognition_info?: string;
  /** 答题卡图片模版ID */
  tpl_url?: string;
}

export interface ServiceUploadProgress {
  expires_at?: string;
  filename?: string;
  progress?: number;
  session_id?: string;
  status?: string;
  total_chunks?: number;
  total_size?: number;
  uploaded_chunk_indexes?: number[];
  uploaded_chunks?: number;
}

export interface ServiceUploadToken {
  /** 阿里云OSS要求 */
  OSSAccessKeyId?: string;
  /** 前端使用 */
  accessKeyId?: string;
  bucket?: string;
  endpoint?: string;
  /** Key            string `json:"key"` */
  expires?: number;
  policy?: string;
  region?: string;
  signature?: string;
}

/**
 * @Description AI题目类型，用于AI识别和自动评分：
 * - objective: 客观题，如选择题、判断题等，可以自动评分
 * - subjective: 主观题，如简答题、论述题等，需要人工评分
 * 注意：此字段影响AI识别和自动评分的行为
 * @example "objective"
 */
export enum ExamBatchUpdateTemplateQuestionRequestAiQuestionTypeEnum {
  Objective = 'objective',
  Subjective = 'subjective'
}

/**
 * @Description 分配方式，决定任务如何分配给教师：
 * - efficiency: 效率优先，系统根据教师历史阅卷效率自动分配
 * - quantity: 定量分配，手动指定每个教师分配的具体任务数量
 * - student: 按学生分配，根据学生数量进行分配
 * 注意：选择quantity时必须提供quantity_task_allocation配置
 * @example "efficiency"
 */
export enum ExamBatchUpdateTemplateQuestionRequestAllocationMethodEnum {
  Efficiency = 'efficiency',
  Quantity = 'quantity',
  Student = 'student'
}

/**
 * @Description 答案得分类型，决定答案的评分方式：
 * - standard: 标准，按标准答案评分
 * - different: 不同选项，不同选项有不同分值
 * - number: 正确选项个数，按正确选项数量评分
 * 注意：此字段主要用于多选题和复杂评分场景
 * @example "standard"
 */
export enum ExamBatchUpdateTemplateQuestionRequestAnswerScoreTypeEnum {
  Standard = 'standard',
  Different = 'different',
  Number = 'number'
}

/**
 * @Description 评阅方式，决定题目如何被评阅：
 * - single: 单评，每个题目只由一位教师评阅
 * - double: 双评，每个题目由两位教师评阅，系统会计算平均分或取最高分
 * - part: 部分评，每个题目由一位教师评阅，系统会计算部分得分
 * - multi: 多评，每个题目由多位教师评阅，系统会计算平均分或取最高分
 * - none: 无仲裁多评
 * 注意：双评模式下需要确保有足够的阅卷老师
 * @example "single"
 */
export enum ExamBatchUpdateTemplateQuestionRequestEvaluateMethodEnum {
  Single = 'single',
  Double = 'double',
  Part = 'part',
  Multi = 'multi',
  None = 'none'
}

/**
 * @Description 联考模式，决定考试的组织方式：
 * - single: 单校模式，适用于单个学校的考试
 * - branch: 分校模式，适用于分校考试
 * - mixed: 混合模式，适用于分校和单校混合考试
 * 注意：联考模式下必须提供branch_task_allocation配置
 * @example "single"
 */
export enum ExamBatchUpdateTemplateQuestionRequestJointModeEnum {
  Single = 'single',
  Branch = 'branch',
  Mixed = 'mixed'
}

/**
 * @Description 题目类型，题目的具体类型：
 * - single: 单选题，只有一个正确答案
 * - multiple: 多选题，有多个正确答案
 * - judge: 判断题
 * - answer: 解答题
 * - fill: 填空题
 * - composition: 作文题
 * - optional: 选做题
 * 注意：此字段影响答题卡的设计和评分逻辑
 * @example "single"
 */
export enum ExamBatchUpdateTemplateQuestionRequestQuestionTypeEnum {
  Single = 'single',
  Multiple = 'multiple',
  Judge = 'judge',
  Answer = 'answer',
  Fill = 'fill',
  Composition = 'composition',
  Optional = 'optional'
}

/**
 * @Description 得分类型，决定如何计算得分：
 * - zero: 零分
 * - full: 满分
 * 注意：此字段影响评分逻辑，建议与题目类型匹配
 * @example "full"
 */
export enum ExamBatchUpdateTemplateQuestionRequestScoreTypeEnum {
  Full = 'full',
  Zero = 'zero'
}

/**
 * @Description 打分模式，决定如何计算最终得分：
 * - total: 总分，直接使用评阅得分
 * - partial: 部分分，根据部分正确情况计算得分
 * 注意：此字段影响最终得分的计算方式
 * @example "total"
 */
export enum ExamBatchUpdateTemplateQuestionRequestScoringModeEnum {
  Total = 'total',
  Partial = 'partial'
}

/**
 * @Description 分配类型，决定该学校的任务分配方式：
 * - average: 平均分配，系统会将任务平均分配给该学校的教师
 * - proportional: 按比例分配，系统会根据该学校的学生数量按比例分配任务
 * 注意：选择proportional时，系统会自动计算分配比例，Average字段可能被忽略
 * @example "average"
 */
export enum ExamBranchTaskAllocationAllocationMethodEnum {
  Average = 'average',
  Proportional = 'proportional'
}

/** 上传状态筛选 */
export enum ExamClassMatchRequestUploadStatusEnum {
  Uploaded = 'uploaded',
  Lack = 'lack',
  None = 'none'
}

/** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
export enum ExamCreateExamSubjectAnswerSheetTemplateRequestAnswerSheetTypeEnum {
  New = 'new',
  Pdf = 'pdf',
  AnswerSheet = 'answer_sheet'
}

/** 删除类型：1-清空paper_url，2-清空paper_answer_url */
export enum ExamDeletePaperRequestTypeEnum {
  Value1 = 1,
  Value2 = 2
}

/** 模板类型：detail-小题分模式，total-总分模式 */
export enum ExamGenerateScoreTemplateRequestTypeEnum {
  Detail = 'detail',
  Total = 'total'
}

/** 重阅类型 */
export enum ExamRereadMarkingRequestRereadTypeEnum {
  All = 'all',
  Score = 'score',
  Time = 'time'
}

/** 恢复类型：subject-考试科目，question-题目 */
export enum ExamResumeMarkingRequestResumeTypeEnum {
  Subject = 'subject',
  Question = 'question'
}

/** 问题卷类型 */
export enum ExamSetProblemRecordRequestProblemTypeEnum {
  ImageFog = 'image_fog',
  FooterMissing = 'footer_missing'
}

/**
 * 科目类型，必填，枚举值：单科、综合科、选科
 * @example "单科"
 */
export enum ExamSplitCompositeSubjectRequestTypeEnum {
  Value单科 = '单科',
  Value综合科 = '综合科',
  Value选科 = '选科'
}

/** 学生类型：all/normal/absent（默认all） */
export enum ExamStudentScoreListRequestStudentTypeEnum {
  All = 'all',
  Normal = 'normal',
  Absent = 'absent'
}

/** 暂停类型：subject-考试科目，question-题目 */
export enum ExamSuspendMarkingRequestSuspendTypeEnum {
  Subject = 'subject',
  Question = 'question'
}

/** 答题卡类型：new-新建，pdf-PDF文件，answer_sheet-已有答题卡 */
export enum ExamUpdateExamSubjectAnswerSheetTemplateRequestAnswerSheetTypeEnum {
  New = 'new',
  Pdf = 'pdf',
  AnswerSheet = 'answer_sheet'
}

/** 分析类型 */
export enum ExamStatisticsQuestionAnalysisRequestVoAnalysisTypeEnum {
  Question = 'question',
  MajorQuestion = 'major_question',
  ObjectiveSubjective = 'objective_subjective'
}

/** 查询模式：class(按班级), school(按学校，用于联考) */
export enum ExamStatisticsQuestionAnalysisRequestVoQueryModeEnum {
  Class = 'class',
  School = 'school'
}

/** 查询模式：class(按班级), school(按学校，用于联考) */
export enum ExamStatisticsQuestionExcelExportRequestVoQueryModeEnum {
  Class = 'class',
  School = 'school'
}

/** 查询模式：class(按班级), school(按学校，用于联考) */
export enum ExamStatisticsQuestionRankingRequestVoQueryModeEnum {
  Class = 'class',
  School = 'school'
}

/** 查询模式：class(按班级), school(按学校，用于联考) */
export enum ExamStatisticsScoreRankingRequestVoQueryModeEnum {
  Class = 'class',
  School = 'school'
}

/** 权限设置 */
export enum ModelCreateExamAnalysisSettingRequestVisibilityEnum {
  Private = 'private',
  Public = 'public'
}

/**
 * 科目类型，必填，枚举值：单科、综合科、选科
 * @example "单科"
 */
export enum ModelCreateSubjectRequestTypeEnum {
  Value单科 = '单科',
  Value综合科 = '综合科',
  Value选科 = '选科'
}

/** 显著类型：up-上升，down-下降，key-重点学生，wave-成绩波动                                                                // 是否隐藏缺考，默认false */
export enum ModelGetKeyStudentRequestEmphasisTypeEnum {
  Up = 'up',
  Down = 'down',
  Key = 'key',
  Wave = 'wave'
}

/** 权限设置 */
export enum ModelUpdateExamAnalysisSettingRequestVisibilityEnum {
  Private = 'private',
  Public = 'public'
}

/**
 * 科目类型，可选，枚举值：单科、综合科、选科
 * @example "单科"
 */
export enum ModelUpdateSubjectRequestTypeEnum {
  Value单科 = '单科',
  Value综合科 = '综合科',
  Value选科 = '选科'
}

/**
 * efficiency-效率优先,quantity-定量分配,average-平均分配
 * 注意：选择quantity时必须提供quantity_task_allocation配置，选择其他方式时必须提供branch_task_allocation配置
 * @example "quantity"
 */
export enum ServiceTaskAllocationRequestAllocationMethodEnum {
  Efficiency = 'efficiency',
  Quantity = 'quantity',
  Student = 'student'
}

/**
 * @Description 评选方式，决定题目如何被评阅：
 * - single: 单评，每个题目只由一位教师评阅
 * - double: 双评，每个题目由两位教师评阅，系统会计算平均分或取最高分
 * - part: 部分评，每个题目由一位教师评阅，系统会计算部分得分
 * - multi: 多评，每个题目由多位教师评阅，系统会计算平均分或取最高分
 * - none: 无仲裁多评
 * 注意：双评模式下需要确保有足够的阅卷老师
 * @example "double"
 */
export enum ServiceTaskAllocationRequestEvaluateMethodEnum {
  Single = 'single',
  Double = 'double',
  Part = 'part',
  Multi = 'multi',
  None = 'none'
}

/**
 * @Description 联考模式，决定考试的组织方式：
 * - single: 单校模式，适用于单个学校的考试
 * - branch: 分校模式，适用于分校考试
 * - mixed: 混合模式，适用于分校和单校混合考试
 * 联考模式下必须提供branch_task_allocation配置
 * @example "mixed"
 */
export enum ServiceTaskAllocationRequestJointModeEnum {
  Single = 'single',
  Branch = 'branch',
  Mixed = 'mixed'
}

/**
 * efficiency-效率优先,quantity-定量分配,average-平均分配
 * 注意：选择quantity时必须提供quantity_task_allocation配置，选择其他方式时必须提供branch_task_allocation配置
 * @example "quantity"
 */
export enum ServiceTaskAllocationReuseRequestAllocationMethodEnum {
  Efficiency = 'efficiency',
  Quantity = 'quantity',
  Student = 'student'
}

/**
 * @Description 评选方式，决定题目如何被评阅：
 * - single: 单评，每个题目只由一位教师评阅
 * - double: 双评，每个题目由两位教师评阅，系统会计算平均分或取最高分
 * - part: 部分评，每个题目由一位教师评阅，系统会计算部分得分
 * - multi: 多评，每个题目由多位教师评阅，系统会计算平均分或取最高分
 * - none: 无仲裁多评
 * 注意：双评模式下需要确保有足够的阅卷老师
 * @example "double"
 */
export enum ServiceTaskAllocationReuseRequestEvaluateMethodEnum {
  Single = 'single',
  Double = 'double',
  Part = 'part',
  Multi = 'multi',
  None = 'none'
}

/**
 * @Description 联考模式，决定考试的组织方式：
 * - single: 单校模式，适用于单个学校的考试
 * - branch: 分校模式，适用于分校考试
 * - mixed: 混合模式，适用于分校和单校混合考试
 * 联考模式下必须提供branch_task_allocation配置
 * @example "mixed"
 */
export enum ServiceTaskAllocationReuseRequestJointModeEnum {
  Single = 'single',
  Branch = 'branch',
  Mixed = 'mixed'
}

/** 排序字段（选填） */
export enum CheckScoreListParamsOrderByEnum {
  TimeAsc = 'time_asc',
  TimeDesc = 'time_desc',
  ScoreAsc = 'score_asc',
  ScoreDesc = 'score_desc'
}

/** 排序字段（选填） */
export enum ExportTeacherDetailListParamsOrderByEnum {
  TimeAsc = 'time_asc',
  TimeDesc = 'time_desc',
  ScoreAsc = 'score_asc',
  ScoreDesc = 'score_desc'
}

/**
 * 排序字段：1-按打分从小到大 排序，2-按打分从大到小排序，3-按时间从早到晚排序，4-按时间从晚到在排序
 * @default 1
 */
export enum HistoryDetailParamsOrderByEnum {
  Value1 = 1,
  Value2 = 2,
  Value3 = 3,
  Value4 = 4
}

/** 科目类型筛选：传'选科'时只返回选考科目，其他情况返回非选考科目 */
export enum SubjectsListParams1TypeEnum {
  Value单科 = '单科',
  Value综合科 = '综合科',
  Value选科 = '选科'
}
