declare module 'api-type' {
  import type { AxiosRequestConfig } from 'axios'
  export type BaseMultiplePageQuery = { pageNumber: number; pageSize: number }
  type BaseMultiplePageResult = {
    pageCount: number
    pageNumber: number
    pageSize: number
    totalCount: number
  }

  export type MultipleQuery<T extends object> = BaseMultiplePageQuery & T
  export type MultipleResult<T> = BaseMultiplePageResult & { result: T[] }

  type BaseDefine<P = null, R = null, O = null> = {
    params: P
    result: R
  }

  export type ApiMap = User.ApiMap &
    Role.ApiMap &
    Exam.ApiMap &
    Subject.ApiMap &
    Statistics.ApiMap &
    Question.ApiMap &
    Marking.ApiMap &
    System.ApiMap &
    Message.ApiMap &
    ForceCheck.ApiMap &
    Expert.ApiMap

  export type ApiKeys = keyof ApiMap

  export type DefineApiModule<M extends object> = {
    [k in keyof M]: string | (AxiosRequestConfig & { url: string })
  }

  export type ExtractApiParams<T extends ApiKeys> = ApiMap[T] extends BaseDefine<infer P, any> ? P : never

  export type ExtractMultipleApiParams<T extends ApiKeys> = ExtractApiParams<T> extends MultipleQuery<infer P>
    ? P
    : never

  export type ExtractApiResponse<T extends ApiKeys> = ApiMap[T] extends BaseDefine<any, infer R> ? R : never

  export type ExtractMultipleApiResponse<T extends ApiKeys> = ExtractApiResponse<T> extends MultipleResult<infer R>
    ? R
    : never

  /** 专家卷浏览 */

  export namespace Expert {
    interface SamplePaperListItem {
      createName: string
      createTime: string
      fileName: string
      filePath: string
      id: number
      mainNumber: number
      paperType: string
      score: number
      secretNumber: number
      type: string
    }
    type GetSampleList = BaseDefine<
      MultipleQuery<{ mainNumber?: number; paperType: 'SAMPLE_A' | 'SAMPLE_B' }>,
      MultipleResult<SamplePaperListItem>
    >

    interface RfSampleListItem {
      createName: string
      createTime: string
      filePath: string
      id: number
      mainName: string
      mainNumber: number
      score: number
      scoreLevel: string
      secretNumber: number
    }

    type GetRfSampleList = BaseDefine<MultipleQuery<{ mainNumber?: number }>, MultipleResult<RfSampleListItem>>

    type UpdateMarkScore = BaseDefine<{ id?: number; scores: number[] }>

    interface StandardListItem {
      createName: string
      createTime: string
      fileName: string
      filePath: string
      id: number
      mainNumber: number
      score: number
      secretNumber: number
      taskId: number
    }

    type GetStandardList = BaseDefine<
      MultipleQuery<{
        mainNumber?: number
        dispensed: boolean | ''
        scoreStart?: number | string
        scoreEnd?: number | string
      }>,
      MultipleResult<StandardListItem>
    >

    type TransformStandardToSample = BaseDefine<{ id?: number }>

    interface ExpertAssessListItem {
      createName: string
      createTime: string
      filePath: string
      forceGroupNumber: number
      id: number
      mainName: string
      mainNumber: number
      score: number
      secretNumber: number
    }

    type GetExpertAssessList = BaseDefine<
      MultipleQuery<{
        mainNumber?: number
        forceGroupNumber?: number
      }>,
      MultipleResult<ExpertAssessListItem>
    >

    interface ExpertPickListItem {
      createName: string
      createTime: string
      filePath: string
      forceGroupNumber: number
      id: number
      mainName: string
      mainNumber: number
      role: string
      roleName: string
      score: number
      secretNumber: number
    }

    type GetExpertPickList = BaseDefine<
      MultipleQuery<{
        mainNumber?: number
        forceGroupNumber?: number
        paperType: ExpertPickType
        role: Exclude<ROLE, 'ADMIN'>
      }>,
      MultipleResult<ExpertPickListItem>
    >

    type DeletePaper = BaseDefine<{ id?: number }>

    export interface ApiMap {
      /** AB培训卷 */
      getSampleList: GetSampleList
      /** RF卷 */
      getRfSampleList: GetRfSampleList
      /** 修改分数 */
      updateMarkScore: UpdateMarkScore
      /** 获取标准卷 */
      getStandardList: GetStandardList
      /** 标准卷转样卷 */
      transformStandardToSample: TransformStandardToSample
      /** 强制考核卷列表 */
      getExpertAssessList: GetExpertAssessList
      /** 专家挑选卷 */
      getExpertPickList: GetExpertPickList
      /** 删除 */
      deletePaper: DeletePaper
    }
  }

  /** 强制考核接口 */
  export namespace ForceCheck {
    /** 分发考核卷 */
    type HandOutForceCheck = BaseDefine<{
      forceGroupNumber?: number
      mainNumber?: number
      markerIds: number[]
      subjectCode: string
    }>
    /** 获取考核卷组 */
    interface ForceCheckGroup {
      createTime: string
      creatorId: number
      examId: number
      forceGroupNumber: number
      id: number
      mainNumber: number
      subjectCode: string
      updateTime: string
      updaterId: number
    }
    type GetForceCheckGroupList = BaseDefine<{ mainNumber?: number; subjectCode: string }, ForceCheckGroup[]>
    /** 获取分发进度 */
    interface HandOutProgress {
      /** 已评量 */
      finishCount: number
      /** 强制卷组号 */
      forceGroupNumber: number
      /** 大题 */
      mainQuestion: string
      /** 评卷员 */
      marker: string
      /** 小组号 */
      markingGroupNumber: number
      /** 未评量 */
      pendingCount: number
      /** 科目 */
      subject: string
      /** 总量 */
      totalCount: number
    }
    type GetHandOutProgressList = BaseDefine<
      { mainNumber?: number; subjectCode: string; forceGroupNumber?: number },
      HandOutProgress[]
    >
    export interface ApiMap {
      /** 分发考核卷 */
      handOutForceCheck: HandOutForceCheck
      /** 获取考核卷组 */
      getForceCheckGroupList: GetForceCheckGroupList
      /** 获取分发进度 */
      getHandOutProgressList: GetHandOutProgressList
    }
  }

