// GENERATED CODE - DO NOT MODIFY BY HAND
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import 'intl/messages_all.dart';

// **************************************************************************
// Generator: Flutter Intl IDE plugin
// Made by Localizely
// **************************************************************************

// ignore_for_file: non_constant_identifier_names, lines_longer_than_80_chars
// ignore_for_file: join_return_with_assignment, prefer_final_in_for_each
// ignore_for_file: avoid_redundant_argument_values, avoid_escaping_inner_quotes

class S {
  S();

  static S? _current;

  static S get current {
    assert(_current != null,
        'No instance of S was loaded. Try to initialize the S delegate before accessing S.current.');
    return _current!;
  }

  static const AppLocalizationDelegate delegate = AppLocalizationDelegate();

  static Future<S> load(Locale locale) {
    final name = (locale.countryCode?.isEmpty ?? false)
        ? locale.languageCode
        : locale.toString();
    final localeName = Intl.canonicalizedLocale(name);
    return initializeMessages(localeName).then((_) {
      Intl.defaultLocale = localeName;
      final instance = S();
      S._current = instance;

      return instance;
    });
  }

  static S of(BuildContext context) {
    final instance = S.maybeOf(context);
    assert(instance != null,
        'No instance of S present in the widget tree. Did you add S.delegate in localizationsDelegates?');
    return instance!;
  }

  static S? maybeOf(BuildContext context) {
    return Localizations.of<S>(context, S);
  }

  /// `Wisdom Health`
  String get appName {
    return Intl.message(
      'Wisdom Health',
      name: 'appName',
      desc: '',
      args: [],
    );
  }

  /// `Wisdom`
  String get appNameHst {
    return Intl.message(
      'Wisdom',
      name: 'appNameHst',
      desc: '',
      args: [],
    );
  }

  /// `Wisdom Health Management`
  String get splashTitle {
    return Intl.message(
      'Wisdom Health Management',
      name: 'splashTitle',
      desc: '',
      args: [],
    );
  }

  /// `Wisdom Health Management`
  String get splashTitleHst {
    return Intl.message(
      'Wisdom Health Management',
      name: 'splashTitleHst',
      desc: '',
      args: [],
    );
  }

  /// `Take photos in HD and upload them easily`
  String get appSlogan {
    return Intl.message(
      'Take photos in HD and upload them easily',
      name: 'appSlogan',
      desc: '',
      args: [],
    );
  }

  /// `Dental experts online — providing professional health guidance`
  String get appSlogan2 {
    return Intl.message(
      'Dental experts online — providing professional health guidance',
      name: 'appSlogan2',
      desc: '',
      args: [],
    );
  }

  /// `History`
  String get history {
    return Intl.message(
      'History',
      name: 'history',
      desc: '',
      args: [],
    );
  }

  /// `The video is abnormal`
  String get showVideoError {
    return Intl.message(
      'The video is abnormal',
      name: 'showVideoError',
      desc: '',
      args: [],
    );
  }

  /// `Waiting for the device to connect`
  String get waitingConnectDevice {
    return Intl.message(
      'Waiting for the device to connect',
      name: 'waitingConnectDevice',
      desc: '',
      args: [],
    );
  }

  /// `1. Turn on the Wisdom Dental Viewer, the device will automatically start WiFi, the WiFi name is mlg + device number (for example mlg_L240684), and use your mobile phone to connect to this WiFi.`
  String get notConnectDesc1 {
    return Intl.message(
      '1. Turn on the Wisdom Dental Viewer, the device will automatically start WiFi, the WiFi name is mlg + device number (for example mlg_L240684), and use your mobile phone to connect to this WiFi.',
      name: 'notConnectDesc1',
      desc: '',
      args: [],
    );
  }

  /// `2. Automatic link between the device and the application. After opening the app to take photos and videos, the device will automatically store the pictures or videos on your phone.`
  String get notConnectDesc2 {
    return Intl.message(
      '2. Automatic link between the device and the application. After opening the app to take photos and videos, the device will automatically store the pictures or videos on your phone.',
      name: 'notConnectDesc2',
      desc: '',
      args: [],
    );
  }

  /// `Connect`
  String get connect {
    return Intl.message(
      'Connect',
      name: 'connect',
      desc: '',
      args: [],
    );
  }

  /// `Click Connect`
  String get clickToConnect {
    return Intl.message(
      'Click Connect',
      name: 'clickToConnect',
      desc: '',
      args: [],
    );
  }

  /// `FAQS`
  String get faqs {
    return Intl.message(
      'FAQS',
      name: 'faqs',
      desc: '',
      args: [],
    );
  }

  /// `Still can't link the viewer after following the instructions?`
  String get faq1Title {
    return Intl.message(
      'Still can\'t link the viewer after following the instructions?',
      name: 'faq1Title',
      desc: '',
      args: [],
    );
  }

