fis_lib_i18n/lib/modules/realTimeConsultation.dart

import 'package:fis_i18n/types.dart';

/// 实时诊断模块
class RealTimeConsultationModule extends ModuleBase {
  RealTimeConsultationModule._({
    required this.makeCall,
    required this.unrated,
    required this.exitConsultation,
    required this.noVolumeAdjustmentChannel,
    required this.processingImage,
    required this.emergencyCall,
    required this.emergencyConfig,
    required this.startEmergency,
    required this.selectExpert,
    required this.selectDevice,
    required this.emergencyEquipment,
    required this.setEmergencyUltrasoundFirst,
    required this.goToSettings,
    required this.emergency,
    required this.consultationScreenshot,
    required this.consultationRoom,
    required this.confirmLeaveConsultation,
    required this.scanningTechnique,
    required this.devicePicture,
    required this.consultationDetail,
    required this.joinConsultation,
    required this.appraise,
    required this.noAppraise,
    required this.acceptedInvitation,
    required this.declinedInvitation,
    required this.acceptedTheInvitation4Toast,
    required this.declinedTheInvitation4Toast,
    required this.changeToAcceptInvitation,
    required this.changeToDeclineInvitation,
    required this.declineInvitation,
    required this.acceptInvitation,
    required this.followUp,
    required this.pleaseWriteFollowUp,
    required this.applied,
    required this.consultationList,
    required this.callAgain,
    required this.calling,
    required this.cancelCall,
    required this.callCanceled,
    required this.busy,
    required this.hasLeft,
    required this.starttConsultation,
    required this.endConsultation,
    required this.fullRecording,
    required this.endRecording,
    required this.lineSegment,
    required this.paintBrush,
    required this.tuningParameter,
    required this.tuningParameter4btn,
    required this.record,
    required this.searchRecords,
    required this.appointmentConsultation,
    required this.consultationImage,
    required this.consultationImageShort,
    required this.consultationRecord,
    required this.consultationReport,
    required this.consultationFollowUp,
    required this.applicant,
    required this.toBeReviewed,
    required this.patientInformation,
    required this.pastMedicalHistory,
    required this.appointmentInformation,
    required this.consultationEquipment,
    required this.consultationHours,
    required this.inspectionPosition,
    required this.nameOfDisease,
    required this.consultationInstitution,
    required this.competentExperts,
    required this.applicantMechanism,
    required this.requiredItemsNotCompleted,
    required this.applicantpeople,
    required this.operator,
    required this.expertAssistant,
    required this.preliminaryDiagnosis,
    required this.confirmApplication,
    required this.applyForAppointment,
    required this.pleaseEnterCreatedPatientName,
    required this.pleaseSelectPatient,
    required this.pleaseSelectPet,
    required this.pleaseSelectPatientForConsultation,
    required this.pleaseSelectConsultationEquipment,
    required this.pleaseSelectScanningDoctor,
    required this.pleaseSelectInspectionSite,
    required this.pleaseSelectConsultationInstitution,
    required this.pleaseSelectCompetentExpert,
    required this.pleaseSelectApplicant,
    required this.realTimeDiagnosis,
    required this.sureCancelCurrentConsultation,
    required this.requested,
    required this.withdrawn,
    required this.rejected,
    required this.toBeStarted,
    required this.haveInHand,
    required this.toBeReported,
    required this.closed,
    required this.withdrawalSucceeded,
    required this.withdraw,
    required this.timeOfAppointment,
    required this.applicationClassification,
    required this.iApplied,
    required this.iOrganized,
    required this.iInvolved,
    required this.pleaseSelectCategory,
    required this.groundsForRefusal,
    required this.rejectApplication,
    required this.reasonsForRefusal,
    required this.reasonsCannotBeNull,
    required this.notice,
    required this.noticeContent,
    required this.expertInCharge,
    required this.iknow,
    required this.minBeforeStart15,
    required this.minBeforeStart30,
    required this.minBeforeStart60,
    required this.beforeStart1day,
    required this.inAppReminder,
    required this.SMSReminder,
    required this.dateTime,
    required this.assistantPhysician,
    required this.participants,
    required this.consultationDescription,
    required this.reminderTime,
    required this.reminderMehod,
    required this.chooseExpert,
    required this.addParticipants,
    required this.hintText,
    required this.timeErrorNotice,
    required this.dateErrorNotice,
    required this.approveConsultationFaild,
    required this.noExpertsToChooseFrom,
    required this.chooseParticipants,
    required this.noAssistant,
    required this.timeErrorNoticeEqual,
    required this.addUpTo3People,
    required this.addUpTo4People,
    required this.theUpperLimitHasBeenReached,
    required this.accept,
    required this.scanDoctor,
    required this.thisInstitution,
    required this.createApplication,
    required this.notSet,
    required this.unsatisfactory,
    required this.satisfactory,
    required this.general,
    required this.dateConsultation,
    required this.consultationEvaluation,
    required this.uploader,
    required this.followUpPerson,
    required this.followUpTime,
    required this.followUpRecord,
    required this.previous,
    required this.next,
    required this.startTime,
    required this.selectStartTime,
    required this.endTime,
    required this.consultationStatus,
    required this.selectConsultationEvaluation,
    required this.selectConsultationStatus,
    required this.cannotAddVisit,
    required this.cannotAddEvalutation,
    required this.viewComments,
    required this.consultationScore,
    required this.evaluationTip,
    required this.negative,
    required this.medium,
    required this.good,
    required this.captureVid,
    required this.recording,
    required this.longPressToRecord,
    required this.captureFailed,
    required this.captureSaved,
    required this.recordFailed,
    required this.recordSaved,
    required this.noUsChannel,
    required this.captureImageList,
    required this.noCaptureImage,
    required this.uploading,
    required this.uploadFinished,
    required this.pauseFullRecording,
    required this.continueFullRecording,
    required this.toAge,
    required this.male,
    required this.female,
    required this.errorFilteringAge,
    required this.consultationExport,
    required this.exporting,
    required this.exportFailed,
    required this.exportConsultationRecords,
    required this.exportConsultationImage,
    required this.exportConsultationReport,
    required this.probesAndApplications,
    required this.expired,
    required this.checkPartNotEmpty,
    required this.createPatientConfirmWithDuplicateName,
    required this.validateUniquePart,
  });