  /** 消息接口 */

  export namespace Message {
    interface BaseMessageResponse {
      content: string
      receiveUserId: number
      receiveUserName: string
      sendTime: string
      sendUserId: number
      sendUserName: string
      taskId: number
    }
    /** 历史消息 */
    type GetUserHistory = BaseDefine<{ sendUserId: number }, BaseMessageResponse[]>
    /** 历史消息列表 */
    type GetHistory = BaseDefine<null, BaseMessageResponse[]>
    /** 发送/回复消息 */
    type SendMessage = BaseDefine<{ taskId?: number; content: string; receiveUserIds: number[] }>
    export interface ApiMap {
      getUserHistory: GetUserHistory
      getHistory: GetHistory
      sendMessage: SendMessage
    }
  }

  /** meta data  基础数据导入配置 */
  export namespace System {
    /** 评卷数据导入 */
    interface MarkingDataImport {
      dayNumber?: number
      file?: File
      mainNumber?: number
      separator: string
      subjectCode: string
    }

    type ImportMarkingData = BaseDefine<MarkingDataImport>

    /** 获取导入文件路径 */
    type GetImportFilePath = BaseDefine<
      null,
      { rfPath: string; sampleAPath: string; sampleBPath: string; markStandardPath: string }
    >

    interface SamplePaperImport {
      file?: File
      /** 大题号 */
      mainNumber?: number
      /** 试卷类型 */
      paperType?: PaperType
      /** 试卷密码前缀 */
      prefix: string
      /** 分隔符 */
      separator: string
      /** 科目代码 */
      subjectCode: string
    }

    type ImportSamplePaper = BaseDefine<SamplePaperImport>

    interface RfPaperImport {
      file?: File
      /** 试卷密码前缀 */
      prefix: string
      /** 大题号 */
      mainNumber?: number
      /** 科目代码 */
      subjectCode: string
      /** 分隔符 */
      separator: string
    }

    type ImportRfPaper = BaseDefine<RfPaperImport>

    interface MarkStandardImport {
      file?: File
      /** 大题号 */
      mainNumber?: number
      /** 科目代码 */
      subjectCode: string
    }

    type ImportMarkStandard = BaseDefine<MarkStandardImport>

    interface ScoreListItem {
      /** 准考证号 */
      examNumber: string
      firstMarker: string
      firstScore: number
      id: number
      subject: string
      subjectCode: string
    }

    type GetCetScoreList = BaseDefine<MultipleQuery<{ subjectCode: string }>, MultipleResult<ScoreListItem>>

    type ExportCetScoreList = BaseDefine<{ subjectCode: string }, null>
    export interface ApiMap {
      importMarkingData: ImportMarkingData
      getImportFilePath: GetImportFilePath
      importSamplePaper: ImportSamplePaper
      importRfPaper: ImportRfPaper
      importMarkStandard: ImportMarkStandard
      getCetScoreList: GetCetScoreList
      exportCetScoreList: ExportCetScoreList
    }
  }

  /** 评卷相关 */
  export namespace Marking {
    /** 自定义查询 - 抽查 */

    // 查询参数
    interface CustomQuery {
      /** 是否包含仲裁 */
      arbitration?: boolean
      /** 是否已抽查 */
      checked?: boolean
      /** 大题号 */
      mainNumber?: number
      /** 评卷员id */
      markerId?: number
      /** 小组号 */
      markingGroupNumber?: number
      /** 分数截止 */
      scoreEnd?: number
      /** 分数开始 */
      scoreStart?: number
      /** 科目代码 */
      subjectCode?: string
      /** 时间截止 */
      timeEnd?: string
      /** 时间开始 */
      timeStart?: string
      /** 密号 */
      secretNumber?: string
    }

    /** 自定义抽查任务列表 */
    interface CustomQueryTask {
      customCheckNumber: number
      examNumber: string
      filePath: string
      mainNumber: number
      markTime: string
      markerName: string
      markerScore: number
      secretNumber: string
      taskId: number
    }
    type GetCustomQueryTasks = BaseDefine<MultipleQuery<CustomQuery>, MultipleResult<CustomQueryTask>>

    type SetCustomQueryConfig = BaseDefine<{ name: string; params: CustomQuery }>

    type GetCustomQueryConfigList = BaseDefine<{ name: string }, { name: string; params: CustomQuery }[]>

    type GetMarkingStandard = BaseDefine<null, { examId: number; mainNumber: number; subjectCode: string; url: string }>

    interface Question {
      intervalScore: number
      subNumber: string
      totalScore: number
    }
    interface Task {
      mainNumber: number
      mainTitle: string
      questionList: Question[]
      secretNumber: string
      subjectCode: string
      taskId: number
      taskType: TaskType
      url: string
    }

    type GetMarkingTask = BaseDefine<null, Task>