  /// `1. Check whether the observation instrument is in normal use. \nCheck whether the observer is powered on and whether the battery is low in combination with the <Oral Observer Instruction Manual>.`
  String get faq1Desc1 {
    return Intl.message(
      '1. Check whether the observation instrument is in normal use. \nCheck whether the observer is powered on and whether the battery is low in combination with the <Oral Observer Instruction Manual>.',
      name: 'faq1Desc1',
      desc: '',
      args: [],
    );
  }

  /// `2. Check whether the phone is normally turned on the WiFi switch.`
  String get faq1Desc2 {
    return Intl.message(
      '2. Check whether the phone is normally turned on the WiFi switch.',
      name: 'faq1Desc2',
      desc: '',
      args: [],
    );
  }

  /// `3. Restart the viewer and mobile device.`
  String get faq1Desc3 {
    return Intl.message(
      '3. Restart the viewer and mobile device.',
      name: 'faq1Desc3',
      desc: '',
      args: [],
    );
  }

  /// `You have linked your device`
  String get deviceHasConnected {
    return Intl.message(
      'You have linked your device',
      name: 'deviceHasConnected',
      desc: '',
      args: [],
    );
  }

  /// `Start shooting`
  String get startShot {
    return Intl.message(
      'Start shooting',
      name: 'startShot',
      desc: '',
      args: [],
    );
  }

  /// `Stop shooting`
  String get stopShot {
    return Intl.message(
      'Stop shooting',
      name: 'stopShot',
      desc: '',
      args: [],
    );
  }

  /// `Take photo`
  String get takePhoto {
    return Intl.message(
      'Take photo',
      name: 'takePhoto',
      desc: '',
      args: [],
    );
  }

  /// `Start recording`
  String get startRecord {
    return Intl.message(
      'Start recording',
      name: 'startRecord',
      desc: '',
      args: [],
    );
  }

  /// `Stop recording`
  String get StopRecord {
    return Intl.message(
      'Stop recording',
      name: 'StopRecord',
      desc: '',
      args: [],
    );
  }

  /// `Recording`
  String get record {
    return Intl.message(
      'Recording',
      name: 'record',
      desc: '',
      args: [],
    );
  }

  /// `The photo was taken successfully`
  String get takePhotoSuccess {
    return Intl.message(
      'The photo was taken successfully',
      name: 'takePhotoSuccess',
      desc: '',
      args: [],
    );
  }

  /// `Failed to take a photo`
  String get takePhotoFailed {
    return Intl.message(
      'Failed to take a photo',
      name: 'takePhotoFailed',
      desc: '',
      args: [],
    );
  }

  /// `Recording has started`
  String get hasStartRecord {
    return Intl.message(
      'Recording has started',
      name: 'hasStartRecord',
      desc: '',
      args: [],
    );
  }

  /// `Recording has been stopped`
  String get hasStopRecord {
    return Intl.message(
      'Recording has been stopped',
      name: 'hasStopRecord',
      desc: '',
      args: [],
    );
  }

  /// `Failed to start recording`
  String get startRecordFailed {
    return Intl.message(
      'Failed to start recording',
      name: 'startRecordFailed',
      desc: '',
      args: [],
    );
  }

  /// `Failed to stop recording`
  String get stopRecordFailed {
    return Intl.message(
      'Failed to stop recording',
      name: 'stopRecordFailed',
      desc: '',
      args: [],
    );
  }

  /// `Photo`
  String get photo {
    return Intl.message(
      'Photo',
      name: 'photo',
      desc: '',
      args: [],
    );
  }

  /// `Video`
  String get video {
    return Intl.message(
      'Video',
      name: 'video',
      desc: '',
      args: [],
    );
  }

  /// `Tips`
  String get hint {
    return Intl.message(
      'Tips',
      name: 'hint',
      desc: '',
      args: [],
    );
  }

  /// `Whether to delete this photo record?`
  String get deletePhotoHint {
    return Intl.message(
      'Whether to delete this photo record?',
      name: 'deletePhotoHint',
      desc: '',
      args: [],
    );
  }

  /// `Whether to delete this video recording?`
  String get deleteVideoHint {
    return Intl.message(
      'Whether to delete this video recording?',
      name: 'deleteVideoHint',
      desc: '',
      args: [],
    );
  }

  /// `Confirm`
  String get confirm {
    return Intl.message(
      'Confirm',
      name: 'confirm',
      desc: '',
      args: [],
    );
  }

  /// `Cancel`
  String get cancel {
    return Intl.message(
      'Cancel',
      name: 'cancel',
      desc: '',
      args: [],
    );
  }

  /// `Delete successfully`
  String get deleteSuccess {
    return Intl.message(
      'Delete successfully',
      name: 'deleteSuccess',
      desc: '',
      args: [],
    );
  }