  static const ModuleName = "realTimeConsultation";

  factory RealTimeConsultationModule(Map<String, dynamic> map) {
    return RealTimeConsultationModule._(
      makeCall: map.pick("makeCall"),
      unrated: map.pick("unrated"),
      exitConsultation: map.pick("exitConsultation"),
      noVolumeAdjustmentChannel: map.pick("noVolumeAdjustmentChannel"),
      processingImage: map.pick("processingImage"),
      emergencyCall: map.pick("emergencyCall"),
      emergencyConfig: map.pick("emergencyConfig"),
      startEmergency: map.pick("startEmergency"),
      selectExpert: map.pick("selectExpert"),
      selectDevice: map.pick("selectDevice"),
      emergencyEquipment: map.pick("emergencyEquipment"),
      setEmergencyUltrasoundFirst: map.pick("setEmergencyUltrasoundFirst"),
      goToSettings: map.pick("goToSettings"),
      emergency: map.pick("emergency"),
      consultationScreenshot: map.pick("consultationScreenshot"),
      consultationRoom: map.pick("consultationRoom"),
      confirmLeaveConsultation: map.pick("confirmLeaveConsultation"),
      scanningTechnique: map.pick("scanningTechnique"),
      devicePicture: map.pick("devicePicture"),
      consultationDetail: map.pick("consultationDetail"),
      joinConsultation: map.pick("joinConsultation"),
      appraise: map.pick("appraise"),
      noAppraise: map.pick("noAppraise"),
      acceptedInvitation: map.pick("acceptedInvitation"),
      declinedInvitation: map.pick("declinedInvitation"),
      acceptedTheInvitation4Toast: map.pick("acceptedTheInvitation4Toast"),
      declinedTheInvitation4Toast: map.pick("declinedTheInvitation4Toast"),
      changeToAcceptInvitation: map.pick("changeToAcceptInvitation"),
      changeToDeclineInvitation: map.pick("changeToDeclineInvitation"),
      declineInvitation: map.pick("declineInvitation"),
      acceptInvitation: map.pick("acceptInvitation"),
      followUp: map.pick("followUp"),
      pleaseWriteFollowUp: map.pick("pleaseWriteFollowUp"),
      applied: map.pick("applied"),
      consultationList: map.pick("consultationList"),
      callAgain: map.pick("callAgain"),
      calling: map.pick("calling"),
      cancelCall: map.pick("cancelCall"),
      callCanceled: map.pick("callCanceled"),
      busy: map.pick("busy"),
      hasLeft: map.pick("hasLeft"),
      starttConsultation: map.pick("starttConsultation"),
      endConsultation: map.pick("endConsultation"),
      fullRecording: map.pick("fullRecording"),
      endRecording: map.pick("endRecording"),
      lineSegment: map.pick("lineSegment"),
      paintBrush: map.pick("paintBrush"),
      tuningParameter: map.pick("tuningParameter"),
      tuningParameter4btn: map.pick("tuningParameter4btn"),
      record: map.pick("record"),
      searchRecords: map.pick("searchRecords"),
      appointmentConsultation: map.pick("appointmentConsultation"),
      consultationImage: map.pick("consultationImage"),
      consultationImageShort: map.pick("consultationImageShort"),
      consultationRecord: map.pick("consultationRecord"),
      consultationReport: map.pick("consultationReport"),
      consultationFollowUp: map.pick("consultationFollowUp"),
      applicant: map.pick("applicant"),
      toBeReviewed: map.pick("toBeReviewed"),
      patientInformation: map.pick("patientInformation"),
      pastMedicalHistory: map.pick("pastMedicalHistory"),
      appointmentInformation: map.pick("appointmentInformation"),
      consultationEquipment: map.pick("consultationEquipment"),
      consultationHours: map.pick("consultationHours"),
      inspectionPosition: map.pick("inspectionPosition"),
      nameOfDisease: map.pick("nameOfDisease"),
      consultationInstitution: map.pick("consultationInstitution"),
      competentExperts: map.pick("competentExperts"),
      applicantMechanism: map.pick("applicantMechanism"),
      requiredItemsNotCompleted: map.pick("requiredItemsNotCompleted"),
      applicantpeople: map.pick("applicantpeople"),
      operator: map.pick("operator"),
      expertAssistant: map.pick("expertAssistant"),
      preliminaryDiagnosis: map.pick("preliminaryDiagnosis"),
      confirmApplication: map.pick("confirmApplication"),
      applyForAppointment: map.pick("applyForAppointment"),
      pleaseEnterCreatedPatientName: map.pick("pleaseEnterCreatedPatientName"),
      pleaseSelectPatient: map.pick("pleaseSelectPatient"),
      pleaseSelectPet: map.pick("pleaseSelectPet"),
      pleaseSelectPatientForConsultation:
          map.pick("pleaseSelectPatientForConsultation"),
      pleaseSelectConsultationEquipment:
          map.pick("pleaseSelectConsultationEquipment"),
      pleaseSelectScanningDoctor: map.pick("pleaseSelectScanningDoctor"),
      pleaseSelectInspectionSite: map.pick("pleaseSelectInspectionSite"),
      pleaseSelectConsultationInstitution:
          map.pick("pleaseSelectConsultationInstitution"),
      pleaseSelectCompetentExpert: map.pick("pleaseSelectCompetentExpert"),
      pleaseSelectApplicant: map.pick("pleaseSelectApplicant"),
      realTimeDiagnosis: map.pick("realTimeDiagnosis"),
      sureCancelCurrentConsultation: map.pick("sureCancelCurrentConsultation"),
      requested: map.pick("requested"),
      withdrawn: map.pick("withdrawn"),
      rejected: map.pick("rejected"),
      toBeStarted: map.pick("toBeStarted"),
      haveInHand: map.pick("haveInHand"),
      toBeReported: map.pick("toBeReported"),
      closed: map.pick("closed"),
      withdrawalSucceeded: map.pick("withdrawalSucceeded"),
      withdraw: map.pick("withdraw"),
      timeOfAppointment: map.pick("timeOfAppointment"),
      applicationClassification: map.pick("applicationClassification"),
      iApplied: map.pick("iApplied"),
      iOrganized: map.pick("iOrganized"),
      iInvolved: map.pick("iInvolved"),
      pleaseSelectCategory: map.pick("pleaseSelectCategory"),
      groundsForRefusal: map.pick("groundsForRefusal"),
      rejectApplication: map.pick("rejectApplication"),
      reasonsForRefusal: map.pick("reasonsForRefusal"),
      reasonsCannotBeNull: map.pick("reasonsCannotBeNull"),
      notice: map.pick("notice"),
      noticeContent: map.pick("noticeContent"),
      expertInCharge: map.pick("expertInCharge"),
      iknow: map.pick("iknow"),
      minBeforeStart15: map.pick("minBeforeStart15"),
      minBeforeStart30: map.pick("minBeforeStart30"),
      minBeforeStart60: map.pick("minBeforeStart60"),
      beforeStart1day: map.pick("beforeStart1day"),
      inAppReminder: map.pick("inAppReminder"),
      SMSReminder: map.pick("SMSReminder"),
      dateTime: map.pick("dateTime"),
      assistantPhysician: map.pick("assistantPhysician"),
      participants: map.pick("participants"),
      consultationDescription: map.pick("consultationDescription"),
      reminderTime: map.pick("reminderTime"),
      reminderMehod: map.pick("reminderMehod"),
      chooseExpert: map.pick("chooseExpert"),
      addParticipants: map.pick("addParticipants"),
      hintText: map.pick("hintText"),
      timeErrorNotice: map.pick("timeErrorNotice"),
      dateErrorNotice: map.pick("dateErrorNotice"),
      approveConsultationFaild: map.pick("approveConsultationFaild"),
      noExpertsToChooseFrom: map.pick("noExpertsToChooseFrom"),
      chooseParticipants: map.pick("chooseParticipants"),
      noAssistant: map.pick("noAssistant"),
      timeErrorNoticeEqual: map.pick("timeErrorNoticeEqual"),
      addUpTo3People: map.pick("addUpTo3People"),
      addUpTo4People: map.pick("addUpTo4People"),
      theUpperLimitHasBeenReached: map.pick("theUpperLimitHasBeenReached"),
      accept: map.pick("accept"),
      scanDoctor: map.pick("scanDoctor"),
      thisInstitution: map.pick("thisInstitution"),
      createApplication: map.pick("createApplication"),
      notSet: map.pick("notSet"),
      unsatisfactory: map.pick("unsatisfactory"),
      satisfactory: map.pick("satisfactory"),
      general: map.pick("general"),
      dateConsultation: map.pick("dateConsultation"),
      consultationEvaluation: map.pick("consultationEvaluation"),
      uploader: map.pick("uploader"),
      followUpPerson: map.pick("followUpPerson"),
      followUpTime: map.pick("followUpTime"),
      followUpRecord: map.pick("followUpRecord"),
      previous: map.pick("previous"),
      next: map.pick("next"),
      startTime: map.pick("startTime"),
      selectStartTime: map.pick("selectStartTime"),
      endTime: map.pick("endTime"),
      consultationStatus: map.pick("consultationStatus"),
      selectConsultationEvaluation: map.pick("selectConsultationEvaluation"),
      selectConsultationStatus: map.pick("selectConsultationStatus"),
      cannotAddVisit: map.pick("cannotAddVisit"),
      cannotAddEvalutation: map.pick("cannotAddEvalutation"),
      viewComments: map.pick("viewComments"),
      consultationScore: map.pick("consultationScore"),
      evaluationTip: map.pick("evaluationTip"),
      negative: map.pick("negative"),
      medium: map.pick("medium"),
      good: map.pick("good"),
      captureVid: map.pick("captureVid"),
      recording: map.pick("recording"),
      longPressToRecord: map.pick("longPressToRecord"),
      captureFailed: map.pick("captureFailed"),
      captureSaved: map.pick("captureSaved"),
      recordFailed: map.pick("recordFailed"),
      recordSaved: map.pick("recordSaved"),
      noUsChannel: map.pick("noUsChannel"),
      captureImageList: map.pick("captureImageList"),
      noCaptureImage: map.pick("noCaptureImage"),
      uploading: map.pick("uploading"),
      uploadFinished: map.pick("uploadFinished"),
      pauseFullRecording: map.pick("pauseFullRecording"),
      continueFullRecording: map.pick("continueFullRecording"),
      toAge: map.pick("toAge"),
      male: map.pick("male"),
      female: map.pick("female"),
      errorFilteringAge: map.pick("errorFilteringAge"),
      consultationExport: map.pick("consultationExport"),
      exporting: map.pick("exporting"),
      exportFailed: map.pick("exportFailed"),
      exportConsultationRecords: map.pick("exportConsultationRecords"),
      exportConsultationImage: map.pick("exportConsultationImage"),
      exportConsultationReport: map.pick("exportConsultationReport"),
      probesAndApplications: map.pick("probesAndApplications"),
      expired: map.pick("expired"),
      checkPartNotEmpty: map.pick("checkPartNotEmpty"),
      createPatientConfirmWithDuplicateName:
          map.pick("createPatientConfirmWithDuplicateName"),
      validateUniquePart: map.pick("validateUniquePart"),
    );
  }