    interface MarkStatus {
      markedCount: number
      personCount: number
      problemCount: number
      totalCount: number
    }

    type GetMarkStatus = BaseDefine<null, MarkStatus>

    interface SubmitMark {
      markScore: number
      markScores: number[]
      spentTime: number
      taskId: number
      problem: boolean
      problemType?: ProblemType
    }

    type SubmitMarkTask = BaseDefine<SubmitMark, MarkStatus>

    interface HistoryTask {
      mainNumber: number
      mainTitle: number
      markScore: number
      markTime: string
      markerScores: number[]
      questionList: Question[]
      secretNumber: string
      subjectCode: string
      taskId: number
      taskType: string
      url: string
    }

    type GetMarkHistory = BaseDefine<null, HistoryTask[]>

    interface ProblemListParams {
      mainNumber?: number
      problemType: ProblemType | ''
      status: '' | 'INITIAL' | 'PROCESSED'
    }

    interface ProblemListItem {
      createTime: string
      examNumber: string
      filePath: string
      headerName: number
      headerScore: number
      headerScores: number[]
      id: number
      mainNumber: number
      mainName: string
      markerName: string
      markerRatio: string
      markerScore: number
      objectiveScore: number
      problemSolveType: string
      problemType: string
      secretNumber: string
      solveTime: string
      taskId: number
    }

    type GetProblemHistory = BaseDefine<MultipleQuery<ProblemListParams>, MultipleResult<ProblemListItem>>

    type MarkProblemPaper = BaseDefine<{ id?: number; scores: number[] }>

    interface MarkScoreHistory {
      id: number
      markScore: number
      markerName: string
      markTime: string
      secretNumber: string
      status: string
      taskId: number
      url: string
    }

    type GetMarkScoreHistoryListWithTask = BaseDefine<{ taskId: number }, MarkScoreHistory[]>

    type GetMarkScoreHistoryListWithSecret = BaseDefine<{ secretNumber: number }, MarkScoreHistory[]>

    type RejectMarkHistory = BaseDefine<{ description: string; id: number; reason: string }>

    interface ArbitrationListItem {
      chiefName: string
      chiefRatio: string
      chiefScore: number
      deputyName: string
      deputyRatio: string
      deputyScore: number
      filePath: string
      groupLeaderName: string
      groupLeaderRatio: string
      groupLeaderScore: number
      id: number
      mainName: string
      mainNumber: number
      markerName: string
      markerRatio: string
      markerScore: number
      objectiveScore: number
      secretNumber: string
      status: string
      taskId: number
      teamLeaderName: string
      teamLeaderRatio: string
      teamLeaderScore: number
    }

    type GetArbitrationList = BaseDefine<
      MultipleQuery<{ mainNumber?: number; status: ArbitrationStatus | '' }>,
      MultipleResult<ArbitrationListItem>
    >

    type MarkArbitrationPaper = BaseDefine<{ id?: number; scores: number[] }>

    type ViewArbitrationPaper = BaseDefine<{ id?: number }>

    interface ReMarkPaperListItem {
      confirm: string
      confirmScore: number
      filePath: string
      id: number
      mainNumber: number
      mainName: string
      markerName: string
      markerScore: number
      reMarkTime: string
      secretNumber: string
      taskId: number
    }

    type GetReMarkPaperList = BaseDefine<
      MultipleQuery<{ mainNumber?: number; status: boolean }>,
      MultipleResult<ReMarkPaperListItem>
    >

    type MarkReMarkPaper = BaseDefine<{ id?: number; scores: number[] }>

    type ConfirmReMarkPaper = BaseDefine<{ id?: number }>

    interface TrainingRecord {
      examId: number
      markScore: number
      score: number
      secretNumber: string
      subjectCode: string
      taskId: number
      taskType: string
      url: string
    }

    type ViewTrainingRecord = BaseDefine<null, TrainingRecord[]>

    interface SamplePaper {
      description: string
      examId: number
      id: number
      mainNumber: number
      mainTitle: string
      markTime: string
      markerName: string
      score: number
      secretNumber: number
      subjectCode: string
      url: string
    }

    type ViewSamplePaper = BaseDefine<null, SamplePaper[]>

    interface SamePaperListItem {
      examNumber: string
      filePath: string
      id: number
      mainNumber: number
      markerName: string
      sameExamNumber: string
      sameFilePath: string
      sameSecretNumber: string
      secretNumber: number
      status: 'INITIAL' | 'NOT_SAME' | 'SAME'
      taskId: number
    }

    type GetSimilarPaperList = BaseDefine<
      MultipleQuery<{
        mainNumber?: number
        status: 'INITIAL' | 'NOT_SAME' | 'SAME'
      }>,
      MultipleResult<SamePaperListItem>
    >

    type ConfirmIsSimilar = BaseDefine<{ id?: number; same: boolean }>

    type ExportSimilarPaper = BaseDefine<
      MultipleQuery<{
        mainNumber?: number
        status: 'INITIAL' | 'NOT_SAME' | 'SAME'
      }>
    >