  /// `Delete failed`
  String get deleteFailed {
    return Intl.message(
      'Delete failed',
      name: 'deleteFailed',
      desc: '',
      args: [],
    );
  }

  /// `In order to save the photos and videos you have taken, grant the file management permission`
  String get storagePermissionHint {
    return Intl.message(
      'In order to save the photos and videos you have taken, grant the file management permission',
      name: 'storagePermissionHint',
      desc: '',
      args: [],
    );
  }

  /// `If you do not grant the file management permission, you will not be able to save photos and videos`
  String get storagePermissionRejectHint {
    return Intl.message(
      'If you do not grant the file management permission, you will not be able to save photos and videos',
      name: 'storagePermissionRejectHint',
      desc: '',
      args: [],
    );
  }

  /// `File management privileges have been granted`
  String get storagePermissionGrantedHint {
    return Intl.message(
      'File management privileges have been granted',
      name: 'storagePermissionGrantedHint',
      desc: '',
      args: [],
    );
  }

  /// `There is no history`
  String get noHistories {
    return Intl.message(
      'There is no history',
      name: 'noHistories',
      desc: '',
      args: [],
    );
  }

  /// `Reading history`
  String get loadingHistories {
    return Intl.message(
      'Reading history',
      name: 'loadingHistories',
      desc: '',
      args: [],
    );
  }

  /// `Click Exit Program again`
  String get tapAgainExit {
    return Intl.message(
      'Click Exit Program again',
      name: 'tapAgainExit',
      desc: '',
      args: [],
    );
  }

  /// `Settings`
  String get settings {
    return Intl.message(
      'Settings',
      name: 'settings',
      desc: '',
      args: [],
    );
  }

  /// `Delayed shooting:`
  String get delayShotColon {
    return Intl.message(
      'Delayed shooting:',
      name: 'delayShotColon',
      desc: '',
      args: [],
    );
  }

  /// `Delay time:`
  String get delayTimeColon {
    return Intl.message(
      'Delay time:',
      name: 'delayTimeColon',
      desc: '',
      args: [],
    );
  }

  /// `{second}Second`
  String xxSecond(Object second) {
    return Intl.message(
      '${second}Second',
      name: 'xxSecond',
      desc: '',
      args: [second],
    );
  }

  /// `Open`
  String get open {
    return Intl.message(
      'Open',
      name: 'open',
      desc: '',
      args: [],
    );
  }

  /// `Close`
  String get close {
    return Intl.message(
      'Close',
      name: 'close',
      desc: '',
      args: [],
    );
  }

  /// `Please select the tooth area`
  String get selectToothAreaHint {
    return Intl.message(
      'Please select the tooth area',
      name: 'selectToothAreaHint',
      desc: '',
      args: [],
    );
  }

  /// `{selected} has been selected`
  String hasSelectXx(Object selected) {
    return Intl.message(
      '$selected has been selected',
      name: 'hasSelectXx',
      desc: '',
      args: [selected],
    );
  }

  /// `Upper left area`
  String get leftTopArea {
    return Intl.message(
      'Upper left area',
      name: 'leftTopArea',
      desc: '',
      args: [],
    );
  }

  /// `Lower left area`
  String get leftBototmArea {
    return Intl.message(
      'Lower left area',
      name: 'leftBototmArea',
      desc: '',
      args: [],
    );
  }

  /// `Upper right area`
  String get rightTopArea {
    return Intl.message(
      'Upper right area',
      name: 'rightTopArea',
      desc: '',
      args: [],
    );
  }

  /// `Lower right area`
  String get rightBottomArea {
    return Intl.message(
      'Lower right area',
      name: 'rightBottomArea',
      desc: '',
      args: [],
    );
  }

  /// `Unknown`
  String get unknown {
    return Intl.message(
      'Unknown',
      name: 'unknown',
      desc: '',
      args: [],
    );
  }

  /// `Please remain still`
  String get pleaseHold {
    return Intl.message(
      'Please remain still',
      name: 'pleaseHold',
      desc: '',
      args: [],
    );
  }

  /// `By time`
  String get byTime {
    return Intl.message(
      'By time',
      name: 'byTime',
      desc: '',
      args: [],
    );
  }

  /// `By type`
  String get byCategory {
    return Intl.message(
      'By type',
      name: 'byCategory',
      desc: '',
      args: [],
    );
  }

  /// `{count} items have been selected`
  String hasSelectCountItem(Object count) {
    return Intl.message(
      '$count items have been selected',
      name: 'hasSelectCountItem',
      desc: '',
      args: [count],
    );
  }

  /// `Upload`
  String get upload {
    return Intl.message(
      'Upload',
      name: 'upload',
      desc: '',
      args: [],
    );
  }

  /// `Delete`
  String get delete {
    return Intl.message(
      'Delete',
      name: 'delete',
      desc: '',
      args: [],
    );
  }