  /// 发起呼叫
  final FTrStr makeCall;

  /// 未评价
  final FTrStr unrated;

  /// 退出会诊
  final FTrStr exitConsultation;

  /// 暂无可调节音量的频道
  final FTrStr noVolumeAdjustmentChannel;

  /// 正在处理图像，请稍后再试
  final FTrStr processingImage;

  /// 急诊呼叫
  final FTrStr emergencyCall;

  /// 急诊配置
  final FTrStr emergencyConfig;

  /// 发起急诊
  final FTrStr startEmergency;

  /// 请选择急诊专家：
  final FTrStr selectExpert;

  /// 请选择急诊设备：
  final FTrStr selectDevice;

  /// 急诊设备
  final FTrStr emergencyEquipment;

  /// 请先设置急诊超声机
  final FTrStr setEmergencyUltrasoundFirst;

  /// 前往设置
  final FTrStr goToSettings;

  /// 即时会诊
  final FTrStr emergency;

  /// 会诊截图
  final FTrStr consultationScreenshot;

  /// 会诊间
  final FTrStr consultationRoom;

  /// 确认离开会诊？
  final FTrStr confirmLeaveConsultation;

  /// << 扫查手法
  final FTrStr scanningTechnique;

  /// << 超声图像
  final FTrStr devicePicture;