    export interface ApiMap {
      /** 自定义查询 - 抽查 */
      getCustomQueryTasks: GetCustomQueryTasks
      /** 自定义查询 - 保存为快捷查询 */
      setCustomQueryConfig: SetCustomQueryConfig
      /** 自定义查询 - 获取快捷查询列表 */
      getCustomQueryConfigList: GetCustomQueryConfigList
      /** 查看评分标准 */
      getMarkingStandard: GetMarkingStandard
      /** 获取评卷任务 */
      getMarkingTask: GetMarkingTask
      /** 获取评卷进度 */
      getMarkStatus: GetMarkStatus
      /** 提交评卷任务 */
      submitMarkTask: SubmitMarkTask
      /** 获取回评历史 */
      getMarkHistory: GetMarkHistory
      /** 问题卷列表 */
      getProblemHistory: GetProblemHistory
      /** 问题卷打分 */
      markProblemPaper: MarkProblemPaper
      /** 通过taskId 查询给分记录 */
      getMarkScoreHistoryListWithTask: GetMarkScoreHistoryListWithTask
      /** 通过secretNumber 查询给分记录 */
      getMarkScoreHistoryListWithSecret: GetMarkScoreHistoryListWithSecret
      /** 打回 */
      rejectMarkHistory: RejectMarkHistory
      /** 仲裁卷列表 */
      getArbitrationList: GetArbitrationList
      /** 仲裁卷打分 */
      markArbitrationPaper: MarkArbitrationPaper
      /** 仲裁卷浏览 */
      viewArbitrationPaper: ViewArbitrationPaper
      /** 重评卷列表 */
      getReMarkPaperList: GetReMarkPaperList
      /** 重评卷打分 */
      markReMarkPaper: MarkReMarkPaper
      /** 重评卷确认 */
      confirmReMarkPaper: ConfirmReMarkPaper
      /** 查看培训记录 */
      viewTrainingRecord: ViewTrainingRecord
      /** 查看样卷 */
      viewSamplePaper: ViewSamplePaper
      /** 雷同卷列表 */
      getSimilarPaperList: GetSimilarPaperList
      /** 是否雷同 */
      confirmIsSimilar: ConfirmIsSimilar
      /** 导出雷同 */
      exportSimilarPaper: ExportSimilarPaper
    }
  }

  /** 题目管理 */
  export namespace Question {
    /** 删除小题 */
    type DeleteSubQuestion = BaseDefine<{
      id: number
    }>

    /** 编辑小题 */
    type EditSubQuestion = BaseDefine<{
      id?: number
      /** 小题间隔分 */
      intervalScore?: number
    }>

    /** 小题列表信息 */
    interface SubQuestionInfo {
      id: number
      intervalScore: number
      mainNumber: number
      mainTitle: string
      subNumber: number
      totalScore: number
    }

    /** 获取小题列表 */
    type GetSubQuestionList = BaseDefine<{ subjectCode: string }, SubQuestionInfo[]>

    interface MainQuestionListItem {
      createTime: string
      creatorId: number
      examId: number
      groupNumber: number
      id: number
      levelRange: number[]
      mainNumber: number
      minMarkTime: number
      remarkNumber: number
      remarkType: string
      standardRate: number
      selfRate: number
      subjectCode: string
      systemRate: number
      title: string
      totalScore: number
      updateTime: string
      updaterId: number
    }

    /** 获取大题列表 */
    type GetMainQuestionList = BaseDefine<{ subjectCode: string }, MainQuestionListItem[]>

    interface SubQuestionStruct {
      intervalScore: number
      score: number
      subNumber: number
      totalScore: number
    }
    /** 获取大题评卷结构 */
    type GetQuestionStruct = BaseDefine<
      { mainNumber?: number },
      { mainNumber: number; mainTitle: string; questionList: SubQuestionStruct[] }
    >

    /** 大题设置 (新增/编辑) */
    interface MainQuestionMeta {
      /** 大题号 */
      mainNumber?: number
      /** 大题名称 */
      mainTitle: string
      /** 分组数量 */
      groupNumber?: number
      /** 间隔分 */
      intervalScore?: number
      /** 最小阅卷时间 */
      minMarkTime?: number
      /** 小题数量 */
      questionCount?: number
      /** 小题满分 */
      questionScore?: number
      /** 回评数量 */
      remarkNumber?: number
      /** 标准卷频度 */
      standardRate?: number
      /** 自查卷频度 */
      selfRate?: number
      /** 系统抽查频度 */
      systemRate?: number
      /** 起始题号 */
      startNumber: number
      /** 档次比例 */
      levelRange: number[]
      /** 回评方式,可用值:TIME,QUANTITY */
      remarkType: RemarkType
      /** 科目代码 */
      subjectCode: string
      /** 成绩表对应题目类型,可用值:COMPOSITION,TRANSLATE */
      category: QuestionCategory
    }

    /** 新增大题 */
    type AddMainQuestion = BaseDefine<MainQuestionMeta>

    /** 大题设置 */
    type EditMainQuestion = BaseDefine<MainQuestionMeta>

    /** 获取大题信息 */
    type GetMainQuestionInfo = BaseDefine<
      { mainNumber: number; subjectCode: string },
      MainQuestionMeta & { examId: number }
    >

    export interface ApiMap {
      deleteSubQuestion: DeleteSubQuestion
      editSubQuestion: EditSubQuestion
      getSubQuestionList: GetSubQuestionList
      addMainQuestion: AddMainQuestion
      editMainQuestion: EditMainQuestion
      getMainQuestionInfo: GetMainQuestionInfo
      getMainQuestionList: GetMainQuestionList
      /** 获取大题评卷结构 */
      getQuestionStruct: GetQuestionStruct
    }
  }

  /** 科目管理 */
  export namespace Subject {
    /** 删除科目 */
    type DeleteSubject = BaseDefine<{ id: number }>

    interface BaseSubjectInfo {
      /** 科目代码 */
      code: string
      /** 科目名称 */
      name: string
      /** 启用/禁用 */
      enable: boolean
    }