  /// `Please select the records you want to upload`
  String get pleaseSelectToUpload {
    return Intl.message(
      'Please select the records you want to upload',
      name: 'pleaseSelectToUpload',
      desc: '',
      args: [],
    );
  }

  /// `Please select the records you want to delete`
  String get pleaseSelectToDelete {
    return Intl.message(
      'Please select the records you want to delete',
      name: 'pleaseSelectToDelete',
      desc: '',
      args: [],
    );
  }

  /// `Do you delete {count} records?`
  String deleteMultiHint(Object count) {
    return Intl.message(
      'Do you delete $count records?',
      name: 'deleteMultiHint',
      desc: '',
      args: [count],
    );
  }

  /// `Select all`
  String get selectAll {
    return Intl.message(
      'Select all',
      name: 'selectAll',
      desc: '',
      args: [],
    );
  }

  /// `Please select the hospital you want to upload`
  String get pleaseSelectUploadClinic {
    return Intl.message(
      'Please select the hospital you want to upload',
      name: 'pleaseSelectUploadClinic',
      desc: '',
      args: [],
    );
  }

  /// `The connection timed out`
  String get connectTimeout {
    return Intl.message(
      'The connection timed out',
      name: 'connectTimeout',
      desc: '',
      args: [],
    );
  }

  /// `The request timed out`
  String get requestTimeout {
    return Intl.message(
      'The request timed out',
      name: 'requestTimeout',
      desc: '',
      args: [],
    );
  }

  /// `Response timed out`
  String get responseTimeout {
    return Intl.message(
      'Response timed out',
      name: 'responseTimeout',
      desc: '',
      args: [],
    );
  }

  /// `Request a cancellation`
  String get requestCancel {
    return Intl.message(
      'Request a cancellation',
      name: 'requestCancel',
      desc: '',
      args: [],
    );
  }

  /// `Request syntax error`
  String get requestGrammarError {
    return Intl.message(
      'Request syntax error',
      name: 'requestGrammarError',
      desc: '',
      args: [],
    );
  }

  /// `There are no permissions`
  String get noPermissions {
    return Intl.message(
      'There are no permissions',
      name: 'noPermissions',
      desc: '',
      args: [],
    );
  }

  /// `The server refuses to execute`
  String get serverRejectExec {
    return Intl.message(
      'The server refuses to execute',
      name: 'serverRejectExec',
      desc: '',
      args: [],
    );
  }

  /// `The requested resource does not exist`
  String get requestResourceExist {
    return Intl.message(
      'The requested resource does not exist',
      name: 'requestResourceExist',
      desc: '',
      args: [],
    );
  }

  /// `The request method is prohibited`
  String get requestMethodBanned {
    return Intl.message(
      'The request method is prohibited',
      name: 'requestMethodBanned',
      desc: '',
      args: [],
    );
  }

  /// `Server internal error`
  String get serverInternalError {
    return Intl.message(
      'Server internal error',
      name: 'serverInternalError',
      desc: '',
      args: [],
    );
  }

  /// `Wrong gateway`
  String get gateError {
    return Intl.message(
      'Wrong gateway',
      name: 'gateError',
      desc: '',
      args: [],
    );
  }

  /// `The server is abnormal`
  String get serverError {
    return Intl.message(
      'The server is abnormal',
      name: 'serverError',
      desc: '',
      args: [],
    );
  }

  /// `The gateway timed out`
  String get gateTimeout {
    return Intl.message(
      'The gateway timed out',
      name: 'gateTimeout',
      desc: '',
      args: [],
    );
  }

  /// `HTTP requests are not supported`
  String get notSupportHttpRequest {
    return Intl.message(
      'HTTP requests are not supported',
      name: 'notSupportHttpRequest',
      desc: '',
      args: [],
    );
  }

  /// `Unknown error`
  String get unknownException {
    return Intl.message(
      'Unknown error',
      name: 'unknownException',
      desc: '',
      args: [],
    );
  }

  /// `The network is not connected`
  String get notworkNotConnect {
    return Intl.message(
      'The network is not connected',
      name: 'notworkNotConnect',
      desc: '',
      args: [],
    );
  }

  /// `Connection error`
  String get connectError {
    return Intl.message(
      'Connection error',
      name: 'connectError',
      desc: '',
      args: [],
    );
  }

  /// `Certificate error`
  String get certificateError {
    return Intl.message(
      'Certificate error',
      name: 'certificateError',
      desc: '',
      args: [],
    );
  }

  /// `There is no data`
  String get noData {
    return Intl.message(
      'There is no data',
      name: 'noData',
      desc: '',
      args: [],
    );
  }