  /// 会诊详情
  final FTrStr consultationDetail;

  /// 进入会诊
  final FTrStr joinConsultation;

  /// 评价
  final FTrStr appraise;

  /// 暂无评价
  final FTrStr noAppraise;

  /// 已同意参加
  final FTrStr acceptedInvitation;

  /// 已拒绝参加
  final FTrStr declinedInvitation;

  /// 已同意该会诊邀约
  final FTrStr acceptedTheInvitation4Toast;

  /// 已拒绝该会诊邀约
  final FTrStr declinedTheInvitation4Toast;

  /// 切换为同意参加
  final FTrStr changeToAcceptInvitation;

  /// 切换为拒绝参加
  final FTrStr changeToDeclineInvitation;

  /// 拒绝参加
  final FTrStr declineInvitation;

  /// 同意参加
  final FTrStr acceptInvitation;

  /// 随访
  final FTrStr followUp;

  /// 请填写随访内容
  final FTrStr pleaseWriteFollowUp;

  /// 已申请
  final FTrStr applied;

  /// 会诊列表
  final FTrStr consultationList;

  /// 再次呼叫
  final FTrStr callAgain;

  /// 呼叫中
  final FTrStr calling;

  /// 取消呼叫
  final FTrStr cancelCall;

  /// 已取消呼叫
  final FTrStr callCanceled;