    interface SubjectInfo extends BaseSubjectInfo {
      /** 科目ID */
      id: number
      /** 考试ID */
      examId: number
      /** 考试名称 */
      examName: string
      /** 客观分 */
      objectiveScore: number
      /** 主观分 */
      subjectiveScore: number
      /** 试卷总分 */
      totalScore: number
    }

    /** 获取科目信息 */
    type GetSubjectInfo = BaseDefine<{ id: number }, SubjectInfo>

    /** 查询科目列表 */
    type GetSubjectList = BaseDefine<
      MultipleQuery<{
        /** 科目代码 */
        code?: string
        /** 科目名称 */
        name?: string
      }>,
      MultipleResult<SubjectInfo>
    >
    /** 新增/修改科目 */
    type SaveSubjectInfo = BaseDefine<BaseSubjectInfo & { id?: number }>

    /** 启用/禁用科目 */
    type ToggleEnableSubject = BaseDefine<{ ids: number[]; enable: boolean }>
    export interface ApiMap {
      /** 删除考试 */
      deleteSubject: DeleteSubject
      /** 获取考试信息 */
      getSubjectInfo: GetSubjectInfo
      /** 查询考试列表 */
      getSubjectList: GetSubjectList
      /** 新增/修改考试 */
      saveSubjectInfo: SaveSubjectInfo
      /** 启用/禁用科目 */
      toggleEnableSubject: ToggleEnableSubject
    }
  }

  /** 考试管理 */
  export namespace Exam {
    /** 删除考试 */
    type DeleteExam = BaseDefine<{ id: number }>

    /** 获取考试信息 */
    type GetExamInfo = BaseDefine<{ id: number }, Required<BaseExamInfo>>

    /** 查询考试列表 */
    type GetExamList = BaseDefine<
      MultipleQuery<{
        /** 考试状态 */
        enable?: boolean
        /** 考试名称 */
        name?: string
      }>,
      MultipleResult<{
        /** 考试状态 */
        enable: boolean
        /** 考试ID */
        id: number
        /** 考试名称 */
        name: string
        /** 更新时间 */
        updateTime: string
      }>
    >
    interface BaseExamInfo {
      id?: number
      /** 问题卷允许打回 */
      doubtReject: boolean
      /** 评卷模式 */
      markingMode: MarkMode
      /** 在线评卷时长 */
      maxMarkingDuration: number
      /** 考试名称 */
      name: string
      /** 抽查卷允许打回 */
      spotCheckReject: boolean
      /** 用户姓名收集 */
      userNameCollect: boolean
      enable: boolean
    }

    /** 新增/修改考试 */
    type SaveExamInfo = BaseDefine<Partial<BaseExamInfo>>

    /** 启用/禁用考试 */
    type ToggleEnableExam = BaseDefine<{ ids: number[]; enable: boolean }>
    export interface ApiMap {
      /** 删除考试 */
      deleteExam: DeleteExam
      /** 获取考试信息 */
      getExamInfo: GetExamInfo
      /** 查询考试列表 */
      getExamList: GetExamList
      /** 新增/修改考试 */
      saveExamInfo: SaveExamInfo
      /** 启用/禁用考试 */
      toggleEnableExam: ToggleEnableExam
    }
  }

  /** 用户管理 & 登录 */
  export namespace User {
    /** >>> user api <<< */
    /** 用户登录 */
    interface LoginResponse {
      accessToken: string
      activeTime: string
      allowIP: string[]
      denyIP: string[]
      identity: string
      secret: string
      sessionId: string
      // 名称
      name: string
      // 角色
      role: ROLE
      // 用户ID
      id: number
      // 考试批次ID
      examId: number
      // 大题ID
      mainNumber: number
      // 评卷员状态
      stage: STAGE
      // 科目代码
      subjectCode: string
    }
    type UserLogin = BaseDefine<
      {
        loginName: string
        password: string
      },
      LoginResponse
    >

    /** 导出用户 */
    type ExportUser = BaseDefine<{
      enable?: boolean
      role?: ROLE
      loginName?: string
      name?: string
      mainNumber?: number
      subjectCode?: string
    }>

    interface BaseUserInfo {
      examId?: number
      examName?: string
      loginName: string
      mainNumber?: number
      markingGroupNumber?: number
      name?: string
      role: ROLE
      subjectCode: string
      enable: boolean
    }

    interface ResponseUserInfo extends BaseUserInfo {
      id: number
      createTime: string
      groupId: number
      subjectName: string
      roleName: string
      updateTime: string
      updaterName: string
    }

    /** 新增修改用户信息 */
    type SaveUserInfo = BaseDefine<
      BaseUserInfo & {
        id?: number
        password: string
      }
    >

    /** 批量创建用户 */
    type BulkSaveUser = BaseDefine<{
      /** 启用/禁用 */
      enable: boolean
      /** 账号位数 */
      loginNameLength: number
      /** 大题ID */
      mainNumber?: number
      /** 分组账号数量 */
      markingGroupAccounts?: number
      /** 小组号 */
      markingGroupNumber?: number
      /** 密码 */
      password: string
      /** 自定义前缀 */
      prefix: string
      /** 角色 */
      role: ROLE
      /** 起始数 */
      start?: number
      /** 科目代码 */
      subjectCode: string
    }>