  /// `Uploading in progress, do you want to stop uploading?`
  String get stopUploadAlert {
    return Intl.message(
      'Uploading in progress, do you want to stop uploading?',
      name: 'stopUploadAlert',
      desc: '',
      args: [],
    );
  }

  /// `Please enter the patient's ID number`
  String get pleaseInputPatientIdCard {
    return Intl.message(
      'Please enter the patient\'s ID number',
      name: 'pleaseInputPatientIdCard',
      desc: '',
      args: [],
    );
  }

  /// `Please enter a valid ID number`
  String get pleaseInputValidIdCard {
    return Intl.message(
      'Please enter a valid ID number',
      name: 'pleaseInputValidIdCard',
      desc: '',
      args: [],
    );
  }

  /// `During uploading, do not close the current page or exit the app`
  String get uploadingHint {
    return Intl.message(
      'During uploading, do not close the current page or exit the app',
      name: 'uploadingHint',
      desc: '',
      args: [],
    );
  }

  /// `There are no files that can be uploaded`
  String get noFileCanUpload {
    return Intl.message(
      'There are no files that can be uploaded',
      name: 'noFileCanUpload',
      desc: '',
      args: [],
    );
  }

  /// `The interface is abnormal and the upload fails,please try again`
  String get uploadFailedByInterfaceError {
    return Intl.message(
      'The interface is abnormal and the upload fails,please try again',
      name: 'uploadFailedByInterfaceError',
      desc: '',
      args: [],
    );
  }

  /// `The app is not granted the necessary permissions to use the function properly`
  String get notGrantedPermissionCannotUse {
    return Intl.message(
      'The app is not granted the necessary permissions to use the function properly',
      name: 'notGrantedPermissionCannotUse',
      desc: '',
      args: [],
    );
  }

  /// `The upload failed, please try again`
  String get uploadFailedPleaseRetry {
    return Intl.message(
      'The upload failed, please try again',
      name: 'uploadFailedPleaseRetry',
      desc: '',
      args: [],
    );
  }

  /// `The upload is successful`
  String get uploadSuccess {
    return Intl.message(
      'The upload is successful',
      name: 'uploadSuccess',
      desc: '',
      args: [],
    );
  }

  /// `Upload failed`
  String get uploadFailed {
    return Intl.message(
      'Upload failed',
      name: 'uploadFailed',
      desc: '',
      args: [],
    );
  }

  /// `Please connect to the external network Wifi first`
  String get pleaseConnectInternetWifi {
    return Intl.message(
      'Please connect to the external network Wifi first',
      name: 'pleaseConnectInternetWifi',
      desc: '',
      args: [],
    );
  }

  /// `Delayed shooting`
  String get delayShot {
    return Intl.message(
      'Delayed shooting',
      name: 'delayShot',
      desc: '',
      args: [],
    );
  }

  /// `Sign out`
  String get logout {
    return Intl.message(
      'Sign out',
      name: 'logout',
      desc: '',
      args: [],
    );
  }

  /// `User Agreement`
  String get userAgreement {
    return Intl.message(
      'User Agreement',
      name: 'userAgreement',
      desc: '',
      args: [],
    );
  }

  /// `Privacy Policy`
  String get privacyPolicy {
    return Intl.message(
      'Privacy Policy',
      name: 'privacyPolicy',
      desc: '',
      args: [],
    );
  }

  /// `"User Agreement"`
  String get userAgreementBookTitle {
    return Intl.message(
      '"User Agreement"',
      name: 'userAgreementBookTitle',
      desc: '',
      args: [],
    );
  }

  /// `"Privacy Policy"`
  String get privacyPolicyBookTitle {
    return Intl.message(
      '"Privacy Policy"',
      name: 'privacyPolicyBookTitle',
      desc: '',
      args: [],
    );
  }

  /// `Detect the version`
  String get checkVersion {
    return Intl.message(
      'Detect the version',
      name: 'checkVersion',
      desc: '',
      args: [],
    );
  }

  /// `A new version was discovered`
  String get hasNewVersion {
    return Intl.message(
      'A new version was discovered',
      name: 'hasNewVersion',
      desc: '',
      args: [],
    );
  }

  /// `It's already the latest version`
  String get alreadyLatestVersion {
    return Intl.message(
      'It\'s already the latest version',
      name: 'alreadyLatestVersion',
      desc: '',
      args: [],
    );
  }

  /// `Update now`
  String get updateNow {
    return Intl.message(
      'Update now',
      name: 'updateNow',
      desc: '',
      args: [],
    );
  }

  /// `Next time`
  String get nextTime {
    return Intl.message(
      'Next time',
      name: 'nextTime',
      desc: '',
      args: [],
    );
  }

  /// `Cancel the download`
  String get cancelDownload {
    return Intl.message(
      'Cancel the download',
      name: 'cancelDownload',
      desc: '',
      args: [],
    );
  }