  /// 忙线中
  final FTrStr busy;

  /// 已离开
  final FTrStr hasLeft;

  /// 开始会诊
  final FTrStr starttConsultation;

  /// 结束会诊
  final FTrStr endConsultation;

  /// 全程录制
  final FTrStr fullRecording;

  /// 结束录制
  final FTrStr endRecording;

  /// 线段
  final FTrStr lineSegment;

  /// 画笔
  final FTrStr paintBrush;

  /// 远程调参
  final FTrStr tuningParameter;

  /// 调参
  final FTrStr tuningParameter4btn;

  /// 记录
  final FTrStr record;

  /// 搜索记录
  final FTrStr searchRecords;

  /// 预约会诊
  final FTrStr appointmentConsultation;

  /// 会诊图像
  final FTrStr consultationImage;

  /// 会诊图像
  final FTrStr consultationImageShort;

  /// 会诊记录
  final FTrStr consultationRecord;

  /// 会诊报告
  final FTrStr consultationReport;

  /// 会诊随访
  final FTrStr consultationFollowUp;

  /// 申请单位
  final FTrStr applicant;

  /// 待审核
  final FTrStr toBeReviewed;

  /// 历史检查
  final FTrStr patientInformation;

  /// 既往病史
  final FTrStr pastMedicalHistory;

  /// 预约信息
  final FTrStr appointmentInformation;

  /// 会诊设备
  final FTrStr consultationEquipment;

  /// 会诊时间
  final FTrStr consultationHours;

  /// 检查部位
  final FTrStr inspectionPosition;