    /** 查询用户信息 */
    type GetUserInfo = BaseDefine<
      {
        id: number
      },
      ResponseUserInfo
    >
    /** 查询当前用户信息 */
    type GetMyUserInfo = BaseDefine<null, ResponseUserInfo>
    /** 查询用户列表 */
    type GetUserList = BaseDefine<
      MultipleQuery<{
        enable?: boolean
        role?: ROLE
        loginName?: string
        name?: string
        mainNumber?: number
        subjectCode?: string
      }>,
      MultipleResult<ResponseUserInfo>
    >
    /** 修改用户密码 */
    type UpdateUserPwd = BaseDefine<{ password: string }>
    /** 修改用户姓名 */
    type UpdateUserName = BaseDefine<{ name: string }>
    /** 重置指定用户密码 */
    type ResetUsersPwd = BaseDefine<{ userIds: number[] }>
    /** 启用/禁用用户 */
    type ToggleEnableUsers = BaseDefine<{ ids: number[]; enable: boolean }>

    interface PrivilegeInfo {
      code: string
      id: number
      name: string
      nodeCode: string
      nodeId: string
      nodeName: string
      parentId: number
      parentNodeId: string
      privilegeType: string
      privilegeUri: string
    }
    /** 获取当前用户菜单 */
    type GetUserPrivilege = BaseDefine<null, PrivilegeInfo>

    /** 超管选择考试 */
    type CheckExam = BaseDefine<{ examId: number }>

    /** 获取评卷员Tree */
    interface Marker {
      createTime: string
      enable: boolean
      examId: number
      examName: string
      id: number
      loginName: string
      mainNumber: number
      markingGroupNumber: number
      name: string
      role: string
      roleName: string
      subjectCode: string
      updateTime: string
      updaterName: string
    }

    type GetMarkerTree = BaseDefine<
      { subjectCode: string; mainNumber?: number; name: string },
      { markers: Marker[]; markingGroupNumber: number }[]
    >

    type GetMarkerList = BaseDefine<{ subjectCode: string; mainNumber?: number; markingGroupNumber?: number }, Marker[]>

    /** >>> user api end <<< */
    export interface ApiMap {
      userLogin: UserLogin
      userLogout: null
      exportUser: ExportUser
      downloadUserTemplate: null
      saveUserInfo: SaveUserInfo
      getUserInfo: GetUserInfo
      getMyUserInfo: GetMyUserInfo
      getUserList: GetUserList
      updateUserPwd: UpdateUserPwd
      resetUsersPwd: ResetUsersPwd
      toggleEnableUsers: ToggleEnableUsers
      checkExam: CheckExam
      bulkSaveUser: BulkSaveUser
      updateUserName: UpdateUserName
      getUserPrivilege: GetUserPrivilege
      getMarkerTree: GetMarkerTree
      getMarkerList: GetMarkerList
    }
  }

  /** 角色管理 */
  export namespace Role {
    /** role api  */
    interface RawRole {
      code: ROLE
      roleName: string
      updateTime: string
      updaterName: string
    }

    type getRoleList = BaseDefine<{ role?: ROLE }, RawRole[]>
    type getRolePrivilege = BaseDefine<
      { role: ROLE },
      {
        code: ROLE
        hasPrivilege: boolean
        id: number
        name: string
        nodeCode: string
        nodeId: number
        nodeName: string
        parentId: number
        parentNodeId: number
      }
    >

    type setRolePrivilege = BaseDefine<{ role: ROLE; privilegeIds: number[] }>

    /** role api end */

    export interface ApiMap {
      getRoleList: getRoleList
      getRolePrivilege: getRolePrivilege
      setRolePrivilege: setRolePrivilege
    }
  }

  /** 监控分析 */
  export namespace Statistics {
    interface BaseFilterOption {
      subjectCode?: string
      questionMainNumber?: number
      markingGroupNumbers?: number[]
    }

    /** 质量统计-自查一致性分析 */
    interface SelfCheckAnalysisReq {
      /** 结束时间，格式：yyyyMMddHHmmss */
      endTime: string
      /** 小组号 */
      markingGroupNumber?: number
      /** 大题号 */
      questionMainNumber?: number
      /** 开始时间，格式：yyyyMMddHHmmss */
      startTime: string
      /** 科目代码 */
      subjectCode: string
    }
    interface SelfCheckAnalysisResponse {
      /** 平均离差 */
      avgDiff: number
      /** 自查份数 */
      checkCount: number
      /** 评卷员ID */
      markerId: number
      /** 评卷员名称 */
      markerName: string
    }

    type SelfCheckAnalysis = BaseDefine<SelfCheckAnalysisReq, SelfCheckAnalysisResponse[]>

    /** 质量分析- 抽查情况统计 */
    interface StatisticCheckInfo {
      customCheckCount: number
      customCheckReScoreCount: number
      markerId: number
      markerName: string
      questionMainName: string
      questionMainNumber: number
      rejectCount: number
      sysCheckCount: number
      sysCheckReScoreCount: number
    }

    type StatisticCheckOverview = BaseDefine<
      {
        questionMainNumber?: number
        subjectCode: string
        markingGroupLeaderId?: number
      },
      StatisticCheckInfo[]
    >
    /** 质量统计-主观题校验列表 */
    interface SubjectiveListItem {
      filePath: string
      headerName: string
      headerScore: number
      mainName: string
      mainNumber: number
      markerScore: number
      secretNumber: number
      status: string
      taskId: number
      updateTime: string
    }

    type GetSubjectiveCheckList = BaseDefine<
      MultipleQuery<{
        subjectCode: string
        mainNumber?: number
        checked?: boolean
        rule: 'RULE1' | 'RULE2' | 'RULE3' | 'RULE4'
      }>,
      MultipleResult<SubjectiveListItem>
    >

    type SubjectiveCheckMark = BaseDefine<{ taskId?: number; scores: number[] }>