  /// `The download is complete`
  String get downloadComplete {
    return Intl.message(
      'The download is complete',
      name: 'downloadComplete',
      desc: '',
      args: [],
    );
  }

  /// `Install`
  String get install {
    return Intl.message(
      'Install',
      name: 'install',
      desc: '',
      args: [],
    );
  }

  /// `Downloading`
  String get downloading {
    return Intl.message(
      'Downloading',
      name: 'downloading',
      desc: '',
      args: [],
    );
  }

  /// `The download failed`
  String get downloadFailed {
    return Intl.message(
      'The download failed',
      name: 'downloadFailed',
      desc: '',
      args: [],
    );
  }

  /// `Unregistered mobile phone numbers will be automatically registered after verification`
  String get registerHint {
    return Intl.message(
      'Unregistered mobile phone numbers will be automatically registered after verification',
      name: 'registerHint',
      desc: '',
      args: [],
    );
  }

  /// `Send`
  String get send {
    return Intl.message(
      'Send',
      name: 'send',
      desc: '',
      args: [],
    );
  }

  /// `Login`
  String get login {
    return Intl.message(
      'Login',
      name: 'login',
      desc: '',
      args: [],
    );
  }

  /// `Mobile:`
  String get mobileColon {
    return Intl.message(
      'Mobile:',
      name: 'mobileColon',
      desc: '',
      args: [],
    );
  }

  /// `Captcha:`
  String get captchaColon {
    return Intl.message(
      'Captcha:',
      name: 'captchaColon',
      desc: '',
      args: [],
    );
  }

  /// `Please enter your mobile phone number`
  String get mobileInputHint {
    return Intl.message(
      'Please enter your mobile phone number',
      name: 'mobileInputHint',
      desc: '',
      args: [],
    );
  }

  /// `Please enter a captcha`
  String get captchaInputHint {
    return Intl.message(
      'Please enter a captcha',
      name: 'captchaInputHint',
      desc: '',
      args: [],
    );
  }

  /// `Please enter a valid mobile phone number`
  String get mobileFormatError {
    return Intl.message(
      'Please enter a valid mobile phone number',
      name: 'mobileFormatError',
      desc: '',
      args: [],
    );
  }

  /// `The captcha is incorrect`
  String get captchaError {
    return Intl.message(
      'The captcha is incorrect',
      name: 'captchaError',
      desc: '',
      args: [],
    );
  }

  /// `A captcha has been sent`
  String get captchaHasSend {
    return Intl.message(
      'A captcha has been sent',
      name: 'captchaHasSend',
      desc: '',
      args: [],
    );
  }

  /// `The captcha failed to be sent`
  String get captchaSendError {
    return Intl.message(
      'The captcha failed to be sent',
      name: 'captchaSendError',
      desc: '',
      args: [],
    );
  }

  /// `Login successful`
  String get loginSuccess {
    return Intl.message(
      'Login successful',
      name: 'loginSuccess',
      desc: '',
      args: [],
    );
  }

  /// `Login failed`
  String get loginFailed {
    return Intl.message(
      'Login failed',
      name: 'loginFailed',
      desc: '',
      args: [],
    );
  }

  /// `Whether to log out?`
  String get logoutHint {
    return Intl.message(
      'Whether to log out?',
      name: 'logoutHint',
      desc: '',
      args: [],
    );
  }

  /// `I have read and agreed`
  String get readAndAgree {
    return Intl.message(
      'I have read and agreed',
      name: 'readAndAgree',
      desc: '',
      args: [],
    );
  }

  /// `Please read and agree to the User Agreement and Privacy Policy`
  String get needReadAndAgree {
    return Intl.message(
      'Please read and agree to the User Agreement and Privacy Policy',
      name: 'needReadAndAgree',
      desc: '',
      args: [],
    );
  }

  /// `Switch`
  String get switchPatient {
    return Intl.message(
      'Switch',
      name: 'switchPatient',
      desc: '',
      args: [],
    );
  }

  /// `Add`
  String get addPatient {
    return Intl.message(
      'Add',
      name: 'addPatient',
      desc: '',
      args: [],
    );
  }

  /// `Data is syncing, please wait`
  String get syncDataWaiting {
    return Intl.message(
      'Data is syncing, please wait',
      name: 'syncDataWaiting',
      desc: '',
      args: [],
    );
  }

  /// `Please add a new patient for the first use`
  String get needAddPatient {
    return Intl.message(
      'Please add a new patient for the first use',
      name: 'needAddPatient',
      desc: '',
      args: [],
    );
  }

  /// `Select the patient`
  String get selectPatient {
    return Intl.message(
      'Select the patient',
      name: 'selectPatient',
      desc: '',
      args: [],
    );
  }

  /// `Patient list`
  String get patientList {
    return Intl.message(
      'Patient list',
      name: 'patientList',
      desc: '',
      args: [],
    );
  }