  /// 疾病名称
  final FTrStr nameOfDisease;

  /// 会诊医院
  final FTrStr consultationInstitution;

  /// 会诊专家
  final FTrStr competentExperts;

  /// 申请医院
  final FTrStr applicantMechanism;

  /// 必填项未完成
  final FTrStr requiredItemsNotCompleted;

  /// 申请人
  final FTrStr applicantpeople;

  /// 操作人
  final FTrStr operator;

  /// 专家助理
  final FTrStr expertAssistant;

  /// 初步诊断
  final FTrStr preliminaryDiagnosis;

  /// 确认申请
  final FTrStr confirmApplication;

  /// 会诊申请
  final FTrStr applyForAppointment;

  /// 请输入创建的病人名
  final FTrStr pleaseEnterCreatedPatientName;

  /// 请选择病人
  final FTrStr pleaseSelectPatient;

  /// 请选择宠物
  final FTrStr pleaseSelectPet;

  /// 请搜索或选择会诊病人
  final FTrStr pleaseSelectPatientForConsultation;

  /// 请选择会诊设备
  final FTrStr pleaseSelectConsultationEquipment;

  /// 请选择扫查医生
  final FTrStr pleaseSelectScanningDoctor;

  /// 请选择检查部位
  final FTrStr pleaseSelectInspectionSite;

  /// 请选择会诊医院
  final FTrStr pleaseSelectConsultationInstitution;

  /// 请选择会诊专家
  final FTrStr pleaseSelectCompetentExpert;

  /// 请选择申请人
  final FTrStr pleaseSelectApplicant;

  /// 实时会诊
  final FTrStr realTimeDiagnosis;

  /// 是否确定撤回当前会诊
  final FTrStr sureCancelCurrentConsultation;

  /// 待审核
  final FTrStr requested;

  /// 已撤回
  final FTrStr withdrawn;

  /// 已拒绝
  final FTrStr rejected;

  /// 待开始
  final FTrStr toBeStarted;

  /// 进行中
  final FTrStr haveInHand;

  /// 待报告
  final FTrStr toBeReported;

  /// 已结束
  final FTrStr closed;

  /// 撤回成功，请至“待处理”列表查看
  final FTrStr withdrawalSucceeded;

  /// 撤回
  final FTrStr withdraw;

  /// 预约时间
  final FTrStr timeOfAppointment;

  /// 申请分类
  final FTrStr applicationClassification;

  /// 我申请的
  final FTrStr iApplied;

  /// 我组织的
  final FTrStr iOrganized;

  /// 我参与的
  final FTrStr iInvolved;

  /// 请选择分类
  final FTrStr pleaseSelectCategory;

  /// 拒绝理由
  final FTrStr groundsForRefusal;

  /// 拒绝申请
  final FTrStr rejectApplication;

  /// 拒绝原因
  final FTrStr reasonsForRefusal;

  /// 拒绝理由不能为空
  final FTrStr reasonsCannotBeNull;

  /// 通知
  final FTrStr notice;

  /// 会诊将在15分钟后开始,请及时参与!
  final FTrStr noticeContent;

  /// 主管专家
  final FTrStr expertInCharge;

  /// 我知道了
  final FTrStr iknow;

  /// 开始前15分钟
  final FTrStr minBeforeStart15;

  /// 开始前30分钟
  final FTrStr minBeforeStart30;

  /// 开始前60分钟
  final FTrStr minBeforeStart60;

  /// 开始前1天
  final FTrStr beforeStart1day;

  /// 应用内提醒
  final FTrStr inAppReminder;

  /// 短信提醒
  final FTrStr SMSReminder;

  /// 时间
  final FTrStr dateTime;

  /// 助理医师
  final FTrStr assistantPhysician;

  /// 参与人员
  final FTrStr participants;

  /// 会诊描述
  final FTrStr consultationDescription;

  /// 提醒时间
  final FTrStr reminderTime;

  /// 提醒方式
  final FTrStr reminderMehod;

  /// 请选择专家
  final FTrStr chooseExpert;

  /// 添加参与人
  final FTrStr addParticipants;

  /// 100个字以内
  final FTrStr hintText;

  /// 会诊结束时间不能早于开始时间!
  final FTrStr timeErrorNotice;

  /// 会诊时间必须晚于当前时间!
  final FTrStr dateErrorNotice;

  /// 提交会诊申请失败
  final FTrStr approveConsultationFaild;