    type SubjectiveCheckConfirm = BaseDefine<{ taskId?: number }>

    /** 决策分析-评卷进度统计（整体） */
    interface MarkProgressResponse {
      /** 已完成数 */
      finishCount: number
      /** 完成比率 */
      finishRate: number
      /** 大题名称 */
      questionMainName: string
      /** 大题号 */
      questionMainNumber: number
      /** 预计耗时（秒） */
      takeTime: number
      /** 试卷总量 */
      totalPaper: number
    }

    type GetMarkProgress = BaseDefine<{ subjectCode: string }, MarkProgressResponse[]>

    /** 决策分析-评卷进度统计（按小组） */
    interface MarkProgressByGroup {
      dayFinishCount: number
      dayFinishRate: number
      finishCount: number
      finishRate: number
      markingGroupNumber: number
    }

    type GetMarkProgressByGroup = BaseDefine<
      { subjectCode: string; questionMainNumber?: number },
      MarkProgressByGroup[]
    >

    /** 决策分析-评卷进度统计（按评卷员） */
    interface MarkProgressByMarker {
      dayFinishCounts: { count: number; date: string }[]
      markerId: number
      markerName: string
      markingGroupNumber: number
      totalFinishCount: number
    }
    type GetMarkProgressByMarker = BaseDefine<
      { subjectCode: string; questionMainNumber?: number; markingGroupNumbers?: number },
      MarkProgressByMarker[]
    >

    type ExportMarkProgressByMarker = BaseDefine<{
      subjectCode: string
      questionMainNumber?: number
      markingGroupNumber?: number
    }>

    /** 科目进度收尾 */
    interface SubjectProgressEndInfo {
      arbitrationPaperRate: number
      checkPaperCount: number
      checkPaperRate: number
      finishCount: number
      finishRate: number
      questionMainName: string
      questionMainNumber: number
      subjectiveUnVerifyPaperCount: number
      todoArbitrationPaperCount: number
      todoProblemPaperCount: number
      todoSamePaperCount: number
      totalPaper: number
    }

    type SubjectProgressEnd = BaseDefine<{ subjectCode: string }, SubjectProgressEndInfo[]>

    interface BaseParams {
      subjectCode: string
      questionMainNumber?: number
      markingGroupNumber?: number
    }

    /** 质量统计-收尾检查-评卷员未评卷列表（分页） */

    interface UnMarkPaper {
      markerId: number
      markerName: string
      questionMainName: string
      questionMainNumber: number
      secretNumber: string
      taskId: number
    }
    type UnMarkPaperList = BaseDefine<MultipleQuery<BaseParams>, MultipleResult<UnMarkPaper>>
    /** 质量统计-收尾检查-未处理雷同卷列表 */
    interface UnProcessSimilar {
      questionMainName: string
      questionMainNumber: number
      sameSecretNumber: string
      secretNumber: string
    }
    type UnProcessSimilarList = BaseDefine<BaseParams, UnProcessSimilar[]>
    /** 质量统计-收尾检查-未处理问题卷列表 */
    interface UnProcessProblem {
      questionMainName: string
      questionMainNumber: number
      secretNumber: string
    }
    type UnProcessProblemList = BaseDefine<BaseParams, UnProcessProblem[]>

    /** 小组监控 */
    interface GroupMonitor {
      /** 已浏览自定义抽查卷数 */
      customCheckCount: number
      /** 已浏览问题卷数 */
      problemCount: number
      /** 已浏览系统抽查卷数 */
      sysCheckCount: number
      /** 组长 */
      markingGroupLeader: string
      /** 小组号 */
      markingGroupNumber: number
      /** 已给分自定义抽查卷数 */
      customCheckReScoreCount: number
      /** 已给分问题卷数 */
      problemReScoreCount: number
      /** 已给分系统抽查卷数 */
      sysCheckReScoreCount: number
      /** 已浏览试卷总数 */
      totalCount: number
      /** 已给分试卷总数 */
      totalReScoreCount: number
    }
    type GetGroupMonitor = BaseDefine<BaseFilterOption, GroupMonitor[]>

    /** 决策分析- 统计 */
    interface StatisticItem {
      markerId: number
      markerName: string
      value: number
    }

    type GetStatistics = BaseDefine<BaseFilterOption, Record<string, StatisticItem[]>>

    /** 决策分析-监控统计（按小组） */
    interface GetStatisticsByGroupParams {
      endTime?: string
      hasJudge?: boolean
      markerId?: number
      markingGroupNumbers?: number[]
      questionMainNumber?: number
      startTime?: string
      subjectCode: string
    }

    interface GetStatisticsByGroupResponseItem {
      /** 平均分 */
      avg: number
      /** 抽查改正量 */
      checkCorrectCount: number
      /** 抽查量 */
      checkCount: number
      /** 综合指数 */
      integration: number
      /** 评卷员ID */
      markerId: number
      /** 评卷员名称 */
      markerName: string
      /** 小组号 */
      markingGroupNumber: number
      /** 评卷份数 */
      markingPaperCount: number
      /** 评卷速度（n秒每个） */
      markingRate: number
      /** 评卷状态 */
      markingStatus: string
      /** 平均客主比 */
      objSubAvgRate: number
      /** 客主比（近N分钟） */
      objSubRate: number
      /** 客观平均分 */
      objectiveAvg: number
      /** 客观标准差 */
      objectiveStd: number
      /** 客观0分量 */
      objectiveZero: number
      /** 是否在线 */
      online: boolean
      /** 重评待确认量 */
      reMarkConfirmCount: number
      /** 重评量 */
      reMarkCount: number
      /** 最低分（近N分钟） */
      scoreLow: number
      /** 最高分（近N分钟） */
      scoreTop: number
      /** 方差 */
      sd: number
      /** 标准差 */
      std: number
      /** 相关系数 */
      xyRelate: number
      /** 评卷员明细统计列表 */
      markerDetails: GetStatisticsByGroupResponseItem[] | null
    }