  /// `Please select a patient`
  String get pleaseSelectPatient {
    return Intl.message(
      'Please select a patient',
      name: 'pleaseSelectPatient',
      desc: '',
      args: [],
    );
  }

  /// `Submit`
  String get submit {
    return Intl.message(
      'Submit',
      name: 'submit',
      desc: '',
      args: [],
    );
  }

  /// `You can add up to four new consultants, including you. \nOnce the information of the referrer is completed, it is not allowed to be modified, so please fill it in carefully.`
  String get addPatientHint {
    return Intl.message(
      'You can add up to four new consultants, including you. \nOnce the information of the referrer is completed, it is not allowed to be modified, so please fill it in carefully.',
      name: 'addPatientHint',
      desc: '',
      args: [],
    );
  }

  /// `Relationship`
  String get relation {
    return Intl.message(
      'Relationship',
      name: 'relation',
      desc: '',
      args: [],
    );
  }

  /// `Name`
  String get name {
    return Intl.message(
      'Name',
      name: 'name',
      desc: '',
      args: [],
    );
  }

  /// `Gender`
  String get gender {
    return Intl.message(
      'Gender',
      name: 'gender',
      desc: '',
      args: [],
    );
  }

  /// `Age`
  String get age {
    return Intl.message(
      'Age',
      name: 'age',
      desc: '',
      args: [],
    );
  }

  /// `ID number`
  String get idCard {
    return Intl.message(
      'ID number',
      name: 'idCard',
      desc: '',
      args: [],
    );
  }

  /// `Please select your personal relationship`
  String get pleaseSelectRelation {
    return Intl.message(
      'Please select your personal relationship',
      name: 'pleaseSelectRelation',
      desc: '',
      args: [],
    );
  }

  /// `Please enter your real name`
  String get pleaseInputRealName {
    return Intl.message(
      'Please enter your real name',
      name: 'pleaseInputRealName',
      desc: '',
      args: [],
    );
  }

  /// `Male`
  String get male {
    return Intl.message(
      'Male',
      name: 'male',
      desc: '',
      args: [],
    );
  }

  /// `Female`
  String get female {
    return Intl.message(
      'Female',
      name: 'female',
      desc: '',
      args: [],
    );
  }

  /// `Please enter your age`
  String get pleaseInputAge {
    return Intl.message(
      'Please enter your age',
      name: 'pleaseInputAge',
      desc: '',
      args: [],
    );
  }

  /// `The age does not match the age on the ID card`
  String get ageNotMatchIdCard {
    return Intl.message(
      'The age does not match the age on the ID card',
      name: 'ageNotMatchIdCard',
      desc: '',
      args: [],
    );
  }

  /// `The gender does not match the gender in the ID card`
  String get genderNotMatchIdCard {
    return Intl.message(
      'The gender does not match the gender in the ID card',
      name: 'genderNotMatchIdCard',
      desc: '',
      args: [],
    );
  }

  /// `Preview the photo`
  String get previewPhoto {
    return Intl.message(
      'Preview the photo',
      name: 'previewPhoto',
      desc: '',
      args: [],
    );
  }

  /// `Preview the video`
  String get previewVideo {
    return Intl.message(
      'Preview the video',
      name: 'previewVideo',
      desc: '',
      args: [],
    );
  }

  /// `Save`
  String get save {
    return Intl.message(
      'Save',
      name: 'save',
      desc: '',
      args: [],
    );
  }

  /// `Remake`
  String get retakePhoto {
    return Intl.message(
      'Remake',
      name: 'retakePhoto',
      desc: '',
      args: [],
    );
  }

  /// `Not selected`
  String get unselected {
    return Intl.message(
      'Not selected',
      name: 'unselected',
      desc: '',
      args: [],
    );
  }

  /// `Please photograph the oral {area}, and the best distance is 1.5 cm`
  String takePhotoAreaHint(Object area) {
    return Intl.message(
      'Please photograph the oral $area, and the best distance is 1.5 cm',
      name: 'takePhotoAreaHint',
      desc: '',
      args: [area],
    );
  }

  /// `{age} years old`
  String xxAge(Object age) {
    return Intl.message(
      '$age years old',
      name: 'xxAge',
      desc: '',
      args: [age],
    );
  }

  /// `Save failed`
  String get saveFailed {
    return Intl.message(
      'Save failed',
      name: 'saveFailed',
      desc: '',
      args: [],
    );
  }

  /// `Save success`
  String get saveSuccess {
    return Intl.message(
      'Save success',
      name: 'saveSuccess',
      desc: '',
      args: [],
    );
  }

  /// `You've already added four patients and can't add any more.`
  String get maxPatientCount {
    return Intl.message(
      'You\'ve already added four patients and can\'t add any more.',
      name: 'maxPatientCount',
      desc: '',
      args: [],
    );
  }