  /// 没有可选择的专家
  final FTrStr noExpertsToChooseFrom;

  /// 请勾选参与人
  final FTrStr chooseParticipants;

  /// 未填写
  final FTrStr noAssistant;

  /// 会诊结束时间不能等于开始时间!
  final FTrStr timeErrorNoticeEqual;

  /// 最多添加3人
  final FTrStr addUpTo3People;

  /// 最多添加4人
  final FTrStr addUpTo4People;

  /// 参与人已达上限，无法继续添加
  final FTrStr theUpperLimitHasBeenReached;

  /// 接受
  final FTrStr accept;

  /// 扫查医生
  final FTrStr scanDoctor;

  /// 本医院
  final FTrStr thisInstitution;

  /// 创建申请
  final FTrStr createApplication;

  /// 未设置
  final FTrStr notSet;

  /// 不满意
  final FTrStr unsatisfactory;

  /// 满意
  final FTrStr satisfactory;

  /// 一般
  final FTrStr general;

  /// 会诊日期
  final FTrStr dateConsultation;

  /// 会诊评价
  final FTrStr consultationEvaluation;

  /// 上传者:
  final FTrStr uploader;

  /// 随访人
  final FTrStr followUpPerson;

  /// 随访时间
  final FTrStr followUpTime;

  /// 随访记录
  final FTrStr followUpRecord;

  /// 上一条
  final FTrStr previous;

  /// 下一条
  final FTrStr next;

  /// 开始时间
  final FTrStr startTime;

  /// 选择开始时间
  final FTrStr selectStartTime;

  /// 结束时间
  final FTrStr endTime;

  /// 会诊状态
  final FTrStr consultationStatus;

  /// 选择会诊评价
  final FTrStr selectConsultationEvaluation;

  /// 选择会诊状态
  final FTrStr selectConsultationStatus;

  /// 会诊没有结束，不能进行随访
  final FTrStr cannotAddVisit;

  /// 会诊没有结束，不能进行评价
  final FTrStr cannotAddEvalutation;

  /// 查看评价
  final FTrStr viewComments;

  /// 会诊评分
  final FTrStr consultationScore;

  /// 您仅有一次不支持更改和删除的评价机会，请给出客观公正的会诊评价。
  final FTrStr evaluationTip;

  /// 差评
  final FTrStr negative;

  /// 中评
  final FTrStr medium;

  /// 好评
  final FTrStr good;

  /// 保存
  final FTrStr captureVid;

  /// 录制中
  final FTrStr recording;

  /// 长按方可录制
  final FTrStr longPressToRecord;

  /// 截图失败
  final FTrStr captureFailed;

  /// 截图已保存到会诊图像
  final FTrStr captureSaved;

  /// 录制失败
  final FTrStr recordFailed;

  /// 录制已保存到会诊图像
  final FTrStr recordSaved;

  /// 超声画面不存在
  final FTrStr noUsChannel;

  /// 截图列表
  final FTrStr captureImageList;

  /// 暂无截图
  final FTrStr noCaptureImage;

  /// 上传中...
  final FTrStr uploading;

  /// 上传完成
  final FTrStr uploadFinished;

  /// 暂停
  final FTrStr pauseFullRecording;

  /// 继续
  final FTrStr continueFullRecording;

  /// 至
  final FTrStr toAge;

  /// 男
  final FTrStr male;

  /// 女
  final FTrStr female;

  /// 筛选年龄出错
  final FTrStr errorFilteringAge;

  /// 会诊导出
  final FTrStr consultationExport;

  /// 正在导出
  final FTrStr exporting;

  /// 导出失败
  final FTrStr exportFailed;

  /// 导出会诊记录
  final FTrStr exportConsultationRecords;

  /// 导出会诊图像
  final FTrStr exportConsultationImage;

  /// 导出会诊报告
  final FTrStr exportConsultationReport;

  /// 探头和应用
  final FTrStr probesAndApplications;

  /// 已过期
  final FTrStr expired;

  /// 自定义检查部位不能为空
  final FTrStr checkPartNotEmpty;

  /// 已存在相同姓名的病人，是否继续创建？
  final FTrStr createPatientConfirmWithDuplicateName;

  /// 自定义检查部位不能重复
  final FTrStr validateUniquePart;

  @override
  getProp(String propName) {
    // TODO: implement getProp
    throw UnimplementedError();
  }
}