    type GetStatisticsByGroup = BaseDefine<GetStatisticsByGroupParams, GetStatisticsByGroupResponseItem[]>

    /** 决策分析-监控统计导出（按小组） */
    type ExportStatisticsByGroup = BaseDefine<GetStatisticsByGroupParams>

    /** 培训监控 */
    interface TrainingMonitorParams {
      subjectCode: string
      mainNumber?: number
      markingGroupNumber?: number
      markStage: 'SAMPLE_A' | 'SAMPLE_B' | 'FORCE'
      forceGroupNumber?: number
    }
    interface TrainingMonitorResponse {
      /** 平均分 */
      avg: number
      /** 差异份数 */
      diffCount: number
      /** 评卷员ID */
      markerId: number
      /** 评卷员名称 */
      markerName: string
      /** 打分列表 */
      scoreList: number[]
      /** 状态 */
      status: number
      /** 标准差 */
      std: number
      /** 相关系数 */
      xyRelate: number
    }
    type GetTrainingMonitor = BaseDefine<TrainingMonitorParams, { data: TrainingMonitorResponse[]; header: number[] }>

    /** 个人统计 */
    interface PersonalStatistic {
      avg: number
      markerId: number
      markerName: string
      markingPaperCount: number
      markingRate: number
      questionMainName: string
      questionMainNumber: number
    }
    type GetPersonalStatistic = BaseDefine<{ startTime: string; endTime: string; markerId?: number }, PersonalStatistic>

    interface SystemSpotListItem {
      examNumber: string
      filePath: string
      id: number
      mainNumber: number
      markScore: number
      markTime: string
      markerName: string
      secretNumber: number
      status: string
      taskId: number
    }

    type GetSystemSpotList = BaseDefine<
      MultipleQuery<{
        level: 'LEVEL_1' | 'LEVEL_2' | 'LEVEL_3' | 'LEVEL_4' | 'LEVEL_5' | ''
        status: 'INITIAL' | 'VIEWED' | 'GRADED' | 'REJECT'
        mainNumber?: number
      }>,
      MultipleResult<SystemSpotListItem>
    >

    /** 系统抽查卷打分 */
    type MarkSystemSpotPaper = BaseDefine<{ id?: number; scores: number[] }>

    /** 系统抽查卷打回 */
    type RejectSystemSpotPaper = BaseDefine<{ description: string; id: number; reason: string }>

    /** 系统抽查卷浏览 */
    type ViewSystemSpotPaper = BaseDefine<{ id?: number }>

    interface ApiMap {
      /** 质量统计-自查一致性分析 */
      selfCheckAnalysis: SelfCheckAnalysis
      /** 质量统计-自查一致性分析-离差列表 */
      /** 质量统计-抽查情况统计 */
      statisticCheckOverview: StatisticCheckOverview
      /** 质量统计-主观题校验 */
      getSubjectiveCheckList: GetSubjectiveCheckList
      /** 质量统计-主观题校验打分 */
      subjectiveCheckMark: SubjectiveCheckMark
      /** 质量统计-主观题校验确认 */
      subjectiveCheckConfirm: SubjectiveCheckConfirm
      /** 决策分析-评卷进度统计（整体） */
      getMarkProgress: GetMarkProgress
      /** 决策分析-评卷进度统计（按小组） */
      getMarkProgressByGroup: GetMarkProgressByGroup
      /** 决策分析-评卷进度统计（按评卷员） */
      getMarkProgressByMarker: GetMarkProgressByMarker
      /** 决策分析-评卷进度统计导出（按评卷员） */
      exportMarkProgressByMarker: ExportMarkProgressByMarker
      /** 质量统计-科目进度收尾 */
      subjectProgressEnd: SubjectProgressEnd
      /** 质量统计-收尾检查-评卷员未评卷列表（分页） */
      unMarkPaperList: UnMarkPaperList
      /** 质量统计-收尾检查-未处理雷同卷列表 */
      unProcessSimilarList: UnProcessSimilarList
      /** 质量统计-收尾检查-未处理问题卷列表 */
      unProcessProblemList: UnProcessProblemList
      /** 决策分析-小组监控 */
      getGroupMonitor: GetGroupMonitor
      /** 决策分析-监控统计（整体） */
      getStatistics: GetStatistics

      /** 决策分析-监控统计（按小组） */
      getStatisticsByGroup: GetStatisticsByGroup
      /** 决策分析-监控统计导出（按小组） */
      exportStatisticsByGroup: ExportStatisticsByGroup
      /** 决策分析-监控统计客观题&主观题分数分布 */
      /**培训监控 */
      getTrainingMonitor: GetTrainingMonitor
      /** 个人统计 */
      getPersonalStatistic: GetPersonalStatistic
      /** 系统抽查卷 */
      getSystemSpotList: GetSystemSpotList
      /** 系统抽查卷打分 */
      markSystemSpotPaper: MarkSystemSpotPaper
      /** 系统抽查卷打回 */
      rejectSystemSpotPaper: RejectSystemSpotPaper
      /** 系统抽查卷浏览 */
      viewSystemSpotPaper: ViewSystemSpotPaper
    }
  }
}