  /// `The login information is no longer valid, please log in again`
  String get tokenInvalidHint {
    return Intl.message(
      'The login information is no longer valid, please log in again',
      name: 'tokenInvalidHint',
      desc: '',
      args: [],
    );
  }

  /// `Agree`
  String get agree {
    return Intl.message(
      'Agree',
      name: 'agree',
      desc: '',
      args: [],
    );
  }

  /// `Disagree`
  String get disagree {
    return Intl.message(
      'Disagree',
      name: 'disagree',
      desc: '',
      args: [],
    );
  }

  /// `Quit the app`
  String get exitApp {
    return Intl.message(
      'Quit the app',
      name: 'exitApp',
      desc: '',
      args: [],
    );
  }

  /// `Permission description`
  String get permissionDescription {
    return Intl.message(
      'Permission description',
      name: 'permissionDescription',
      desc: '',
      args: [],
    );
  }

  /// `"Permission description"`
  String get permissionDescriptionBookTitle {
    return Intl.message(
      '"Permission description"',
      name: 'permissionDescriptionBookTitle',
      desc: '',
      args: [],
    );
  }

  /// `User Agreement and Privacy Policy Reminder`
  String get permissionDescDialogTitle {
    return Intl.message(
      'User Agreement and Privacy Policy Reminder',
      name: 'permissionDescDialogTitle',
      desc: '',
      args: [],
    );
  }

  /// `Welcome to {appName}!\n\nWe have formulated the User Agreement and Privacy Policy in accordance with relevant laws to help you understand how we collect, store and use your personal information. \n\nBased on your express authorization, we may call your device permissions, and you have the right to refuse or cancel the authorization, please refer to the "Permission Description" for specific permission acquisition`
  String permissionDescDialogContent(Object appName) {
    return Intl.message(
      'Welcome to $appName!\n\nWe have formulated the User Agreement and Privacy Policy in accordance with relevant laws to help you understand how we collect, store and use your personal information. \n\nBased on your express authorization, we may call your device permissions, and you have the right to refuse or cancel the authorization, please refer to the "Permission Description" for specific permission acquisition',
      name: 'permissionDescDialogContent',
      desc: '',
      args: [appName],
    );
  }

  /// `Read`
  String get read {
    return Intl.message(
      'Read',
      name: 'read',
      desc: '',
      args: [],
    );
  }

  /// `Agree`
  String get agreeContinue {
    return Intl.message(
      'Agree',
      name: 'agreeContinue',
      desc: '',
      args: [],
    );
  }

  /// `Since the application companion instrument uses WiFi connection, you need to judge whether you have connected to the WiFi of the instrument through the location permission, and request your location permission, please click Allow in the next pop-up window.`
  String get requestLocationHint {
    return Intl.message(
      'Since the application companion instrument uses WiFi connection, you need to judge whether you have connected to the WiFi of the instrument through the location permission, and request your location permission, please click Allow in the next pop-up window.',
      name: 'requestLocationHint',
      desc: '',
      args: [],
    );
  }

  /// `Select Photos`
  String get selectPhoto {
    return Intl.message(
      'Select Photos',
      name: 'selectPhoto',
      desc: '',
      args: [],
    );
  }

  /// `Select Recording`
  String get selectRecord {
    return Intl.message(
      'Select Recording',
      name: 'selectRecord',
      desc: '',
      args: [],
    );
  }

  /// `Select Photo & Video Recording`
  String get selectPhotoAndRecord {
    return Intl.message(
      'Select Photo & Video Recording',
      name: 'selectPhotoAndRecord',
      desc: '',
      args: [],
    );
  }

  /// `You can choose up to {count}`
  String maxSelectCountXx(Object count) {
    return Intl.message(
      'You can choose up to $count',
      name: 'maxSelectCountXx',
      desc: '',
      args: [count],
    );
  }

  /// `Please select at least one`
  String get pleaseSelectAtLastOne {
    return Intl.message(
      'Please select at least one',
      name: 'pleaseSelectAtLastOne',
      desc: '',
      args: [],
    );
  }
}

class AppLocalizationDelegate extends LocalizationsDelegate<S> {
  const AppLocalizationDelegate();

  List<Locale> get supportedLocales {
    return const <Locale>[
      Locale.fromSubtags(languageCode: 'en'),
      Locale.fromSubtags(languageCode: 'zh'),
    ];
  }

  @override
  bool isSupported(Locale locale) => _isSupported(locale);
  @override
  Future<S> load(Locale locale) => S.load(locale);
  @override
  bool shouldReload(AppLocalizationDelegate old) => false;

  bool _isSupported(Locale locale) {
    for (var supportedLocale in supportedLocales) {
      if (supportedLocale.languageCode == locale.languageCode) {
        return true;
      }
    }
    return false;
  }
}
