// Copyright 2014 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file has been automatically generated. Please do not edit it manually.
// To regenerate the file, use:
// dart dev/tools/localization/bin/gen_localizations.dart --overwrite

import 'dart:collection';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:intl/intl.dart' as intl;

import '../material_localizations.dart';

// The classes defined here encode all of the translations found in the
// `flutter_localizations/lib/src/l10n/*.arb` files.
//
// These classes are constructed by the [getMaterialTranslation] method at the
// bottom of this file, and used by the [_MaterialLocalizationsDelegate.load]
// method defined in `flutter_localizations/lib/src/material_localizations.dart`.

/// The translations for Afrikaans (`af`).
class MaterialLocalizationAf extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Afrikaans.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationAf({
    String localeName = 'af',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Meer oor \$applicationName';

  @override
  String get alertDialogLabel => 'Opletberig';

  @override
  String get anteMeridiemAbbreviation => 'vm.';

  @override
  String get backButtonTooltip => 'Terug';

  @override
  String get cancelButtonLabel => 'KANSELLEER';

  @override
  String get closeButtonLabel => 'MAAK TOE';

  @override
  String get closeButtonTooltip => 'Maak toe';

  @override
  String get collapsedIconTapHint => 'Vou uit';

  @override
  String get continueButtonLabel => 'GAAN VOORT';

  @override
  String get copyButtonLabel => 'KOPIEER';

  @override
  String get cutButtonLabel => 'KNIP';

  @override
  String get deleteButtonTooltip => 'Vee uit';

  @override
  String get dialogLabel => 'Dialoog';

  @override
  String get drawerLabel => 'Navigasiekieslys';

  @override
  String get expandedIconTapHint => 'Vou in';

  @override
  String get hideAccountsLabel => 'Versteek rekeninge';

  @override
  String get licensesPageTitle => 'Lisensies';

  @override
  String get modalBarrierDismissLabel => 'Maak toe';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Volgende maand';

  @override
  String get nextPageTooltip => 'Volgende bladsy';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Maak navigasiekieslys oop';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow van \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow van ongeveer \$rowCount';

  @override
  String get pasteButtonLabel => 'PLAK';

  @override
  String get popupMenuLabel => 'Opspringkieslys';

  @override
  String get postMeridiemAbbreviation => 'nm.';

  @override
  String get previousMonthTooltip => 'Vorige maand';

  @override
  String get previousPageTooltip => 'Vorige bladsy';

  @override
  String get refreshIndicatorSemanticLabel => 'Herlaai';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 karakter oor';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount karakters oor';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Skuif af';

  @override
  String get reorderItemLeft => 'Skuif na links';

  @override
  String get reorderItemRight => 'Skuif na regs';

  @override
  String get reorderItemToEnd => 'Skuif na die einde';

  @override
  String get reorderItemToStart => 'Skuif na die begin';

  @override
  String get reorderItemUp => 'Skuif op';

  @override
  String get rowsPerPageTitle => 'Rye per bladsy:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Soek';

  @override
  String get selectAllButtonLabel => 'KIES ALLES';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item is gekies';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount items is gekies';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Wys rekeninge';

  @override
  String get showMenuTooltip => 'Wys kieslys';

  @override
  String get signedInLabel => 'Aangemeld';

  @override
  String get tabLabelRaw => 'Oortjie \$tabIndex van \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Kies ure';

  @override
  String get timePickerMinuteModeAnnouncement => 'Kies minute';

  @override
  String get viewLicensesButtonLabel => 'BEKYK LISENSIES';
}

/// The translations for Amharic (`am`).
class MaterialLocalizationAm extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Amharic.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationAm({
    String localeName = 'am',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'ስለ \$applicationName';

  @override
  String get alertDialogLabel => 'ማንቂያ';

  @override
  String get anteMeridiemAbbreviation => 'ጥዋት';

  @override
  String get backButtonTooltip => 'ተመለስ';

  @override
  String get cancelButtonLabel => 'ይቅር';

  @override
  String get closeButtonLabel => 'ዝጋ';

  @override
  String get closeButtonTooltip => 'ዝጋ';

  @override
  String get collapsedIconTapHint => 'ዘርጋ';

  @override
  String get continueButtonLabel => 'ቀጥል';

  @override
  String get copyButtonLabel => 'ቅዳ';

  @override
  String get cutButtonLabel => 'ቁረጥ';

  @override
  String get deleteButtonTooltip => 'ሰርዝ';

  @override
  String get dialogLabel => 'መገናኛ';

  @override
  String get drawerLabel => 'የዳሰሳ ምናሌ';

  @override
  String get expandedIconTapHint => 'ሰብስብ';

  @override
  String get hideAccountsLabel => 'መለያዎችን ደብቅ';

  @override
  String get licensesPageTitle => 'ፈቃዶች';

  @override
  String get modalBarrierDismissLabel => 'አሰናብት';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ቀጣይ ወር';

  @override
  String get nextPageTooltip => 'ቀጣይ ገጽ';

  @override
  String get okButtonLabel => 'እሺ';

  @override
  String get openAppDrawerTooltip => 'የዳሰሳ ምናሌን ክፈት';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow ከ\$rowCount ውስጥ';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow ከ\$rowCount ያህል ውስጥ';

  @override
  String get pasteButtonLabel => 'ለጥፍ';

  @override
  String get popupMenuLabel => 'የብቅ-ባይ ምናሌ';

  @override
  String get postMeridiemAbbreviation => 'ከሰዓት';

  @override
  String get previousMonthTooltip => 'ቀዳሚ ወር';

  @override
  String get previousPageTooltip => 'ቀዳሚ ገጽ';

  @override
  String get refreshIndicatorSemanticLabel => 'አድስ';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 ቁምፊ ይቀራል';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount ቁምፊዎች ይቀራሉ';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'ወደ ታች ውሰድ';

  @override
  String get reorderItemLeft => 'ወደ ግራ ውሰድ';

  @override
  String get reorderItemRight => 'ወደ ቀኝ ውሰድ';

  @override
  String get reorderItemToEnd => 'ወደ መጨረሻ ውሰድ';

  @override
  String get reorderItemToStart => 'ወደ መጀመሪያ ውሰድ';

  @override
  String get reorderItemUp => 'ወደ ላይ ውሰድ';

  @override
  String get rowsPerPageTitle => 'ረድፎች በገጽ፦';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'ይፈልጉ';

  @override
  String get selectAllButtonLabel => 'ሁሉንም ምረጥ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 ንጥል ተመርጧል';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount ንጥሎች ተመርጠዋል';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'መለያዎችን አሳይ';

  @override
  String get showMenuTooltip => 'ምናሌን አሳይ';

  @override
  String get signedInLabel => 'በመለያ ገብቷል';

  @override
  String get tabLabelRaw => 'ትር \$tabIndex ከ\$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'ሰዓታትን ምረጥ';

  @override
  String get timePickerMinuteModeAnnouncement => 'ደቂቃዎችን ይምረጡ';

  @override
  String get viewLicensesButtonLabel => 'ፈቃዶችን ይመልከቱ';
}

/// The translations for Arabic (`ar`).
class MaterialLocalizationAr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Arabic.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationAr({
    String localeName = 'ar',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'حول \"\$applicationName\"';

  @override
  String get alertDialogLabel => 'تنبيه';

  @override
  String get anteMeridiemAbbreviation => 'ص';

  @override
  String get backButtonTooltip => 'رجوع';

  @override
  String get cancelButtonLabel => 'إلغاء';

  @override
  String get closeButtonLabel => 'إغلاق';

  @override
  String get closeButtonTooltip => 'إغلاق';

  @override
  String get collapsedIconTapHint => 'توسيع';

  @override
  String get continueButtonLabel => 'متابعة';

  @override
  String get copyButtonLabel => 'نسخ';

  @override
  String get cutButtonLabel => 'قص';

  @override
  String get deleteButtonTooltip => 'حذف';

  @override
  String get dialogLabel => 'مربع حوار';

  @override
  String get drawerLabel => 'قائمة تنقل';

  @override
  String get expandedIconTapHint => 'تصغير';

  @override
  String get hideAccountsLabel => 'إخفاء الحسابات';

  @override
  String get licensesPageTitle => 'التراخيص';

  @override
  String get modalBarrierDismissLabel => 'رفض';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'الشهر التالي';

  @override
  String get nextPageTooltip => 'الصفحة التالية';

  @override
  String get okButtonLabel => 'حسنًا';

  @override
  String get openAppDrawerTooltip => 'فتح قائمة التنقل';

  @override
  String get pageRowsInfoTitleRaw => 'من \$firstRow إلى \$lastRow من إجمالي \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'من \$firstRow إلى \$lastRow من إجمالي \$rowCount تقريبًا';

  @override
  String get pasteButtonLabel => 'لصق';

  @override
  String get popupMenuLabel => 'قائمة منبثقة';

  @override
  String get postMeridiemAbbreviation => 'م';

  @override
  String get previousMonthTooltip => 'الشهر السابق';

  @override
  String get previousPageTooltip => 'الصفحة السابقة';

  @override
  String get refreshIndicatorSemanticLabel => 'إعادة تحميل';

  @override
  String get remainingTextFieldCharacterCountFew => '\$remainingCount أحرف متبقية';

  @override
  String get remainingTextFieldCharacterCountMany => '\$remainingCount حرفًا متبقيًا';

  @override
  String get remainingTextFieldCharacterCountOne => 'حرف واحد متبقٍ';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount حرف متبقٍ';

  @override
  String get remainingTextFieldCharacterCountTwo => 'حرفان (\$remainingCount) متبقيان';

  @override
  String get remainingTextFieldCharacterCountZero => 'لا أحرف متبقية';

  @override
  String get reorderItemDown => 'نقل لأسفل';

  @override
  String get reorderItemLeft => 'نقل لليمين';

  @override
  String get reorderItemRight => 'نقل لليسار';

  @override
  String get reorderItemToEnd => 'نقل إلى نهاية القائمة';

  @override
  String get reorderItemToStart => 'نقل إلى بداية القائمة';

  @override
  String get reorderItemUp => 'نقل لأعلى';

  @override
  String get rowsPerPageTitle => 'عدد الصفوف في الصفحة:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'بحث';

  @override
  String get selectAllButtonLabel => 'اختيار الكل';

  @override
  String get selectedRowCountTitleFew => 'تم اختيار \$selectedRowCount عنصر';

  @override
  String get selectedRowCountTitleMany => 'تم اختيار \$selectedRowCount عنصرًا';

  @override
  String get selectedRowCountTitleOne => 'تم اختيار عنصر واحد';

  @override
  String get selectedRowCountTitleOther => 'تم اختيار \$selectedRowCount عنصر';

  @override
  String get selectedRowCountTitleTwo => 'تم اختيار عنصرين (\$selectedRowCount)';

  @override
  String get selectedRowCountTitleZero => 'لم يتم اختيار أي عنصر';

  @override
  String get showAccountsLabel => 'إظهار الحسابات';

  @override
  String get showMenuTooltip => 'عرض القائمة';

  @override
  String get signedInLabel => 'تم تسجيل الدخول';

  @override
  String get tabLabelRaw => 'علامة التبويب \$tabIndex من \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'اختيار الساعات';

  @override
  String get timePickerMinuteModeAnnouncement => 'اختيار الدقائق';

  @override
  String get viewLicensesButtonLabel => 'الاطّلاع على التراخيص';
}

/// The translations for Assamese (`as`).
class MaterialLocalizationAs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Assamese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationAs({
    String localeName = 'as',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationNameৰ বিষয়ে';

  @override
  String get alertDialogLabel => 'সতৰ্কবাৰ্তা';

  @override
  String get anteMeridiemAbbreviation => 'পূৰ্বাহ্ন';

  @override
  String get backButtonTooltip => 'উভতি যাওক';

  @override
  String get cancelButtonLabel => 'বাতিল কৰক';

  @override
  String get closeButtonLabel => 'বন্ধ কৰক';

  @override
  String get closeButtonTooltip => 'বন্ধ কৰক';

  @override
  String get collapsedIconTapHint => 'বিস্তাৰ কৰক';

  @override
  String get continueButtonLabel => 'অব্যাহত ৰাখক';

  @override
  String get copyButtonLabel => 'প্ৰতিলিপি কৰক';

  @override
  String get cutButtonLabel => 'কাট কৰক';

  @override
  String get deleteButtonTooltip => 'মচক';

  @override
  String get dialogLabel => 'ডায়ল\'গ';

  @override
  String get drawerLabel => 'নেভিগেশ্বন মেনু';

  @override
  String get expandedIconTapHint => 'সংকোচন কৰক';

  @override
  String get hideAccountsLabel => 'একাউণ্টসমূহ লুকুৱাওক';

  @override
  String get licensesPageTitle => 'অনুজ্ঞাপত্ৰসমূহ';

  @override
  String get modalBarrierDismissLabel => 'অগ্ৰাহ্য কৰক';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'পৰৱৰ্তী মাহ';

  @override
  String get nextPageTooltip => 'পৰৱৰ্তী পৃষ্ঠা';

  @override
  String get okButtonLabel => 'ঠিক আছে';

  @override
  String get openAppDrawerTooltip => 'নেভিগেশ্বন মেনু খোলক';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCountৰ \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$rowCountৰ \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'পে\'ষ্ট কৰক';

  @override
  String get popupMenuLabel => 'প\'পআপ মেনু';

  @override
  String get postMeridiemAbbreviation => 'অপৰাহ্ন';

  @override
  String get previousMonthTooltip => 'পূৰ্বৱৰ্তী মাহ';

  @override
  String get previousPageTooltip => 'পূৰ্বৱৰ্তী পৃষ্ঠা';

  @override
  String get refreshIndicatorSemanticLabel => 'ৰিফ্ৰেশ্ব কৰক';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '১টা বর্ণ বাকী আছে';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCountটা বর্ণ বাকী আছে';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'তললৈ স্থানান্তৰ কৰক';

  @override
  String get reorderItemLeft => 'বাওঁফাললৈ স্থানান্তৰ কৰক';

  @override
  String get reorderItemRight => 'সোঁফাললৈ স্থানান্তৰ কৰক';

  @override
  String get reorderItemToEnd => 'শেষলৈ স্থানান্তৰ কৰক';

  @override
  String get reorderItemToStart => 'আৰম্ভণিলৈ স্থানান্তৰ কৰক';

  @override
  String get reorderItemUp => 'ওপৰলৈ নিয়ক';

  @override
  String get rowsPerPageTitle => 'প্ৰতিটো পৃষ্ঠাত থকা শাৰী:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'সন্ধান কৰক';

  @override
  String get selectAllButtonLabel => 'সকলো বাছনি কৰক';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '১টা বস্তু বাছনি কৰা হ\'ল';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCountটা বস্তু বাছনি কৰা হ’ল';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'একাউণ্টসমূহ দেখুৱাওক';

  @override
  String get showMenuTooltip => 'মেনুখন দেখুৱাওক';

  @override
  String get signedInLabel => 'ছাইন ইন কৰা হ’ল';

  @override
  String get tabLabelRaw => '\$tabCountৰ \$tabIndexটা টেব';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'সময় বাছনি কৰক';

  @override
  String get timePickerMinuteModeAnnouncement => 'মিনিট বাছনি কৰক';

  @override
  String get viewLicensesButtonLabel => 'অনুজ্ঞাপত্ৰসমূহ চাওক';
}

/// The translations for Azerbaijani (`az`).
class MaterialLocalizationAz extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Azerbaijani.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationAz({
    String localeName = 'az',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName haqqında';

  @override
  String get alertDialogLabel => 'Bildiriş';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Geri';

  @override
  String get cancelButtonLabel => 'LƏĞV EDİN';

  @override
  String get closeButtonLabel => 'BAĞLAYIN';

  @override
  String get closeButtonTooltip => 'Bağlayın';

  @override
  String get collapsedIconTapHint => 'Genişləndirin';

  @override
  String get continueButtonLabel => 'DAVAM EDİN';

  @override
  String get copyButtonLabel => 'KOPYALAYIN';

  @override
  String get cutButtonLabel => 'KƏSİN';

  @override
  String get deleteButtonTooltip => 'Silin';

  @override
  String get dialogLabel => 'Dialoq';

  @override
  String get drawerLabel => 'Naviqasiya menyusu';

  @override
  String get expandedIconTapHint => 'Yığcamlaşdırın';

  @override
  String get hideAccountsLabel => 'Hesabları gizlədin';

  @override
  String get licensesPageTitle => 'Lisenziyalar';

  @override
  String get modalBarrierDismissLabel => 'İmtina edin';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Növbəti ay';

  @override
  String get nextPageTooltip => 'Növbəti səhifə';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Naviqasiya menyusunu açın';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow/\$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow/ təxminən \$rowCount';

  @override
  String get pasteButtonLabel => 'YERLƏŞDİRİN';

  @override
  String get popupMenuLabel => 'Popap menyusu';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Keçən ay';

  @override
  String get previousPageTooltip => 'Əvvəlki səhifə';

  @override
  String get refreshIndicatorSemanticLabel => 'Yeniləyin';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 simvol qalır';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount simvol qalır';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Aşağı köçürün';

  @override
  String get reorderItemLeft => 'Sola köçürün';

  @override
  String get reorderItemRight => 'Sağa köçürün';

  @override
  String get reorderItemToEnd => 'Sona köçürün';

  @override
  String get reorderItemToStart => 'Əvvələ köçürün';

  @override
  String get reorderItemUp => 'Yuxarı köçürün';

  @override
  String get rowsPerPageTitle => 'Hər səhifə üzrə sıra:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Axtarın';

  @override
  String get selectAllButtonLabel => 'HAMISINI SEÇİN';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 element seçildi';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount element seçildi';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Hesabları göstərin';

  @override
  String get showMenuTooltip => 'Menyunu göstərin';

  @override
  String get signedInLabel => 'Daxil olundu';

  @override
  String get tabLabelRaw => '\$tabIndex/\$tabCount tab';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Saat seçin';

  @override
  String get timePickerMinuteModeAnnouncement => 'Dəqiqə seçin';

  @override
  String get viewLicensesButtonLabel => 'LİSENZİYALARA BAXIN';
}

/// The translations for Belarusian (`be`).
class MaterialLocalizationBe extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Belarusian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationBe({
    String localeName = 'be',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Інфармацыя пра праграму \"\$applicationName\"';

  @override
  String get alertDialogLabel => 'Абвестка';

  @override
  String get anteMeridiemAbbreviation => 'раніцы';

  @override
  String get backButtonTooltip => 'Назад';

  @override
  String get cancelButtonLabel => 'СКАСАВАЦЬ';

  @override
  String get closeButtonLabel => 'ЗАКРЫЦЬ';

  @override
  String get closeButtonTooltip => 'Закрыць';

  @override
  String get collapsedIconTapHint => 'Разгарнуць';

  @override
  String get continueButtonLabel => 'ПРАЦЯГНУЦЬ';

  @override
  String get copyButtonLabel => 'КАПІРАВАЦЬ';

  @override
  String get cutButtonLabel => 'ВЫРАЗАЦЬ';

  @override
  String get deleteButtonTooltip => 'Выдаліць';

  @override
  String get dialogLabel => 'Дыялогавае акно';

  @override
  String get drawerLabel => 'Меню навігацыі';

  @override
  String get expandedIconTapHint => 'Згарнуць';

  @override
  String get hideAccountsLabel => 'Схаваць уліковыя запісы';

  @override
  String get licensesPageTitle => 'Ліцэнзіі';

  @override
  String get modalBarrierDismissLabel => 'Адхіліць';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Наступны месяц';

  @override
  String get nextPageTooltip => 'Наступная старонка';

  @override
  String get okButtonLabel => 'ОК';

  @override
  String get openAppDrawerTooltip => 'Адкрыць меню навігацыі';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow з \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow з прыблізна \$rowCount';

  @override
  String get pasteButtonLabel => 'УСТАВІЦЬ';

  @override
  String get popupMenuLabel => 'Меню ўсплывальнага акна';

  @override
  String get postMeridiemAbbreviation => 'вечара';

  @override
  String get previousMonthTooltip => 'Папярэдні месяц';

  @override
  String get previousPageTooltip => 'Папярэдняя старонка';

  @override
  String get refreshIndicatorSemanticLabel => 'Абнавіць';

  @override
  String get remainingTextFieldCharacterCountFew => 'Засталося \$remainingCount сімвалы';

  @override
  String get remainingTextFieldCharacterCountMany => 'Засталося \$remainingCount сімвалаў';

  @override
  String get remainingTextFieldCharacterCountOne => 'Застаўся 1 сімвал';

  @override
  String get remainingTextFieldCharacterCountOther => 'Засталося \$remainingCount сімвала';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Перамясціць уніз';

  @override
  String get reorderItemLeft => 'Перамясціць улева';

  @override
  String get reorderItemRight => 'Перамясціць управа';

  @override
  String get reorderItemToEnd => 'Перамясціць у канец';

  @override
  String get reorderItemToStart => 'Перамясціць у пачатак';

  @override
  String get reorderItemUp => 'Перамясціць уверх';

  @override
  String get rowsPerPageTitle => 'Радкоў на старонку:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Пошук';

  @override
  String get selectAllButtonLabel => 'ВЫБРАЦЬ УСЕ';

  @override
  String get selectedRowCountTitleFew => 'Выбрана \$selectedRowCount элементы';

  @override
  String get selectedRowCountTitleMany => 'Выбрана \$selectedRowCount элементаў';

  @override
  String get selectedRowCountTitleOne => 'Выбраны 1 элемент';

  @override
  String get selectedRowCountTitleOther => 'Выбрана \$selectedRowCount элемента';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Паказаць уліковыя запісы';

  @override
  String get showMenuTooltip => 'Паказаць меню';

  @override
  String get signedInLabel => 'Уваход выкананы';

  @override
  String get tabLabelRaw => 'Укладка \$tabIndex з \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Выберыце гадзіны';

  @override
  String get timePickerMinuteModeAnnouncement => 'Выберыце хвіліны';

  @override
  String get viewLicensesButtonLabel => 'ПАКАЗАЦЬ ЛІЦЭНЗІІ';
}

/// The translations for Bulgarian (`bg`).
class MaterialLocalizationBg extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Bulgarian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationBg({
    String localeName = 'bg',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Всичко за \$applicationName';

  @override
  String get alertDialogLabel => 'Сигнал';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Назад';

  @override
  String get cancelButtonLabel => 'ОТКАЗ';

  @override
  String get closeButtonLabel => 'ЗАТВАРЯНЕ';

  @override
  String get closeButtonTooltip => 'Затваряне';

  @override
  String get collapsedIconTapHint => 'Разгъване';

  @override
  String get continueButtonLabel => 'НАПРЕД';

  @override
  String get copyButtonLabel => 'КОПИРАНЕ';

  @override
  String get cutButtonLabel => 'ИЗРЯЗВАНЕ';

  @override
  String get deleteButtonTooltip => 'Изтриване';

  @override
  String get dialogLabel => 'Диалогов прозорец';

  @override
  String get drawerLabel => 'Меню за навигация';

  @override
  String get expandedIconTapHint => 'Свиване';

  @override
  String get hideAccountsLabel => 'Скриване на профилите';

  @override
  String get licensesPageTitle => 'Лицензи';

  @override
  String get modalBarrierDismissLabel => 'Отхвърляне';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Следващият месец';

  @override
  String get nextPageTooltip => 'Следващата страница';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Отваряне на менюто за навигация';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow от \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow от около \$rowCount';

  @override
  String get pasteButtonLabel => 'ПОСТАВЯНЕ';

  @override
  String get popupMenuLabel => 'Изскачащо меню';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Предишният месец';

  @override
  String get previousPageTooltip => 'Предишната страница';

  @override
  String get refreshIndicatorSemanticLabel => 'Опресняване';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Остава 1 знак';

  @override
  String get remainingTextFieldCharacterCountOther => 'Остават \$remainingCount знака';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Преместване надолу';

  @override
  String get reorderItemLeft => 'Преместване наляво';

  @override
  String get reorderItemRight => 'Преместване надясно';

  @override
  String get reorderItemToEnd => 'Преместване в края';

  @override
  String get reorderItemToStart => 'Преместване в началото';

  @override
  String get reorderItemUp => 'Преместване нагоре';

  @override
  String get rowsPerPageTitle => 'Редове на страница:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Търсене';

  @override
  String get selectAllButtonLabel => 'ИЗБИРАНЕ НА ВСИЧКО';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Избран е 1 елемент';

  @override
  String get selectedRowCountTitleOther => 'Избрани са \$selectedRowCount елемента';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Показване на профилите';

  @override
  String get showMenuTooltip => 'Показване на менюто';

  @override
  String get signedInLabel => 'В профила си сте';

  @override
  String get tabLabelRaw => 'Раздел \$tabIndex от \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Избиране на часове';

  @override
  String get timePickerMinuteModeAnnouncement => 'Избиране на минути';

  @override
  String get viewLicensesButtonLabel => 'ПРЕГЛЕД НА ЛИЦЕНЗИТЕ';
}

/// The translations for Bengali Bangla (`bn`).
class MaterialLocalizationBn extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Bengali Bangla.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationBn({
    String localeName = 'bn',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName সম্পর্কে';

  @override
  String get alertDialogLabel => 'সতর্কতা';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'ফিরে যান';

  @override
  String get cancelButtonLabel => 'বাতিল করুন';

  @override
  String get closeButtonLabel => 'বন্ধ করুন';

  @override
  String get closeButtonTooltip => 'বন্ধ করুন';

  @override
  String get collapsedIconTapHint => 'বড় করুন';

  @override
  String get continueButtonLabel => 'চালিয়ে যান';

  @override
  String get copyButtonLabel => 'কপি করুন';

  @override
  String get cutButtonLabel => 'কাট করুন';

  @override
  String get deleteButtonTooltip => 'মুছে দিন';

  @override
  String get dialogLabel => 'ডায়ালগ';

  @override
  String get drawerLabel => 'নেভিগেশান মেনু';

  @override
  String get expandedIconTapHint => 'আড়াল করুন';

  @override
  String get hideAccountsLabel => 'অ্যাকাউন্টগুলি লুকান';

  @override
  String get licensesPageTitle => 'লাইসেন্স';

  @override
  String get modalBarrierDismissLabel => 'খারিজ করুন';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'পরের মাস';

  @override
  String get nextPageTooltip => 'পরের পৃষ্ঠা';

  @override
  String get okButtonLabel => 'ঠিক আছে';

  @override
  String get openAppDrawerTooltip => 'নেভিগেশন মেনু খুলুন';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCountটির মধ্যে \$firstRow-\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'প্রায় \$rowCountটির মধ্যে \$firstRow-\$lastRow নম্বর';

  @override
  String get pasteButtonLabel => 'পেস্ট করুন';

  @override
  String get popupMenuLabel => 'পপ-আপ মেনু';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'আগের মাস';

  @override
  String get previousPageTooltip => 'আগের পৃষ্ঠা';

  @override
  String get refreshIndicatorSemanticLabel => 'রিফ্রেশ করুন';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'আর ১টি অক্ষর লেখা যাবে';

  @override
  String get remainingTextFieldCharacterCountOther => 'আর \$remainingCountটি অক্ষর লেখা যাবে';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'নিচের দিকে সরান';

  @override
  String get reorderItemLeft => 'বাঁদিকে সরান';

  @override
  String get reorderItemRight => 'ডানদিকে সরান';

  @override
  String get reorderItemToEnd => 'একদম শেষের দিকে যান';

  @override
  String get reorderItemToStart => 'চালু করতে সরান';

  @override
  String get reorderItemUp => 'উপরের দিকে সরান';

  @override
  String get rowsPerPageTitle => 'প্রতি পৃষ্ঠায় সারির সংখ্যা:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'সার্চ';

  @override
  String get selectAllButtonLabel => 'সব বেছে নিন';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '১টি আইটেম বেছে নেওয়া হয়েছে';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCountটি আইটেম বেছে নেওয়া হয়েছে';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'অ্যাকাউন্টগুলি দেখান';

  @override
  String get showMenuTooltip => 'মেনু দেখান';

  @override
  String get signedInLabel => 'সাইন-ইন করা হয়েছে';

  @override
  String get tabLabelRaw => '\$tabCount-এর মধ্যে \$tabIndexটি ট্যাব';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'ঘণ্টা বেছে নিন';

  @override
  String get timePickerMinuteModeAnnouncement => 'মিনিট বেছে নিন';

  @override
  String get viewLicensesButtonLabel => 'লাইসেন্স দেখুন';
}

/// The translations for Bosnian (`bs`).
class MaterialLocalizationBs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Bosnian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationBs({
    String localeName = 'bs',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'O aplikaciji \$applicationName';

  @override
  String get alertDialogLabel => 'Upozorenje';

  @override
  String get anteMeridiemAbbreviation => 'prijepodne';

  @override
  String get backButtonTooltip => 'Nazad';

  @override
  String get cancelButtonLabel => 'OTKAŽI';

  @override
  String get closeButtonLabel => 'ZATVORI';

  @override
  String get closeButtonTooltip => 'Zatvaranje';

  @override
  String get collapsedIconTapHint => 'Proširi';

  @override
  String get continueButtonLabel => 'NASTAVI';

  @override
  String get copyButtonLabel => 'KOPIRAJ';

  @override
  String get cutButtonLabel => 'IZREŽI';

  @override
  String get deleteButtonTooltip => 'Brisanje';

  @override
  String get dialogLabel => 'Dijaloški okvir';

  @override
  String get drawerLabel => 'Meni za navigaciju';

  @override
  String get expandedIconTapHint => 'Suzi';

  @override
  String get hideAccountsLabel => 'Sakrij račune';

  @override
  String get licensesPageTitle => 'Licence';

  @override
  String get modalBarrierDismissLabel => 'Odbaci';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Sljedeći mjesec';

  @override
  String get nextPageTooltip => 'Sljedeća stranica';

  @override
  String get okButtonLabel => 'Uredu';

  @override
  String get openAppDrawerTooltip => 'Otvorite meni za navigaciju';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow od \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow od oko \$rowCount';

  @override
  String get pasteButtonLabel => 'ZALIJEPI';

  @override
  String get popupMenuLabel => 'Skočni meni';

  @override
  String get postMeridiemAbbreviation => 'poslijepodne';

  @override
  String get previousMonthTooltip => 'Prethodni mjesec';

  @override
  String get previousPageTooltip => 'Prethodna stranica';

  @override
  String get refreshIndicatorSemanticLabel => 'Osvježi';

  @override
  String get remainingTextFieldCharacterCountFew => 'Još \$remainingCount znaka';

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Još jedan znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Još \$remainingCount znakova';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Pomjeri prema dolje';

  @override
  String get reorderItemLeft => 'Pomjeri lijevo';

  @override
  String get reorderItemRight => 'Pomjeri desno';

  @override
  String get reorderItemToEnd => 'Pomjerite na kraj';

  @override
  String get reorderItemToStart => 'Pomjerite na početak';

  @override
  String get reorderItemUp => 'Pomjeri prema gore';

  @override
  String get rowsPerPageTitle => 'Broj redova po stranici:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Pretražite';

  @override
  String get selectAllButtonLabel => 'ODABERI SVE';

  @override
  String get selectedRowCountTitleFew => 'Odabrane su \$selectedRowCount stavke';

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Odabrana je jedna stavka';

  @override
  String get selectedRowCountTitleOther => 'Odabrano je \$selectedRowCount stavki';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Prikaži račune';

  @override
  String get showMenuTooltip => 'Prikaži meni';

  @override
  String get signedInLabel => 'Prijavljeni ste';

  @override
  String get tabLabelRaw => '\$tabIndex. kartica od \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Odaberite sat';

  @override
  String get timePickerMinuteModeAnnouncement => 'Odaberite minute';

  @override
  String get viewLicensesButtonLabel => 'PRIKAŽI LICENCE';
}

/// The translations for Catalan Valencian (`ca`).
class MaterialLocalizationCa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Catalan Valencian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationCa({
    String localeName = 'ca',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Sobre \$applicationName';

  @override
  String get alertDialogLabel => 'Alerta';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Enrere';

  @override
  String get cancelButtonLabel => 'CANCEL·LA';

  @override
  String get closeButtonLabel => 'TANCA';

  @override
  String get closeButtonTooltip => 'Tanca';

  @override
  String get collapsedIconTapHint => 'Desplega';

  @override
  String get continueButtonLabel => 'CONTINUA';

  @override
  String get copyButtonLabel => 'COPIA';

  @override
  String get cutButtonLabel => 'RETALLA';

  @override
  String get deleteButtonTooltip => 'Suprimeix';

  @override
  String get dialogLabel => 'Diàleg';

  @override
  String get drawerLabel => 'Menú de navegació';

  @override
  String get expandedIconTapHint => 'Replega';

  @override
  String get hideAccountsLabel => 'Amaga els comptes';

  @override
  String get licensesPageTitle => 'Llicències';

  @override
  String get modalBarrierDismissLabel => 'Ignora';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Mes següent';

  @override
  String get nextPageTooltip => 'Pàgina següent';

  @override
  String get okButtonLabel => 'D\'ACORD';

  @override
  String get openAppDrawerTooltip => 'Obre el menú de navegació';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow d\'aproximadament \$rowCount';

  @override
  String get pasteButtonLabel => 'ENGANXA';

  @override
  String get popupMenuLabel => 'Menú emergent';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Mes anterior';

  @override
  String get previousPageTooltip => 'Pàgina anterior';

  @override
  String get refreshIndicatorSemanticLabel => 'Actualitza';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 caràcter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Queden \$remainingCount caràcters';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Mou avall';

  @override
  String get reorderItemLeft => 'Mou cap a l\'esquerra';

  @override
  String get reorderItemRight => 'Mou cap a la dreta';

  @override
  String get reorderItemToEnd => 'Mou al final';

  @override
  String get reorderItemToStart => 'Mou al principi';

  @override
  String get reorderItemUp => 'Mou amunt';

  @override
  String get rowsPerPageTitle => 'Files per pàgina:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Cerca';

  @override
  String get selectAllButtonLabel => 'SELECCIONA-HO TOT';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'S\'ha seleccionat 1 element';

  @override
  String get selectedRowCountTitleOther => 'S\'han seleccionat \$selectedRowCount elements';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Mostra els comptes';

  @override
  String get showMenuTooltip => 'Mostra el menú';

  @override
  String get signedInLabel => 'Sessió iniciada';

  @override
  String get tabLabelRaw => 'Pestanya \$tabIndex de \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Selecciona les hores';

  @override
  String get timePickerMinuteModeAnnouncement => 'Selecciona els minuts';

  @override
  String get viewLicensesButtonLabel => 'MOSTRA LES LLICÈNCIES';
}

/// The translations for Czech (`cs`).
class MaterialLocalizationCs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Czech.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationCs({
    String localeName = 'cs',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'O aplikaci \$applicationName';

  @override
  String get alertDialogLabel => 'Upozornění';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Zpět';

  @override
  String get cancelButtonLabel => 'ZRUŠIT';

  @override
  String get closeButtonLabel => 'ZAVŘÍT';

  @override
  String get closeButtonTooltip => 'Zavřít';

  @override
  String get collapsedIconTapHint => 'Rozbalit';

  @override
  String get continueButtonLabel => 'POKRAČOVAT';

  @override
  String get copyButtonLabel => 'KOPÍROVAT';

  @override
  String get cutButtonLabel => 'VYJMOUT';

  @override
  String get deleteButtonTooltip => 'Smazat';

  @override
  String get dialogLabel => 'Dialogové okno';

  @override
  String get drawerLabel => 'Navigační nabídka';

  @override
  String get expandedIconTapHint => 'Sbalit';

  @override
  String get hideAccountsLabel => 'Skrýt účty';

  @override
  String get licensesPageTitle => 'Licence';

  @override
  String get modalBarrierDismissLabel => 'Zavřít';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Další měsíc';

  @override
  String get nextPageTooltip => 'Další stránka';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Otevřít navigační nabídku';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow z \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow z asi \$rowCount';

  @override
  String get pasteButtonLabel => 'VLOŽIT';

  @override
  String get popupMenuLabel => 'Vyskakovací nabídka';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Předchozí měsíc';

  @override
  String get previousPageTooltip => 'Předchozí stránka';

  @override
  String get refreshIndicatorSemanticLabel => 'Obnovit';

  @override
  String get remainingTextFieldCharacterCountFew => 'Zbývají \$remainingCount znaky';

  @override
  String get remainingTextFieldCharacterCountMany => 'Zbývá \$remainingCount znaku';

  @override
  String get remainingTextFieldCharacterCountOne => 'Zbývá 1 znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Zbývá \$remainingCount znaků';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Přesunout dolů';

  @override
  String get reorderItemLeft => 'Přesunout doleva';

  @override
  String get reorderItemRight => 'Přesunout doprava';

  @override
  String get reorderItemToEnd => 'Přesunout na konec';

  @override
  String get reorderItemToStart => 'Přesunout na začátek';

  @override
  String get reorderItemUp => 'Přesunout nahoru';

  @override
  String get rowsPerPageTitle => 'Počet řádků na stránku:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Hledat';

  @override
  String get selectAllButtonLabel => 'VYBRAT VŠE';

  @override
  String get selectedRowCountTitleFew => 'Jsou vybrány \$selectedRowCount položky';

  @override
  String get selectedRowCountTitleMany => 'Je vybráno \$selectedRowCount položky';

  @override
  String get selectedRowCountTitleOne => 'Je vybrána 1 položka';

  @override
  String get selectedRowCountTitleOther => 'Je vybráno \$selectedRowCount položek';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Zobrazit účty';

  @override
  String get showMenuTooltip => 'Zobrazit nabídku';

  @override
  String get signedInLabel => 'Uživatel přihlášen';

  @override
  String get tabLabelRaw => 'Karta \$tabIndex z \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Vyberte hodiny';

  @override
  String get timePickerMinuteModeAnnouncement => 'Vyberte minuty';

  @override
  String get viewLicensesButtonLabel => 'ZOBRAZIT LICENCE';
}

/// The translations for Danish (`da`).
class MaterialLocalizationDa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Danish.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationDa({
    String localeName = 'da',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Om \$applicationName';

  @override
  String get alertDialogLabel => 'Underretning';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Tilbage';

  @override
  String get cancelButtonLabel => 'ANNULLER';

  @override
  String get closeButtonLabel => 'LUK';

  @override
  String get closeButtonTooltip => 'Luk';

  @override
  String get collapsedIconTapHint => 'Udvid';

  @override
  String get continueButtonLabel => 'FORTSÆT';

  @override
  String get copyButtonLabel => 'KOPIÉR';

  @override
  String get cutButtonLabel => 'KLIP';

  @override
  String get deleteButtonTooltip => 'Slet';

  @override
  String get dialogLabel => 'Dialogboks';

  @override
  String get drawerLabel => 'Navigationsmenu';

  @override
  String get expandedIconTapHint => 'Skjul';

  @override
  String get hideAccountsLabel => 'Skjul konti';

  @override
  String get licensesPageTitle => 'Licenser';

  @override
  String get modalBarrierDismissLabel => 'Afvis';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Næste måned';

  @override
  String get nextPageTooltip => 'Næste side';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Åbn navigationsmenuen';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow af \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow af ca. \$rowCount';

  @override
  String get pasteButtonLabel => 'SÆT IND';

  @override
  String get popupMenuLabel => 'Pop op-menu';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Forrige måned';

  @override
  String get previousPageTooltip => 'Forrige side';

  @override
  String get refreshIndicatorSemanticLabel => 'Opdater';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Ét tegn tilbage';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount tegn tilbage';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Flyt ned';

  @override
  String get reorderItemLeft => 'Flyt til venstre';

  @override
  String get reorderItemRight => 'Flyt til højre';

  @override
  String get reorderItemToEnd => 'Flyt til sidst på listen';

  @override
  String get reorderItemToStart => 'Flyt til først på listen';

  @override
  String get reorderItemUp => 'Flyt op';

  @override
  String get rowsPerPageTitle => 'Rækker pr. side:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Søg';

  @override
  String get selectAllButtonLabel => 'VÆLG ALLE';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 element er valgt';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount elementer er valgt';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Vis konti';

  @override
  String get showMenuTooltip => 'Vis menu';

  @override
  String get signedInLabel => 'Logget ind';

  @override
  String get tabLabelRaw => 'Fane \$tabIndex af \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Vælg timer';

  @override
  String get timePickerMinuteModeAnnouncement => 'Vælg minutter';

  @override
  String get viewLicensesButtonLabel => 'SE LICENSER';
}

/// The translations for German (`de`).
class MaterialLocalizationDe extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for German.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationDe({
    String localeName = 'de',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Über \$applicationName';

  @override
  String get alertDialogLabel => 'Benachrichtigung';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Zurück';

  @override
  String get cancelButtonLabel => 'ABBRECHEN';

  @override
  String get closeButtonLabel => 'SCHLIEẞEN';

  @override
  String get closeButtonTooltip => 'Schließen';

  @override
  String get collapsedIconTapHint => 'Maximieren';

  @override
  String get continueButtonLabel => 'WEITER';

  @override
  String get copyButtonLabel => 'KOPIEREN';

  @override
  String get cutButtonLabel => 'AUSSCHNEIDEN';

  @override
  String get deleteButtonTooltip => 'Löschen';

  @override
  String get dialogLabel => 'Dialogfeld';

  @override
  String get drawerLabel => 'Navigationsmenü';

  @override
  String get expandedIconTapHint => 'Minimieren';

  @override
  String get hideAccountsLabel => 'Konten ausblenden';

  @override
  String get licensesPageTitle => 'Lizenzen';

  @override
  String get modalBarrierDismissLabel => 'Schließen';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Nächster Monat';

  @override
  String get nextPageTooltip => 'Nächste Seite';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Navigationsmenü öffnen';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow von \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow von etwa \$rowCount';

  @override
  String get pasteButtonLabel => 'EINFÜGEN';

  @override
  String get popupMenuLabel => 'Pop-up-Menü';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Vorheriger Monat';

  @override
  String get previousPageTooltip => 'Vorherige Seite';

  @override
  String get refreshIndicatorSemanticLabel => 'Aktualisieren';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Noch 1 Zeichen';

  @override
  String get remainingTextFieldCharacterCountOther => 'Noch \$remainingCount Zeichen';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Nach unten verschieben';

  @override
  String get reorderItemLeft => 'Nach links verschieben';

  @override
  String get reorderItemRight => 'Nach rechts verschieben';

  @override
  String get reorderItemToEnd => 'An das Ende verschieben';

  @override
  String get reorderItemToStart => 'An den Anfang verschieben';

  @override
  String get reorderItemUp => 'Nach oben verschieben';

  @override
  String get rowsPerPageTitle => 'Zeilen pro Seite:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Suchen';

  @override
  String get selectAllButtonLabel => 'ALLE AUSWÄHLEN';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 Element ausgewählt';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount Elemente ausgewählt';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Keine Objekte ausgewählt';

  @override
  String get showAccountsLabel => 'Konten anzeigen';

  @override
  String get showMenuTooltip => 'Menü anzeigen';

  @override
  String get signedInLabel => 'Angemeldet';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex von \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Stunden auswählen';

  @override
  String get timePickerMinuteModeAnnouncement => 'Minuten auswählen';

  @override
  String get viewLicensesButtonLabel => 'LIZENZEN ANZEIGEN';
}

/// The translations for German, as used in Switzerland (`de_CH`).
class MaterialLocalizationDeCh extends MaterialLocalizationDe {
  /// Create an instance of the translation bundle for German, as used in Switzerland.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationDeCh({
    String localeName = 'de_CH',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get closeButtonTooltip => 'Schliessen';

  @override
  String get modalBarrierDismissLabel => 'Schliessen';
}

/// The translations for Modern Greek (`el`).
class MaterialLocalizationEl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Modern Greek.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEl({
    String localeName = 'el',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Σχετικά με την εφαρμογή \$applicationName';

  @override
  String get alertDialogLabel => 'Ειδοποίηση';

  @override
  String get anteMeridiemAbbreviation => 'π.μ.';

  @override
  String get backButtonTooltip => 'Πίσω';

  @override
  String get cancelButtonLabel => 'ΑΚΥΡΩΣΗ';

  @override
  String get closeButtonLabel => 'ΚΛΕΙΣΙΜΟ';

  @override
  String get closeButtonTooltip => 'Κλείσιμο';

  @override
  String get collapsedIconTapHint => 'Ανάπτυξη';

  @override
  String get continueButtonLabel => 'ΣΥΝΕΧΕΙΑ';

  @override
  String get copyButtonLabel => 'ΑΝΤΙΓΡΑΦΗ';

  @override
  String get cutButtonLabel => 'ΑΠΟΚΟΠΗ';

  @override
  String get deleteButtonTooltip => 'Διαγραφή';

  @override
  String get dialogLabel => 'Παράθυρο διαλόγου';

  @override
  String get drawerLabel => 'Μενού πλοήγησης';

  @override
  String get expandedIconTapHint => 'Σύμπτυξη';

  @override
  String get hideAccountsLabel => 'Απόκρυψη λογαριασμών';

  @override
  String get licensesPageTitle => 'Άδειες';

  @override
  String get modalBarrierDismissLabel => 'Παράβλεψη';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Επόμενος μήνας';

  @override
  String get nextPageTooltip => 'Επόμενη σελίδα';

  @override
  String get okButtonLabel => 'ΟΚ';

  @override
  String get openAppDrawerTooltip => 'Άνοιγμα μενού πλοήγησης';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow από \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow από περίπου \$rowCount';

  @override
  String get pasteButtonLabel => 'ΕΠΙΚΟΛΛΗΣΗ';

  @override
  String get popupMenuLabel => 'Αναδυόμενο μενού';

  @override
  String get postMeridiemAbbreviation => 'μ.μ.';

  @override
  String get previousMonthTooltip => 'Προηγούμενος μήνας';

  @override
  String get previousPageTooltip => 'Προηγούμενη σελίδα';

  @override
  String get refreshIndicatorSemanticLabel => 'Ανανέωση';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'απομένει 1 χαρακτήρας';

  @override
  String get remainingTextFieldCharacterCountOther => 'απομένουν \$remainingCount χαρακτήρες';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Μετακίνηση προς τα κάτω';

  @override
  String get reorderItemLeft => 'Μετακίνηση αριστερά';

  @override
  String get reorderItemRight => 'Μετακίνηση δεξιά';

  @override
  String get reorderItemToEnd => 'Μετακίνηση στο τέλος';

  @override
  String get reorderItemToStart => 'Μετακίνηση στην αρχή';

  @override
  String get reorderItemUp => 'Μετακίνηση προς τα πάνω';

  @override
  String get rowsPerPageTitle => 'Σειρές ανά σελίδα:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Αναζήτηση';

  @override
  String get selectAllButtonLabel => 'ΕΠΙΛΟΓΗ ΟΛΩΝ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Επιλέχθηκε 1 στοιχείο';

  @override
  String get selectedRowCountTitleOther => 'Επιλέχθηκαν \$selectedRowCount στοιχεία';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Εμφάνιση λογαριασμών';

  @override
  String get showMenuTooltip => 'Εμφάνιση μενού';

  @override
  String get signedInLabel => 'Σε σύνδεση';

  @override
  String get tabLabelRaw => 'Καρτέλα \$tabIndex από \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Επιλογή ωρών';

  @override
  String get timePickerMinuteModeAnnouncement => 'Επιλογή λεπτών';

  @override
  String get viewLicensesButtonLabel => 'ΠΡΟΒΟΛΗ ΑΔΕΙΩΝ';
}

/// The translations for English (`en`).
class MaterialLocalizationEn extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for English.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEn({
    String localeName = 'en',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'About \$applicationName';

  @override
  String get alertDialogLabel => 'Alert';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Back';

  @override
  String get cancelButtonLabel => 'CANCEL';

  @override
  String get closeButtonLabel => 'CLOSE';

  @override
  String get closeButtonTooltip => 'Close';

  @override
  String get collapsedIconTapHint => 'Expand';

  @override
  String get continueButtonLabel => 'CONTINUE';

  @override
  String get copyButtonLabel => 'COPY';

  @override
  String get cutButtonLabel => 'CUT';

  @override
  String get deleteButtonTooltip => 'Delete';

  @override
  String get dialogLabel => 'Dialog';

  @override
  String get drawerLabel => 'Navigation menu';

  @override
  String get expandedIconTapHint => 'Collapse';

  @override
  String get hideAccountsLabel => 'Hide accounts';

  @override
  String get licensesPageTitle => 'Licenses';

  @override
  String get modalBarrierDismissLabel => 'Dismiss';

  @override
  String get moreButtonTooltip => 'More';

  @override
  String get nextMonthTooltip => 'Next month';

  @override
  String get nextPageTooltip => 'Next page';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Open navigation menu';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow of \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow of about \$rowCount';

  @override
  String get pasteButtonLabel => 'PASTE';

  @override
  String get popupMenuLabel => 'Popup menu';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Previous month';

  @override
  String get previousPageTooltip => 'Previous page';

  @override
  String get refreshIndicatorSemanticLabel => 'Refresh';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 character remaining';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount characters remaining';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'No characters remaining';

  @override
  String get reorderItemDown => 'Move down';

  @override
  String get reorderItemLeft => 'Move left';

  @override
  String get reorderItemRight => 'Move right';

  @override
  String get reorderItemToEnd => 'Move to the end';

  @override
  String get reorderItemToStart => 'Move to the start';

  @override
  String get reorderItemUp => 'Move up';

  @override
  String get rowsPerPageTitle => 'Rows per page:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Search';

  @override
  String get selectAllButtonLabel => 'SELECT ALL';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item selected';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount items selected';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'No items selected';

  @override
  String get showAccountsLabel => 'Show accounts';

  @override
  String get showMenuTooltip => 'Show menu';

  @override
  String get signedInLabel => 'Signed in';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex of \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'Select hours';

  @override
  String get timePickerMinuteModeAnnouncement => 'Select minutes';

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENSES';
}

/// The translations for English, as used in Australia (`en_AU`).
class MaterialLocalizationEnAu extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in Australia.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnAu({
    String localeName = 'en_AU',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in Canada (`en_CA`).
class MaterialLocalizationEnCa extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in Canada.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnCa({
    String localeName = 'en_CA',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in the United Kingdom (`en_GB`).
class MaterialLocalizationEnGb extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in the United Kingdom.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnGb({
    String localeName = 'en_GB',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in Ireland (`en_IE`).
class MaterialLocalizationEnIe extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in Ireland.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnIe({
    String localeName = 'en_IE',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in India (`en_IN`).
class MaterialLocalizationEnIn extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in India.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnIn({
    String localeName = 'en_IN',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in New Zealand (`en_NZ`).
class MaterialLocalizationEnNz extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in New Zealand.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnNz({
    String localeName = 'en_NZ',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in Singapore (`en_SG`).
class MaterialLocalizationEnSg extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in Singapore.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnSg({
    String localeName = 'en_SG',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for English, as used in South Africa (`en_ZA`).
class MaterialLocalizationEnZa extends MaterialLocalizationEn {
  /// Create an instance of the translation bundle for English, as used in South Africa.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEnZa({
    String localeName = 'en_ZA',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get viewLicensesButtonLabel => 'VIEW LICENCES';

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get popupMenuLabel => 'Pop-up menu';

  @override
  String get dialogLabel => 'Dialogue';

  @override
  String get reorderItemLeft => 'Move to the left';

  @override
  String get reorderItemRight => 'Move to the right';
}

/// The translations for Spanish Castilian (`es`).
class MaterialLocalizationEs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Spanish Castilian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEs({
    String localeName = 'es',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Sobre \$applicationName';

  @override
  String get alertDialogLabel => 'Alerta';

  @override
  String get anteMeridiemAbbreviation => 'A.M.';

  @override
  String get backButtonTooltip => 'Atrás';

  @override
  String get cancelButtonLabel => 'CANCELAR';

  @override
  String get closeButtonLabel => 'CERRAR';

  @override
  String get closeButtonTooltip => 'Cerrar';

  @override
  String get collapsedIconTapHint => 'Mostrar';

  @override
  String get continueButtonLabel => 'CONTINUAR';

  @override
  String get copyButtonLabel => 'COPIAR';

  @override
  String get cutButtonLabel => 'CORTAR';

  @override
  String get deleteButtonTooltip => 'Eliminar';

  @override
  String get dialogLabel => 'Cuadro de diálogo';

  @override
  String get drawerLabel => 'Menú de navegación';

  @override
  String get expandedIconTapHint => 'Ocultar';

  @override
  String get hideAccountsLabel => 'Ocultar cuentas';

  @override
  String get licensesPageTitle => 'Licencias';

  @override
  String get modalBarrierDismissLabel => 'Cerrar';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Mes siguiente';

  @override
  String get nextPageTooltip => 'Página siguiente';

  @override
  String get okButtonLabel => 'ACEPTAR';

  @override
  String get openAppDrawerTooltip => 'Abrir el menú de navegación';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow‑\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow‑\$lastRow de aproximadamente \$rowCount';

  @override
  String get pasteButtonLabel => 'PEGAR';

  @override
  String get popupMenuLabel => 'Menú emergente';

  @override
  String get postMeridiemAbbreviation => 'P.M.';

  @override
  String get previousMonthTooltip => 'Mes anterior';

  @override
  String get previousPageTooltip => 'Página anterior';

  @override
  String get refreshIndicatorSemanticLabel => 'Actualizar';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter.';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Mover hacia abajo';

  @override
  String get reorderItemLeft => 'Mover hacia la izquierda';

  @override
  String get reorderItemRight => 'Mover hacia la derecha';

  @override
  String get reorderItemToEnd => 'Mover al final';

  @override
  String get reorderItemToStart => 'Mover al principio';

  @override
  String get reorderItemUp => 'Mover hacia arriba';

  @override
  String get rowsPerPageTitle => 'Filas por página:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Buscar';

  @override
  String get selectAllButtonLabel => 'SELECCIONAR TODO';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 elemento seleccionado';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount elementos seleccionados';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'No se han seleccionado elementos';

  @override
  String get showAccountsLabel => 'Mostrar cuentas';

  @override
  String get showMenuTooltip => 'Mostrar menú';

  @override
  String get signedInLabel => 'Sesión iniciada';

  @override
  String get tabLabelRaw => 'Pestaña \$tabIndex de \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Seleccionar horas';

  @override
  String get timePickerMinuteModeAnnouncement => 'Seleccionar minutos';

  @override
  String get viewLicensesButtonLabel => 'VER LICENCIAS';
}

/// The translations for Spanish Castilian, as used in Latin America and the Caribbean (`es_419`).
class MaterialLocalizationEs419 extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Latin America and the Caribbean.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEs419({
    String localeName = 'es_419',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Argentina (`es_AR`).
class MaterialLocalizationEsAr extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Argentina.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsAr({
    String localeName = 'es_AR',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Bolivia (`es_BO`).
class MaterialLocalizationEsBo extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Bolivia.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsBo({
    String localeName = 'es_BO',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Chile (`es_CL`).
class MaterialLocalizationEsCl extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Chile.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsCl({
    String localeName = 'es_CL',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Colombia (`es_CO`).
class MaterialLocalizationEsCo extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Colombia.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsCo({
    String localeName = 'es_CO',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Costa Rica (`es_CR`).
class MaterialLocalizationEsCr extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Costa Rica.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsCr({
    String localeName = 'es_CR',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in the Dominican Republic (`es_DO`).
class MaterialLocalizationEsDo extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in the Dominican Republic.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsDo({
    String localeName = 'es_DO',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Ecuador (`es_EC`).
class MaterialLocalizationEsEc extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Ecuador.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsEc({
    String localeName = 'es_EC',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Guatemala (`es_GT`).
class MaterialLocalizationEsGt extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Guatemala.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsGt({
    String localeName = 'es_GT',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Honduras (`es_HN`).
class MaterialLocalizationEsHn extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Honduras.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsHn({
    String localeName = 'es_HN',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Mexico (`es_MX`).
class MaterialLocalizationEsMx extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Mexico.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsMx({
    String localeName = 'es_MX',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Nicaragua (`es_NI`).
class MaterialLocalizationEsNi extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Nicaragua.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsNi({
    String localeName = 'es_NI',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Panama (`es_PA`).
class MaterialLocalizationEsPa extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Panama.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsPa({
    String localeName = 'es_PA',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Peru (`es_PE`).
class MaterialLocalizationEsPe extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Peru.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsPe({
    String localeName = 'es_PE',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Puerto Rico (`es_PR`).
class MaterialLocalizationEsPr extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Puerto Rico.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsPr({
    String localeName = 'es_PR',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Paraguay (`es_PY`).
class MaterialLocalizationEsPy extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Paraguay.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsPy({
    String localeName = 'es_PY',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in El Salvador (`es_SV`).
class MaterialLocalizationEsSv extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in El Salvador.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsSv({
    String localeName = 'es_SV',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in the United States (`es_US`).
class MaterialLocalizationEsUs extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in the United States.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsUs({
    String localeName = 'es_US',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Uruguay (`es_UY`).
class MaterialLocalizationEsUy extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Uruguay.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsUy({
    String localeName = 'es_UY',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Spanish Castilian, as used in Venezuela (`es_VE`).
class MaterialLocalizationEsVe extends MaterialLocalizationEs {
  /// Create an instance of the translation bundle for Spanish Castilian, as used in Venezuela.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEsVe({
    String localeName = 'es_VE',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get reorderItemToStart => 'Mover al inicio';

  @override
  String get modalBarrierDismissLabel => 'Descartar';

  @override
  String get signedInLabel => 'Cuenta con la que accediste';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get deleteButtonTooltip => 'Borrar';

  @override
  String get nextMonthTooltip => 'Próximo mes';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow de aproximadamente \$rowCount';

  @override
  String get selectedRowCountTitleOne => 'Se seleccionó 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Se seleccionaron \$selectedRowCount elementos';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get dialogLabel => 'Diálogo';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Queda 1 carácter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Quedan \$remainingCount caracteres';
}

/// The translations for Estonian (`et`).
class MaterialLocalizationEt extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Estonian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEt({
    String localeName = 'et',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Teave rakenduse \$applicationName kohta';

  @override
  String get alertDialogLabel => 'Märguanne';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Tagasi';

  @override
  String get cancelButtonLabel => 'TÜHISTA';

  @override
  String get closeButtonLabel => 'SULE';

  @override
  String get closeButtonTooltip => 'Sule';

  @override
  String get collapsedIconTapHint => 'Laienda';

  @override
  String get continueButtonLabel => 'JÄTKA';

  @override
  String get copyButtonLabel => 'KOPEERI';

  @override
  String get cutButtonLabel => 'LÕIKA';

  @override
  String get deleteButtonTooltip => 'Kustuta';

  @override
  String get dialogLabel => 'Dialoog';

  @override
  String get drawerLabel => 'Navigeerimismenüü';

  @override
  String get expandedIconTapHint => 'Ahenda';

  @override
  String get hideAccountsLabel => 'Peida kontod';

  @override
  String get licensesPageTitle => 'Litsentsid';

  @override
  String get modalBarrierDismissLabel => 'Loobu';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Järgmine kuu';

  @override
  String get nextPageTooltip => 'Järgmine leht';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Ava navigeerimismenüü';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow \$rowCount-st';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow umbes \$rowCount-st';

  @override
  String get pasteButtonLabel => 'KLEEBI';

  @override
  String get popupMenuLabel => 'Hüpikmenüü';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Eelmine kuu';

  @override
  String get previousPageTooltip => 'Eelmine leht';

  @override
  String get refreshIndicatorSemanticLabel => 'Värskendamine';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Jäänud on 1 tähemärk';

  @override
  String get remainingTextFieldCharacterCountOther => 'Jäänud on \$remainingCount tähemärki';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Teisalda alla';

  @override
  String get reorderItemLeft => 'Teisalda vasakule';

  @override
  String get reorderItemRight => 'Teisalda paremale';

  @override
  String get reorderItemToEnd => 'Teisalda lõppu';

  @override
  String get reorderItemToStart => 'Teisalda algusesse';

  @override
  String get reorderItemUp => 'Teisalda üles';

  @override
  String get rowsPerPageTitle => 'Ridu lehe kohta:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Otsing';

  @override
  String get selectAllButtonLabel => 'VALI KÕIK';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Valitud on 1 üksus';

  @override
  String get selectedRowCountTitleOther => 'Valitud on \$selectedRowCount üksust';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Kuva kontod';

  @override
  String get showMenuTooltip => 'Kuva menüü';

  @override
  String get signedInLabel => 'Sisse logitud';

  @override
  String get tabLabelRaw => '\$tabIndex. vahekaart \$tabCount-st';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Tundide valimine';

  @override
  String get timePickerMinuteModeAnnouncement => 'Minutite valimine';

  @override
  String get viewLicensesButtonLabel => 'KUVA LITSENTSID';
}

/// The translations for Basque (`eu`).
class MaterialLocalizationEu extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Basque.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationEu({
    String localeName = 'eu',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName aplikazioari buruz';

  @override
  String get alertDialogLabel => 'Alerta';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Atzera';

  @override
  String get cancelButtonLabel => 'UTZI';

  @override
  String get closeButtonLabel => 'ITXI';

  @override
  String get closeButtonTooltip => 'Itxi';

  @override
  String get collapsedIconTapHint => 'Zabaldu';

  @override
  String get continueButtonLabel => 'EGIN AURRERA';

  @override
  String get copyButtonLabel => 'KOPIATU';

  @override
  String get cutButtonLabel => 'EBAKI';

  @override
  String get deleteButtonTooltip => 'Ezabatu';

  @override
  String get dialogLabel => 'Leihoa';

  @override
  String get drawerLabel => 'Nabigazio-menua';

  @override
  String get expandedIconTapHint => 'Tolestu';

  @override
  String get hideAccountsLabel => 'Ezkutatu kontuak';

  @override
  String get licensesPageTitle => 'Lizentziak';

  @override
  String get modalBarrierDismissLabel => 'Baztertu';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Hurrengo hilabetea';

  @override
  String get nextPageTooltip => 'Hurrengo orria';

  @override
  String get okButtonLabel => 'Ados';

  @override
  String get openAppDrawerTooltip => 'Ireki nabigazio-menua';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow - \$lastRow / \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow - \$lastRow / \$rowCount';

  @override
  String get pasteButtonLabel => 'ITSATSI';

  @override
  String get popupMenuLabel => 'Menu gainerakorra';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Aurreko hilabetea';

  @override
  String get previousPageTooltip => 'Aurreko orria';

  @override
  String get refreshIndicatorSemanticLabel => 'Freskatu';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 karaktere geratzen da';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount karaktere geratzen dira';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Eraman behera';

  @override
  String get reorderItemLeft => 'Eraman ezkerrera';

  @override
  String get reorderItemRight => 'Eraman eskuinera';

  @override
  String get reorderItemToEnd => 'Eraman amaierara';

  @override
  String get reorderItemToStart => 'Eraman hasierara';

  @override
  String get reorderItemUp => 'Eraman gora';

  @override
  String get rowsPerPageTitle => 'Errenkadak orriko:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Bilatu';

  @override
  String get selectAllButtonLabel => 'HAUTATU GUZTIAK';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 elementu hautatu da';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount elementu hautatu dira';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Erakutsi kontuak';

  @override
  String get showMenuTooltip => 'Erakutsi menua';

  @override
  String get signedInLabel => 'Hasi da saioa';

  @override
  String get tabLabelRaw => '\$tabIndex/\$tabCount fitxa';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Hautatu orduak';

  @override
  String get timePickerMinuteModeAnnouncement => 'Hautatu minutuak';

  @override
  String get viewLicensesButtonLabel => 'IKUSI LIZENTZIAK';
}

/// The translations for Persian (`fa`).
class MaterialLocalizationFa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Persian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationFa({
    String localeName = 'fa',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'درباره \$applicationName';

  @override
  String get alertDialogLabel => 'هشدار';

  @override
  String get anteMeridiemAbbreviation => 'ق.ظ.';

  @override
  String get backButtonTooltip => 'برگشت';

  @override
  String get cancelButtonLabel => 'لغو';

  @override
  String get closeButtonLabel => 'بستن';

  @override
  String get closeButtonTooltip => 'بستن';

  @override
  String get collapsedIconTapHint => 'بزرگ کردن';

  @override
  String get continueButtonLabel => 'ادامه';

  @override
  String get copyButtonLabel => 'کپی';

  @override
  String get cutButtonLabel => 'برش';

  @override
  String get deleteButtonTooltip => 'حذف';

  @override
  String get dialogLabel => 'کادر گفتگو';

  @override
  String get drawerLabel => 'منوی پیمایش';

  @override
  String get expandedIconTapHint => 'کوچک کردن';

  @override
  String get hideAccountsLabel => 'پنهان کردن حساب‌ها';

  @override
  String get licensesPageTitle => 'مجوزها';

  @override
  String get modalBarrierDismissLabel => 'نپذیرفتن';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ماه بعد';

  @override
  String get nextPageTooltip => 'صفحه بعد';

  @override
  String get okButtonLabel => 'تأیید';

  @override
  String get openAppDrawerTooltip => 'باز کردن منوی پیمایش';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow از \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow از حدود \$rowCount';

  @override
  String get pasteButtonLabel => 'جای‌گذاری';

  @override
  String get popupMenuLabel => 'منوی بازشو';

  @override
  String get postMeridiemAbbreviation => 'ب.ظ.';

  @override
  String get previousMonthTooltip => 'ماه قبل';

  @override
  String get previousPageTooltip => 'صفحه قبل';

  @override
  String get refreshIndicatorSemanticLabel => 'بازخوانی';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '۱ نویسه باقی مانده است';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount نویسه باقی مانده است';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'انتقال به پایین';

  @override
  String get reorderItemLeft => 'انتقال به راست';

  @override
  String get reorderItemRight => 'انتقال به چپ';

  @override
  String get reorderItemToEnd => 'انتقال به انتها';

  @override
  String get reorderItemToStart => 'انتقال به ابتدا';

  @override
  String get reorderItemUp => 'انتقال به بالا';

  @override
  String get rowsPerPageTitle => 'ردیف در هر صفحه:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'جستجو';

  @override
  String get selectAllButtonLabel => 'انتخاب همه';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '۱ مورد انتخاب شد';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount مورد انتخاب شدند';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'نشان دادن حساب‌ها';

  @override
  String get showMenuTooltip => 'نمایش منو';

  @override
  String get signedInLabel => 'واردشده به سیستم';

  @override
  String get tabLabelRaw => 'برگه \$tabIndex از \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'انتخاب ساعت';

  @override
  String get timePickerMinuteModeAnnouncement => 'انتخاب دقیقه';

  @override
  String get viewLicensesButtonLabel => 'مشاهده مجوزها';
}

/// The translations for Finnish (`fi`).
class MaterialLocalizationFi extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Finnish.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationFi({
    String localeName = 'fi',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Tietoja: \$applicationName';

  @override
  String get alertDialogLabel => 'Ilmoitus';

  @override
  String get anteMeridiemAbbreviation => 'ap';

  @override
  String get backButtonTooltip => 'Takaisin';

  @override
  String get cancelButtonLabel => 'PERUUTA';

  @override
  String get closeButtonLabel => 'SULJE';

  @override
  String get closeButtonTooltip => 'Sulje';

  @override
  String get collapsedIconTapHint => 'Laajenna';

  @override
  String get continueButtonLabel => 'JATKA';

  @override
  String get copyButtonLabel => 'COPY';

  @override
  String get cutButtonLabel => 'LEIKKAA';

  @override
  String get deleteButtonTooltip => 'Poista';

  @override
  String get dialogLabel => 'Valintaikkuna';

  @override
  String get drawerLabel => 'Navigointivalikko';

  @override
  String get expandedIconTapHint => 'Tiivistä';

  @override
  String get hideAccountsLabel => 'Piilota tilit';

  @override
  String get licensesPageTitle => 'Lisenssit';

  @override
  String get modalBarrierDismissLabel => 'Ohita';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Seuraava kuukausi';

  @override
  String get nextPageTooltip => 'Seuraava sivu';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Avaa navigointivalikko';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow/\$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow/~\$rowCount';

  @override
  String get pasteButtonLabel => 'Sijoita';

  @override
  String get popupMenuLabel => 'Ponnahdusvalikko';

  @override
  String get postMeridiemAbbreviation => 'ip';

  @override
  String get previousMonthTooltip => 'Edellinen kuukausi';

  @override
  String get previousPageTooltip => 'Edellinen sivu';

  @override
  String get refreshIndicatorSemanticLabel => 'Päivitys';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 merkki jäljellä';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount merkkiä jäljellä';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Siirrä alas';

  @override
  String get reorderItemLeft => 'Siirrä vasemmalle';

  @override
  String get reorderItemRight => 'Siirrä oikealle';

  @override
  String get reorderItemToEnd => 'Siirrä loppuun';

  @override
  String get reorderItemToStart => 'Siirrä alkuun';

  @override
  String get reorderItemUp => 'Siirrä ylös';

  @override
  String get rowsPerPageTitle => 'Riviä/sivu:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Haku';

  @override
  String get selectAllButtonLabel => 'VALITSE KAIKKI';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 kohde valittu';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount kohdetta valittu';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Näytä tilit';

  @override
  String get showMenuTooltip => 'Näytä valikko';

  @override
  String get signedInLabel => 'Kirjautunut sisään';

  @override
  String get tabLabelRaw => 'Välilehti \$tabIndex/\$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Valitse tunnit';

  @override
  String get timePickerMinuteModeAnnouncement => 'Valitse minuutit';

  @override
  String get viewLicensesButtonLabel => 'NÄYTÄ KÄYTTÖOIKEUDET';
}

/// The translations for Filipino Pilipino (`fil`).
class MaterialLocalizationFil extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Filipino Pilipino.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationFil({
    String localeName = 'fil',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Tungkol sa \$applicationName';

  @override
  String get alertDialogLabel => 'Alerto';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Bumalik';

  @override
  String get cancelButtonLabel => 'KANSELAHIN';

  @override
  String get closeButtonLabel => 'ISARA';

  @override
  String get closeButtonTooltip => 'Isara';

  @override
  String get collapsedIconTapHint => 'I-expand';

  @override
  String get continueButtonLabel => 'MAGPATULOY';

  @override
  String get copyButtonLabel => 'KOPYAHIN';

  @override
  String get cutButtonLabel => 'I-CUT';

  @override
  String get deleteButtonTooltip => 'I-delete';

  @override
  String get dialogLabel => 'Dialog';

  @override
  String get drawerLabel => 'Menu ng navigation';

  @override
  String get expandedIconTapHint => 'I-collapse';

  @override
  String get hideAccountsLabel => 'Itago ang mga account';

  @override
  String get licensesPageTitle => 'Mga Lisensya';

  @override
  String get modalBarrierDismissLabel => 'I-dismiss';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Susunod na buwan';

  @override
  String get nextPageTooltip => 'Susunod na page';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Buksan ang menu ng navigation';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow ng \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow ng humigit kumulang \$rowCount';

  @override
  String get pasteButtonLabel => 'I-PASTE';

  @override
  String get popupMenuLabel => 'Popup na menu';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Nakaraang buwan';

  @override
  String get previousPageTooltip => 'Nakaraang page';

  @override
  String get refreshIndicatorSemanticLabel => 'Nagre-refresh';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 character ang natitira';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount na character ang natitira';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Ilipat pababa';

  @override
  String get reorderItemLeft => 'Ilipat pakaliwa';

  @override
  String get reorderItemRight => 'Ilipat pakanan';

  @override
  String get reorderItemToEnd => 'Ilipat sa dulo';

  @override
  String get reorderItemToStart => 'Ilipat sa simula';

  @override
  String get reorderItemUp => 'Ilipat pataas';

  @override
  String get rowsPerPageTitle => 'Mga row bawat page:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Maghanap';

  @override
  String get selectAllButtonLabel => 'PILIIN LAHAT';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item ang napili';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount na item ang napili';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Ipakita ang mga account';

  @override
  String get showMenuTooltip => 'Ipakita ang menu';

  @override
  String get signedInLabel => 'Naka-sign in';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex ng \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Pumili ng mga oras';

  @override
  String get timePickerMinuteModeAnnouncement => 'Pumili ng mga minuto';

  @override
  String get viewLicensesButtonLabel => 'TINGNAN ANG MGA LISENSYA';
}

/// The translations for French (`fr`).
class MaterialLocalizationFr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for French.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationFr({
    String localeName = 'fr',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'À propos de \$applicationName';

  @override
  String get alertDialogLabel => 'Alerte';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Retour';

  @override
  String get cancelButtonLabel => 'ANNULER';

  @override
  String get closeButtonLabel => 'FERMER';

  @override
  String get closeButtonTooltip => 'Fermer';

  @override
  String get collapsedIconTapHint => 'Développer';

  @override
  String get continueButtonLabel => 'CONTINUER';

  @override
  String get copyButtonLabel => 'COPIER';

  @override
  String get cutButtonLabel => 'COUPER';

  @override
  String get deleteButtonTooltip => 'Supprimer';

  @override
  String get dialogLabel => 'Boîte de dialogue';

  @override
  String get drawerLabel => 'Menu de navigation';

  @override
  String get expandedIconTapHint => 'Réduire';

  @override
  String get hideAccountsLabel => 'Masquer les comptes';

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get modalBarrierDismissLabel => 'Ignorer';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Mois suivant';

  @override
  String get nextPageTooltip => 'Page suivante';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Ouvrir le menu de navigation';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow sur \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow sur environ \$rowCount';

  @override
  String get pasteButtonLabel => 'COLLER';

  @override
  String get popupMenuLabel => 'Menu contextuel';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Mois précédent';

  @override
  String get previousPageTooltip => 'Page précédente';

  @override
  String get refreshIndicatorSemanticLabel => 'Actualiser';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 caractère restant';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount caractères restants';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Déplacer vers le bas';

  @override
  String get reorderItemLeft => 'Déplacer vers la gauche';

  @override
  String get reorderItemRight => 'Déplacer vers la droite';

  @override
  String get reorderItemToEnd => 'Déplacer vers la fin';

  @override
  String get reorderItemToStart => 'Déplacer vers le début';

  @override
  String get reorderItemUp => 'Déplacer vers le haut';

  @override
  String get rowsPerPageTitle => 'Lignes par page :';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Rechercher';

  @override
  String get selectAllButtonLabel => 'TOUT SÉLECTIONNER';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 élément sélectionné';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount éléments sélectionnés';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Aucun élément sélectionné';

  @override
  String get showAccountsLabel => 'Afficher les comptes';

  @override
  String get showMenuTooltip => 'Afficher le menu';

  @override
  String get signedInLabel => 'Connecté';

  @override
  String get tabLabelRaw => 'Onglet \$tabIndex sur \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Sélectionner une heure';

  @override
  String get timePickerMinuteModeAnnouncement => 'Sélectionner des minutes';

  @override
  String get viewLicensesButtonLabel => 'AFFICHER LES LICENCES';
}

/// The translations for French, as used in Canada (`fr_CA`).
class MaterialLocalizationFrCa extends MaterialLocalizationFr {
  /// Create an instance of the translation bundle for French, as used in Canada.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationFrCa({
    String localeName = 'fr_CA',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow à \$lastRow sur \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow à \$lastRow sur environ \$rowCount';

  @override
  String get tabLabelRaw => 'Onglet \$tabIndex sur \$tabCount';

  @override
  String get anteMeridiemAbbreviation => 'am';

  @override
  String get postMeridiemAbbreviation => 'pm';

  @override
  String get timePickerHourModeAnnouncement => 'Sélectionnez les heures';

  @override
  String get timePickerMinuteModeAnnouncement => 'Sélectionnez les minutes';

  @override
  String get reorderItemToStart => 'Déplacer au début';

  @override
  String get reorderItemToEnd => 'Déplacer à la fin';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.frenchCanadian;
}

/// The translations for Galician (`gl`).
class MaterialLocalizationGl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Galician.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationGl({
    String localeName = 'gl',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Acerca de: \$applicationName';

  @override
  String get alertDialogLabel => 'Alerta';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get backButtonTooltip => 'Atrás';

  @override
  String get cancelButtonLabel => 'CANCELAR';

  @override
  String get closeButtonLabel => 'PECHAR';

  @override
  String get closeButtonTooltip => 'Pechar';

  @override
  String get collapsedIconTapHint => 'Despregar';

  @override
  String get continueButtonLabel => 'CONTINUAR';

  @override
  String get copyButtonLabel => 'COPIAR';

  @override
  String get cutButtonLabel => 'CORTAR';

  @override
  String get deleteButtonTooltip => 'Eliminar';

  @override
  String get dialogLabel => 'Cadro de diálogo';

  @override
  String get drawerLabel => 'Menú de navegación';

  @override
  String get expandedIconTapHint => 'Contraer';

  @override
  String get hideAccountsLabel => 'Ocultar contas';

  @override
  String get licensesPageTitle => 'Licenzas';

  @override
  String get modalBarrierDismissLabel => 'Ignorar';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Mes seguinte';

  @override
  String get nextPageTooltip => 'Páxina seguinte';

  @override
  String get okButtonLabel => 'Aceptar';

  @override
  String get openAppDrawerTooltip => 'Abrir menú de navegación';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow de aproximadamente \$rowCount';

  @override
  String get pasteButtonLabel => 'PEGAR';

  @override
  String get popupMenuLabel => 'Menú emerxente';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get previousMonthTooltip => 'Mes anterior';

  @override
  String get previousPageTooltip => 'Páxina anterior';

  @override
  String get refreshIndicatorSemanticLabel => 'Actualizar';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 carácter restante';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount caracteres restantes';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Mover cara abaixo';

  @override
  String get reorderItemLeft => 'Mover cara á esquerda';

  @override
  String get reorderItemRight => 'Mover cara á dereita';

  @override
  String get reorderItemToEnd => 'Mover ao final';

  @override
  String get reorderItemToStart => 'Mover ao inicio';

  @override
  String get reorderItemUp => 'Mover cara arriba';

  @override
  String get rowsPerPageTitle => 'Filas por páxina:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Buscar';

  @override
  String get selectAllButtonLabel => 'SELECCIONAR TODO';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Seleccionouse 1 elemento';

  @override
  String get selectedRowCountTitleOther => 'Seleccionáronse \$selectedRowCount elementos';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Non se seleccionaron elementos';

  @override
  String get showAccountsLabel => 'Mostrar contas';

  @override
  String get showMenuTooltip => 'Mostrar menú';

  @override
  String get signedInLabel => 'Sesión iniciada';

  @override
  String get tabLabelRaw => 'Pestana \$tabIndex de \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Seleccionar horas';

  @override
  String get timePickerMinuteModeAnnouncement => 'Seleccionar minutos';

  @override
  String get viewLicensesButtonLabel => 'VER LICENZAS';
}

/// The translations for Swiss German Alemannic Alsatian (`gsw`).
class MaterialLocalizationGsw extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Swiss German Alemannic Alsatian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationGsw({
    String localeName = 'gsw',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Über \$applicationName';

  @override
  String get alertDialogLabel => 'Benachrichtigung';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Zurück';

  @override
  String get cancelButtonLabel => 'ABBRECHEN';

  @override
  String get closeButtonLabel => 'SCHLIEẞEN';

  @override
  String get closeButtonTooltip => 'Schließen';

  @override
  String get collapsedIconTapHint => 'Maximieren';

  @override
  String get continueButtonLabel => 'WEITER';

  @override
  String get copyButtonLabel => 'KOPIEREN';

  @override
  String get cutButtonLabel => 'AUSSCHNEIDEN';

  @override
  String get deleteButtonTooltip => 'Löschen';

  @override
  String get dialogLabel => 'Dialogfeld';

  @override
  String get drawerLabel => 'Navigationsmenü';

  @override
  String get expandedIconTapHint => 'Minimieren';

  @override
  String get hideAccountsLabel => 'Konten ausblenden';

  @override
  String get licensesPageTitle => 'Lizenzen';

  @override
  String get modalBarrierDismissLabel => 'Schließen';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Nächster Monat';

  @override
  String get nextPageTooltip => 'Nächste Seite';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Navigationsmenü öffnen';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow von \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow von etwa \$rowCount';

  @override
  String get pasteButtonLabel => 'EINFÜGEN';

  @override
  String get popupMenuLabel => 'Pop-up-Menü';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Vorheriger Monat';

  @override
  String get previousPageTooltip => 'Vorherige Seite';

  @override
  String get refreshIndicatorSemanticLabel => 'Aktualisieren';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Noch 1 Zeichen';

  @override
  String get remainingTextFieldCharacterCountOther => 'Noch \$remainingCount Zeichen';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Nach unten verschieben';

  @override
  String get reorderItemLeft => 'Nach links verschieben';

  @override
  String get reorderItemRight => 'Nach rechts verschieben';

  @override
  String get reorderItemToEnd => 'An das Ende verschieben';

  @override
  String get reorderItemToStart => 'An den Anfang verschieben';

  @override
  String get reorderItemUp => 'Nach oben verschieben';

  @override
  String get rowsPerPageTitle => 'Zeilen pro Seite:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Suchen';

  @override
  String get selectAllButtonLabel => 'ALLE AUSWÄHLEN';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 Element ausgewählt';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount Elemente ausgewählt';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Konten anzeigen';

  @override
  String get showMenuTooltip => 'Menü anzeigen';

  @override
  String get signedInLabel => 'Angemeldet';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex von \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Stunden auswählen';

  @override
  String get timePickerMinuteModeAnnouncement => 'Minuten auswählen';

  @override
  String get viewLicensesButtonLabel => 'LIZENZEN ANZEIGEN';
}

/// The translations for Gujarati (`gu`).
class MaterialLocalizationGu extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Gujarati.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationGu({
    String localeName = 'gu',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName વિશે';

  @override
  String get alertDialogLabel => 'અલર્ટ';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'પાછળ';

  @override
  String get cancelButtonLabel => 'રદ કરો';

  @override
  String get closeButtonLabel => 'બંધ કરો';

  @override
  String get closeButtonTooltip => 'બંધ કરો';

  @override
  String get collapsedIconTapHint => 'વિસ્તૃત કરો';

  @override
  String get continueButtonLabel => 'ચાલુ રાખો';

  @override
  String get copyButtonLabel => 'કૉપિ કરો';

  @override
  String get cutButtonLabel => 'કાપો';

  @override
  String get deleteButtonTooltip => 'ડિલીટ કરો';

  @override
  String get dialogLabel => 'સંવાદ';

  @override
  String get drawerLabel => 'નૅવિગેશન મેનૂ';

  @override
  String get expandedIconTapHint => 'સંકુચિત કરો';

  @override
  String get hideAccountsLabel => 'એકાઉન્ટ છુપાવો';

  @override
  String get licensesPageTitle => 'લાઇસન્સ';

  @override
  String get modalBarrierDismissLabel => 'છોડી દો';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'આગલો મહિનો';

  @override
  String get nextPageTooltip => 'આગલું પેજ';

  @override
  String get okButtonLabel => 'ઓકે';

  @override
  String get openAppDrawerTooltip => 'નૅવિગેશન મેનૂ ખોલો';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCountમાંથી \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'આશરે \$rowCountમાંથી \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'પેસ્ટ કરો';

  @override
  String get popupMenuLabel => 'પૉપઅપ મેનૂ';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'પાછલો મહિનો';

  @override
  String get previousPageTooltip => 'પાછલું પેજ';

  @override
  String get refreshIndicatorSemanticLabel => 'રિફ્રેશ કરો';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 અક્ષર બાકી';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount અક્ષર બાકી';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'નીચે ખસેડો';

  @override
  String get reorderItemLeft => 'ડાબે ખસેડો';

  @override
  String get reorderItemRight => 'જમણે ખસેડો';

  @override
  String get reorderItemToEnd => 'અંતમાં ખસેડો';

  @override
  String get reorderItemToStart => 'પ્રારંભમાં ખસેડો';

  @override
  String get reorderItemUp => 'ઉપર ખસેડો';

  @override
  String get rowsPerPageTitle => 'પેજ દીઠ પંક્તિઓ:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'શોધો';

  @override
  String get selectAllButtonLabel => 'બધા પસંદ કરો';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 આઇટમ પસંદ કરી';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount આઇટમ પસંદ કરી';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'એકાઉન્ટ બતાવો';

  @override
  String get showMenuTooltip => 'મેનૂ બતાવો';

  @override
  String get signedInLabel => 'આમાં સાઇન ઇન કર્યું છે';

  @override
  String get tabLabelRaw => '\$tabCountમાંથી \$tabIndex ટૅબ';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'કલાક પસંદ કરો';

  @override
  String get timePickerMinuteModeAnnouncement => 'મિનિટ પસંદ કરો';

  @override
  String get viewLicensesButtonLabel => 'લાઇસન્સ જુઓ';
}

/// The translations for Hebrew (`he`).
class MaterialLocalizationHe extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Hebrew.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationHe({
    String localeName = 'he',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'מידע על \$applicationName';

  @override
  String get alertDialogLabel => 'התראה';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'הקודם';

  @override
  String get cancelButtonLabel => 'ביטול';

  @override
  String get closeButtonLabel => 'סגירה';

  @override
  String get closeButtonTooltip => 'סגירה';

  @override
  String get collapsedIconTapHint => 'הרחבה';

  @override
  String get continueButtonLabel => 'המשך';

  @override
  String get copyButtonLabel => 'העתקה';

  @override
  String get cutButtonLabel => 'גזירה';

  @override
  String get deleteButtonTooltip => 'מחיקה';

  @override
  String get dialogLabel => 'תיבת דו-שיח';

  @override
  String get drawerLabel => 'תפריט ניווט';

  @override
  String get expandedIconTapHint => 'כיווץ';

  @override
  String get hideAccountsLabel => 'הסתרת החשבונות';

  @override
  String get licensesPageTitle => 'רישיונות';

  @override
  String get modalBarrierDismissLabel => 'סגירה';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'החודש הבא';

  @override
  String get nextPageTooltip => 'הדף הבא';

  @override
  String get okButtonLabel => 'אישור';

  @override
  String get openAppDrawerTooltip => 'פתיחה של תפריט הניווט';

  @override
  String get pageRowsInfoTitleRaw => '\$lastRow–\$firstRow מתוך \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$lastRow–\$firstRow מתוך כ-\$rowCount';

  @override
  String get pasteButtonLabel => 'הדבקה';

  @override
  String get popupMenuLabel => 'תפריט קופץ';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'החודש הקודם';

  @override
  String get previousPageTooltip => 'הדף הקודם';

  @override
  String get refreshIndicatorSemanticLabel => 'רענון';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => 'נותרו \$remainingCount תווים';

  @override
  String get remainingTextFieldCharacterCountOne => 'נותר תו אחד';

  @override
  String get remainingTextFieldCharacterCountOther => 'נותרו \$remainingCount תווים';

  @override
  String get remainingTextFieldCharacterCountTwo => 'נותרו \$remainingCount תווים';

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'העברה למטה';

  @override
  String get reorderItemLeft => 'העברה שמאלה';

  @override
  String get reorderItemRight => 'העברה ימינה';

  @override
  String get reorderItemToEnd => 'העברה לסוף';

  @override
  String get reorderItemToStart => 'העברה להתחלה';

  @override
  String get reorderItemUp => 'העברה למעלה';

  @override
  String get rowsPerPageTitle => 'שורות בכל דף:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'חיפוש';

  @override
  String get selectAllButtonLabel => 'בחירת הכול';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => '\$selectedRowCount פריטים נבחרו';

  @override
  String get selectedRowCountTitleOne => 'פריט אחד נבחר';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount פריטים נבחרו';

  @override
  String get selectedRowCountTitleTwo => '\$selectedRowCount פריטים נבחרו';

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'הצגת החשבונות';

  @override
  String get showMenuTooltip => 'הצגת התפריט';

  @override
  String get signedInLabel => 'מחובר';

  @override
  String get tabLabelRaw => 'כרטיסייה \$tabIndex מתוך \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'בחירת שעות';

  @override
  String get timePickerMinuteModeAnnouncement => 'בחירת דקות';

  @override
  String get viewLicensesButtonLabel => 'הצגת הרישיונות';
}

/// The translations for Hindi (`hi`).
class MaterialLocalizationHi extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Hindi.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationHi({
    String localeName = 'hi',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName के बारे में जानकारी';

  @override
  String get alertDialogLabel => 'अलर्ट';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'वापस जाएं';

  @override
  String get cancelButtonLabel => 'रद्द करें';

  @override
  String get closeButtonLabel => 'बंद करें';

  @override
  String get closeButtonTooltip => 'बंद करें';

  @override
  String get collapsedIconTapHint => 'बड़ा करें';

  @override
  String get continueButtonLabel => 'जारी रखें';

  @override
  String get copyButtonLabel => 'कॉपी करें';

  @override
  String get cutButtonLabel => 'कट करें';

  @override
  String get deleteButtonTooltip => 'मिटाएं';

  @override
  String get dialogLabel => 'संवाद';

  @override
  String get drawerLabel => 'नेविगेशन मेन्यू';

  @override
  String get expandedIconTapHint => 'छोटा करें';

  @override
  String get hideAccountsLabel => 'खाते छिपाएं';

  @override
  String get licensesPageTitle => 'लाइसेंस';

  @override
  String get modalBarrierDismissLabel => 'खारिज करें';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'अगला महीना';

  @override
  String get nextPageTooltip => 'अगला पेज';

  @override
  String get okButtonLabel => 'ठीक है';

  @override
  String get openAppDrawerTooltip => 'नेविगेशन मेन्यू खोलें';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount का \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$rowCount में से करीब \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'चिपकाएं';

  @override
  String get popupMenuLabel => 'पॉपअप मेन्यू';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'पिछला महीना';

  @override
  String get previousPageTooltip => 'पिछला पेज';

  @override
  String get refreshIndicatorSemanticLabel => 'रीफ़्रेश करें';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'एक वर्ण अाैर डाला जा सकता है';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount वर्ण अाैर डाले जा सकते हैं';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'नीचे ले जाएं';

  @override
  String get reorderItemLeft => 'बाएं ले जाएं';

  @override
  String get reorderItemRight => 'दाएं ले जाएं';

  @override
  String get reorderItemToEnd => 'आखिर में ले जाएं';

  @override
  String get reorderItemToStart => 'शुरुआत पर ले जाएं';

  @override
  String get reorderItemUp => 'ऊपर ले जाएं';

  @override
  String get rowsPerPageTitle => 'हर पेज में पंक्तियों की संख्या:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => 'खोजें';

  @override
  String get selectAllButtonLabel => 'सभी चुनें';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 चीज़ चुनी गई';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount चीज़ें चुनी गईं';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'खाते दिखाएं';

  @override
  String get showMenuTooltip => 'मेन्यू दिखाएं';

  @override
  String get signedInLabel => 'साइन इन किया हुआ है';

  @override
  String get tabLabelRaw => '\$tabCount का टैब \$tabIndex';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.a_space_h_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'घंटे के हिसाब से समय चुनें';

  @override
  String get timePickerMinuteModeAnnouncement => 'मिनट के हिसाब से समय चुनें';

  @override
  String get viewLicensesButtonLabel => 'लाइसेंस देखें';
}

/// The translations for Croatian (`hr`).
class MaterialLocalizationHr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Croatian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationHr({
    String localeName = 'hr',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'O aplikaciji \$applicationName';

  @override
  String get alertDialogLabel => 'Upozorenje';

  @override
  String get anteMeridiemAbbreviation => 'prijepodne';

  @override
  String get backButtonTooltip => 'Natrag';

  @override
  String get cancelButtonLabel => 'ODUSTANI';

  @override
  String get closeButtonLabel => 'ZATVORI';

  @override
  String get closeButtonTooltip => 'Zatvaranje';

  @override
  String get collapsedIconTapHint => 'Proširi';

  @override
  String get continueButtonLabel => 'NASTAVI';

  @override
  String get copyButtonLabel => 'KOPIRAJ';

  @override
  String get cutButtonLabel => 'IZREŽI';

  @override
  String get deleteButtonTooltip => 'Brisanje';

  @override
  String get dialogLabel => 'Dijalog';

  @override
  String get drawerLabel => 'Navigacijski izbornik';

  @override
  String get expandedIconTapHint => 'Sažmi';

  @override
  String get hideAccountsLabel => 'Sakrijte račune';

  @override
  String get licensesPageTitle => 'Licence';

  @override
  String get modalBarrierDismissLabel => 'Odbaci';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Sljedeći mjesec';

  @override
  String get nextPageTooltip => 'Sljedeća stranica';

  @override
  String get okButtonLabel => 'U REDU';

  @override
  String get openAppDrawerTooltip => 'Otvaranje izbornika za navigaciju';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow od \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow od otprilike \$rowCount';

  @override
  String get pasteButtonLabel => 'ZALIJEPI';

  @override
  String get popupMenuLabel => 'Skočni izbornik';

  @override
  String get postMeridiemAbbreviation => 'popodne';

  @override
  String get previousMonthTooltip => 'Prethodni mjesec';

  @override
  String get previousPageTooltip => 'Prethodna stranica';

  @override
  String get refreshIndicatorSemanticLabel => 'Osvježi';

  @override
  String get remainingTextFieldCharacterCountFew => 'Preostala su \$remainingCount znaka';

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Preostao je 1 znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Preostalo je \$remainingCount znakova';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Pomakni prema dolje';

  @override
  String get reorderItemLeft => 'Pomakni ulijevo';

  @override
  String get reorderItemRight => 'Pomakni udesno';

  @override
  String get reorderItemToEnd => 'Premjesti na kraj';

  @override
  String get reorderItemToStart => 'Premjesti na početak';

  @override
  String get reorderItemUp => 'Pomakni prema gore';

  @override
  String get rowsPerPageTitle => 'Redaka po stranici:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Pretražite';

  @override
  String get selectAllButtonLabel => 'ODABERI SVE';

  @override
  String get selectedRowCountTitleFew => 'Odabrane su \$selectedRowCount stavke';

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Odabrana je jedna stavka';

  @override
  String get selectedRowCountTitleOther => 'Odabrano je \$selectedRowCount stavki';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Prikažite račune';

  @override
  String get showMenuTooltip => 'Prikaz izbornika';

  @override
  String get signedInLabel => 'Prijavljeni korisnik';

  @override
  String get tabLabelRaw => 'Kartica \$tabIndex od \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Odaberite sate';

  @override
  String get timePickerMinuteModeAnnouncement => 'Odaberite minute';

  @override
  String get viewLicensesButtonLabel => 'PRIKAŽI LICENCE';
}

/// The translations for Hungarian (`hu`).
class MaterialLocalizationHu extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Hungarian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationHu({
    String localeName = 'hu',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'A(z) \$applicationName névjegye';

  @override
  String get alertDialogLabel => 'Értesítés';

  @override
  String get anteMeridiemAbbreviation => 'de.';

  @override
  String get backButtonTooltip => 'Vissza';

  @override
  String get cancelButtonLabel => 'MÉGSE';

  @override
  String get closeButtonLabel => 'BEZÁRÁS';

  @override
  String get closeButtonTooltip => 'Bezárás';

  @override
  String get collapsedIconTapHint => 'Kibontás';

  @override
  String get continueButtonLabel => 'TOVÁBB';

  @override
  String get copyButtonLabel => 'MÁSOLÁS';

  @override
  String get cutButtonLabel => 'KIVÁGÁS';

  @override
  String get deleteButtonTooltip => 'Törlés';

  @override
  String get dialogLabel => 'Párbeszédablak';

  @override
  String get drawerLabel => 'Navigációs menü';

  @override
  String get expandedIconTapHint => 'Összecsukás';

  @override
  String get hideAccountsLabel => 'Fiókok elrejtése';

  @override
  String get licensesPageTitle => 'Licencek';

  @override
  String get modalBarrierDismissLabel => 'Elvetés';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Következő hónap';

  @override
  String get nextPageTooltip => 'Következő oldal';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Navigációs menü megnyitása';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount/\$firstRow–\$lastRow.';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'Körülbelül \$rowCount/\$firstRow–\$lastRow.';

  @override
  String get pasteButtonLabel => 'BEILLESZTÉS';

  @override
  String get popupMenuLabel => 'Előugró menü';

  @override
  String get postMeridiemAbbreviation => 'du.';

  @override
  String get previousMonthTooltip => 'Előző hónap';

  @override
  String get previousPageTooltip => 'Előző oldal';

  @override
  String get refreshIndicatorSemanticLabel => 'Frissítés';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 karakter maradt';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount karakter maradt';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Áthelyezés lefelé';

  @override
  String get reorderItemLeft => 'Áthelyezés balra';

  @override
  String get reorderItemRight => 'Áthelyezés jobbra';

  @override
  String get reorderItemToEnd => 'Áthelyezés a végére';

  @override
  String get reorderItemToStart => 'Áthelyezés az elejére';

  @override
  String get reorderItemUp => 'Áthelyezés felfelé';

  @override
  String get rowsPerPageTitle => 'Oldalankénti sorszám:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Keresés';

  @override
  String get selectAllButtonLabel => 'AZ ÖSSZES KIJELÖLÉSE';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 elem kiválasztva';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount elem kiválasztva';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Fiókok megjelenítése';

  @override
  String get showMenuTooltip => 'Menü megjelenítése';

  @override
  String get signedInLabel => 'Bejelentkezve';

  @override
  String get tabLabelRaw => '\$tabCount/\$tabIndex. lap';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Óra kiválasztása';

  @override
  String get timePickerMinuteModeAnnouncement => 'Perc kiválasztása';

  @override
  String get viewLicensesButtonLabel => 'LICENCEK MEGTEKINTÉSE';
}

/// The translations for Armenian (`hy`).
class MaterialLocalizationHy extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Armenian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationHy({
    String localeName = 'hy',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName հավելվածի մասին';

  @override
  String get alertDialogLabel => 'Ծանուցում';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Հետ';

  @override
  String get cancelButtonLabel => 'ՉԵՂԱՐԿԵԼ';

  @override
  String get closeButtonLabel => 'ՓԱԿԵԼ';

  @override
  String get closeButtonTooltip => 'Փակել';

  @override
  String get collapsedIconTapHint => 'Ծավալել';

  @override
  String get continueButtonLabel => 'ՇԱՐՈՒՆԱԿԵԼ';

  @override
  String get copyButtonLabel => 'ՊԱՏՃԵՆԵԼ';

  @override
  String get cutButtonLabel => 'ԿՏՐԵԼ';

  @override
  String get deleteButtonTooltip => 'Ջնջել';

  @override
  String get dialogLabel => 'Երկխոսության պատուհան';

  @override
  String get drawerLabel => 'Նավարկման ընտրացանկ';

  @override
  String get expandedIconTapHint => 'Ծալել';

  @override
  String get hideAccountsLabel => 'Թաքցնել հաշիվները';

  @override
  String get licensesPageTitle => 'Արտոնագրեր';

  @override
  String get modalBarrierDismissLabel => 'Փակել';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Հաջորդ ամիս';

  @override
  String get nextPageTooltip => 'Հաջորդ էջ';

  @override
  String get okButtonLabel => 'Եղավ';

  @override
  String get openAppDrawerTooltip => 'Բացել նավարկման ընտրացանկը';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow \$rowCount-ից';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow մոտավորապես \$rowCount-ից';

  @override
  String get pasteButtonLabel => 'ՏԵՂԱԴՐԵԼ';

  @override
  String get popupMenuLabel => 'Ելնող ընտրացանկ';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Նախորդ ամիս';

  @override
  String get previousPageTooltip => 'Նախորդ էջ';

  @override
  String get refreshIndicatorSemanticLabel => 'Թարմացնել';

  @override
  String get remainingTextFieldCharacterCountFew => 'Մնաց \$remainingCount նիշ';

  @override
  String get remainingTextFieldCharacterCountMany => 'Մնաց \$remainingCount նիշ';

  @override
  String get remainingTextFieldCharacterCountOne => 'Մնացել է 1 նիշ';

  @override
  String get remainingTextFieldCharacterCountOther => 'Մնացել է \$remainingCount նիշ';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'Նիշի հնարավորություն չկա';

  @override
  String get reorderItemDown => 'Տեղափոխել ներքև';

  @override
  String get reorderItemLeft => 'Տեղափոխել ձախ';

  @override
  String get reorderItemRight => 'Տեղափոխել աջ';

  @override
  String get reorderItemToEnd => 'Տեղափոխել վերջ';

  @override
  String get reorderItemToStart => 'Տեղափոխել սկիզբ';

  @override
  String get reorderItemUp => 'Տեղափոխել վերև';

  @override
  String get rowsPerPageTitle => 'Մեկ էջի տողերը՝';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Որոնել';

  @override
  String get selectAllButtonLabel => 'ՆՇԵԼ ԲՈԼՈՐԸ';

  @override
  String get selectedRowCountTitleFew => 'Ընտրված է \$selectedRowCount օբյեկտ';

  @override
  String get selectedRowCountTitleMany => 'Ընտրված է \$selectedRowCount օբյեկտ';

  @override
  String get selectedRowCountTitleOne => 'Ընտրվել է 1 տարր';

  @override
  String get selectedRowCountTitleOther => 'Ընտրվել է \$selectedRowCount տարր';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Տողերը ընտրված չեն';

  @override
  String get showAccountsLabel => 'Ցույց տալ հաշիվները';

  @override
  String get showMenuTooltip => 'Ցույց տալ ընտրացանկը';

  @override
  String get signedInLabel => 'Դուք մուտք եք գործել';

  @override
  String get tabLabelRaw => 'Ներդիր \$tabIndex՝ \$tabCount-ից';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Ընտրեք ժամը';

  @override
  String get timePickerMinuteModeAnnouncement => 'Ընտրեք րոպեները';

  @override
  String get viewLicensesButtonLabel => 'ԴԻՏԵԼ ԱՐՏՈՆԱԳՐԵՐԸ';
}

/// The translations for Indonesian (`id`).
class MaterialLocalizationId extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Indonesian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationId({
    String localeName = 'id',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Tentang \$applicationName';

  @override
  String get alertDialogLabel => 'Notifikasi';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Kembali';

  @override
  String get cancelButtonLabel => 'BATAL';

  @override
  String get closeButtonLabel => 'TUTUP';

  @override
  String get closeButtonTooltip => 'Tutup';

  @override
  String get collapsedIconTapHint => 'Luaskan';

  @override
  String get continueButtonLabel => 'LANJUTKAN';

  @override
  String get copyButtonLabel => 'SALIN';

  @override
  String get cutButtonLabel => 'POTONG';

  @override
  String get deleteButtonTooltip => 'Hapus';

  @override
  String get dialogLabel => 'Dialog';

  @override
  String get drawerLabel => 'Menu navigasi';

  @override
  String get expandedIconTapHint => 'Ciutkan';

  @override
  String get hideAccountsLabel => 'Sembunyikan akun';

  @override
  String get licensesPageTitle => 'Lisensi';

  @override
  String get modalBarrierDismissLabel => 'Tutup';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Bulan berikutnya';

  @override
  String get nextPageTooltip => 'Halaman berikutnya';

  @override
  String get okButtonLabel => 'OKE';

  @override
  String get openAppDrawerTooltip => 'Buka menu navigasi';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow dari \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow dari kira-kira \$rowCount';

  @override
  String get pasteButtonLabel => 'TEMPEL';

  @override
  String get popupMenuLabel => 'Menu pop-up';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Bulan sebelumnya';

  @override
  String get previousPageTooltip => 'Halaman sebelumnya';

  @override
  String get refreshIndicatorSemanticLabel => 'Memuat ulang';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Sisa 1 karakter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Sisa \$remainingCount karakter';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Turunkan';

  @override
  String get reorderItemLeft => 'Pindahkan ke kiri';

  @override
  String get reorderItemRight => 'Pindahkan ke kanan';

  @override
  String get reorderItemToEnd => 'Pindahkan ke akhir';

  @override
  String get reorderItemToStart => 'Pindahkan ke awal';

  @override
  String get reorderItemUp => 'Naikkan';

  @override
  String get rowsPerPageTitle => 'Baris per halaman:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Telusuri';

  @override
  String get selectAllButtonLabel => 'PILIH SEMUA';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item dipilih';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount item dipilih';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Tampilkan akun';

  @override
  String get showMenuTooltip => 'Tampilkan menu';

  @override
  String get signedInLabel => 'Telah login';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex dari \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Pilih jam';

  @override
  String get timePickerMinuteModeAnnouncement => 'Pilih menit';

  @override
  String get viewLicensesButtonLabel => 'LIHAT LISENSI';
}

/// The translations for Icelandic (`is`).
class MaterialLocalizationIs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Icelandic.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationIs({
    String localeName = 'is',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Um \$applicationName';

  @override
  String get alertDialogLabel => 'Tilkynning';

  @override
  String get anteMeridiemAbbreviation => 'f.h.';

  @override
  String get backButtonTooltip => 'Til baka';

  @override
  String get cancelButtonLabel => 'HÆTTA';

  @override
  String get closeButtonLabel => 'LOKA';

  @override
  String get closeButtonTooltip => 'Loka';

  @override
  String get collapsedIconTapHint => 'Stækka';

  @override
  String get continueButtonLabel => 'HALDA ÁFRAM';

  @override
  String get copyButtonLabel => 'AFRITA';

  @override
  String get cutButtonLabel => 'KLIPPA';

  @override
  String get deleteButtonTooltip => 'Eyða';

  @override
  String get dialogLabel => 'Gluggi';

  @override
  String get drawerLabel => 'Yfirlitsvalmynd';

  @override
  String get expandedIconTapHint => 'Draga saman';

  @override
  String get hideAccountsLabel => 'Fela reikninga';

  @override
  String get licensesPageTitle => 'Leyfi';

  @override
  String get modalBarrierDismissLabel => 'Hunsa';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Næsti mánuður';

  @override
  String get nextPageTooltip => 'Næsta síða';

  @override
  String get okButtonLabel => 'Í lagi';

  @override
  String get openAppDrawerTooltip => 'Opna yfirlitsvalmynd';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow af \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow af um það bil \$rowCount';

  @override
  String get pasteButtonLabel => 'LÍMA';

  @override
  String get popupMenuLabel => 'Sprettivalmynd';

  @override
  String get postMeridiemAbbreviation => 'e.h.';

  @override
  String get previousMonthTooltip => 'Fyrri mánuður';

  @override
  String get previousPageTooltip => 'Fyrri síða';

  @override
  String get refreshIndicatorSemanticLabel => 'Endurnýja';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 stafur eftir';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount stafir eftir';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Færa niður';

  @override
  String get reorderItemLeft => 'Færa til vinstri';

  @override
  String get reorderItemRight => 'Færa til hægri';

  @override
  String get reorderItemToEnd => 'Færa aftast';

  @override
  String get reorderItemToStart => 'Færa fremst';

  @override
  String get reorderItemUp => 'Færa upp';

  @override
  String get rowsPerPageTitle => 'Línur á síðu:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Leit';

  @override
  String get selectAllButtonLabel => 'VELJA ALLT';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 atriði valið';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount atriði valin';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Sýna reikninga';

  @override
  String get showMenuTooltip => 'Sýna valmynd';

  @override
  String get signedInLabel => 'Innskráð(ur)';

  @override
  String get tabLabelRaw => 'Flipi \$tabIndex af \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Velja klukkustundir';

  @override
  String get timePickerMinuteModeAnnouncement => 'Velja mínútur';

  @override
  String get viewLicensesButtonLabel => 'SKOÐA LEYFI';
}

/// The translations for Italian (`it`).
class MaterialLocalizationIt extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Italian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationIt({
    String localeName = 'it',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Informazioni su \$applicationName';

  @override
  String get alertDialogLabel => 'Avviso';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Indietro';

  @override
  String get cancelButtonLabel => 'ANNULLA';

  @override
  String get closeButtonLabel => 'CHIUDI';

  @override
  String get closeButtonTooltip => 'Chiudi';

  @override
  String get collapsedIconTapHint => 'Espandi';

  @override
  String get continueButtonLabel => 'CONTINUA';

  @override
  String get copyButtonLabel => 'COPIA';

  @override
  String get cutButtonLabel => 'TAGLIA';

  @override
  String get deleteButtonTooltip => 'Elimina';

  @override
  String get dialogLabel => 'Finestra di dialogo';

  @override
  String get drawerLabel => 'Menu di navigazione';

  @override
  String get expandedIconTapHint => 'Comprimi';

  @override
  String get hideAccountsLabel => 'Nascondi account';

  @override
  String get licensesPageTitle => 'Licenze';

  @override
  String get modalBarrierDismissLabel => 'Ignora';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Mese successivo';

  @override
  String get nextPageTooltip => 'Pagina successiva';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Apri il menu di navigazione';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow di \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow di circa \$rowCount';

  @override
  String get pasteButtonLabel => 'INCOLLA';

  @override
  String get popupMenuLabel => 'Menu popup';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Mese precedente';

  @override
  String get previousPageTooltip => 'Pagina precedente';

  @override
  String get refreshIndicatorSemanticLabel => 'Aggiorna';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 carattere rimanente';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount caratteri rimanenti';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Sposta giù';

  @override
  String get reorderItemLeft => 'Sposta a sinistra';

  @override
  String get reorderItemRight => 'Sposta a destra';

  @override
  String get reorderItemToEnd => 'Sposta alla fine';

  @override
  String get reorderItemToStart => 'Sposta all\'inizio';

  @override
  String get reorderItemUp => 'Sposta su';

  @override
  String get rowsPerPageTitle => 'Righe per pagina:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Cerca';

  @override
  String get selectAllButtonLabel => 'SELEZIONA TUTTO';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 elemento selezionato';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount elementi selezionati';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Mostra account';

  @override
  String get showMenuTooltip => 'Mostra il menu';

  @override
  String get signedInLabel => 'Connesso';

  @override
  String get tabLabelRaw => 'Scheda \$tabIndex di \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Seleziona le ore';

  @override
  String get timePickerMinuteModeAnnouncement => 'Seleziona i minuti';

  @override
  String get viewLicensesButtonLabel => 'VISUALIZZA LICENZE';
}

/// The translations for Japanese (`ja`).
class MaterialLocalizationJa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Japanese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationJa({
    String localeName = 'ja',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName について';

  @override
  String get alertDialogLabel => '通知';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => '戻る';

  @override
  String get cancelButtonLabel => 'キャンセル';

  @override
  String get closeButtonLabel => '閉じる';

  @override
  String get closeButtonTooltip => '閉じる';

  @override
  String get collapsedIconTapHint => '展開';

  @override
  String get continueButtonLabel => '続行';

  @override
  String get copyButtonLabel => 'コピー';

  @override
  String get cutButtonLabel => '切り取り';

  @override
  String get deleteButtonTooltip => '削除';

  @override
  String get dialogLabel => 'ダイアログ';

  @override
  String get drawerLabel => 'ナビゲーション メニュー';

  @override
  String get expandedIconTapHint => '折りたたむ';

  @override
  String get hideAccountsLabel => 'アカウントを非表示';

  @override
  String get licensesPageTitle => 'ライセンス';

  @override
  String get modalBarrierDismissLabel => '閉じる';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => '来月';

  @override
  String get nextPageTooltip => '次のページ';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'ナビゲーション メニューを開く';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow - \$lastRow 行（合計 \$rowCount 行）';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow 行（合計約 \$rowCount 行）';

  @override
  String get pasteButtonLabel => '貼り付け';

  @override
  String get popupMenuLabel => 'ポップアップ メニュー';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => '前月';

  @override
  String get previousPageTooltip => '前のページ';

  @override
  String get refreshIndicatorSemanticLabel => '更新';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '残り 1 文字（半角相当）';

  @override
  String get remainingTextFieldCharacterCountOther => '残り \$remainingCount 文字（半角相当）';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => '下に移動';

  @override
  String get reorderItemLeft => '左に移動';

  @override
  String get reorderItemRight => '右に移動';

  @override
  String get reorderItemToEnd => '最後に移動';

  @override
  String get reorderItemToStart => '先頭に移動';

  @override
  String get reorderItemUp => '上に移動';

  @override
  String get rowsPerPageTitle => 'ページあたりの行数:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => '検索';

  @override
  String get selectAllButtonLabel => 'すべて選択';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 件のアイテムを選択中';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount 件のアイテムを選択中';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'アカウントを表示';

  @override
  String get showMenuTooltip => 'メニューを表示';

  @override
  String get signedInLabel => 'ログイン中';

  @override
  String get tabLabelRaw => 'タブ: \$tabIndex/\$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => '時間を選択';

  @override
  String get timePickerMinuteModeAnnouncement => '分を選択';

  @override
  String get viewLicensesButtonLabel => 'ライセンスを表示';
}

/// The translations for Georgian (`ka`).
class MaterialLocalizationKa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Georgian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationKa({
    String localeName = 'ka',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName-ის შესახებ';

  @override
  String get alertDialogLabel => 'გაფრთხილება';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'უკან';

  @override
  String get cancelButtonLabel => 'გაუქმება';

  @override
  String get closeButtonLabel => 'დახურვა';

  @override
  String get closeButtonTooltip => 'დახურვა';

  @override
  String get collapsedIconTapHint => 'გაშლა';

  @override
  String get continueButtonLabel => 'გაგრძელება';

  @override
  String get copyButtonLabel => 'კოპირება';

  @override
  String get cutButtonLabel => 'ამოჭრა';

  @override
  String get deleteButtonTooltip => 'წაშლა';

  @override
  String get dialogLabel => 'დიალოგი';

  @override
  String get drawerLabel => 'ნავიგაციის მენიუ';

  @override
  String get expandedIconTapHint => 'ჩაკეცვა';

  @override
  String get hideAccountsLabel => 'ანგარიშების დამალვა';

  @override
  String get licensesPageTitle => 'ლიცენზიები';

  @override
  String get modalBarrierDismissLabel => 'დახურვა';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'შემდეგი თვე';

  @override
  String get nextPageTooltip => 'შემდეგი გვერდი';

  @override
  String get okButtonLabel => 'კარგი';

  @override
  String get openAppDrawerTooltip => 'სანავიგაციო მენიუს გახსნა';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow / \$rowCount-დან';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow / დაახლოებით \$rowCount-დან';

  @override
  String get pasteButtonLabel => 'ჩასმა';

  @override
  String get popupMenuLabel => 'ამომხტარი მენიუ';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'წინა თვე';

  @override
  String get previousPageTooltip => 'წინა გვერდი';

  @override
  String get refreshIndicatorSemanticLabel => 'განახლება';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'დარჩა 1 სიმბოლო';

  @override
  String get remainingTextFieldCharacterCountOther => 'დარჩა \$remainingCount სიმბოლო';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'ქვემოთ გადატანა';

  @override
  String get reorderItemLeft => 'მარცხნივ გადატანა';

  @override
  String get reorderItemRight => 'მარჯვნივ გადატანა';

  @override
  String get reorderItemToEnd => 'ბოლოში გადატანა';

  @override
  String get reorderItemToStart => 'დასაწყისში გადატანა';

  @override
  String get reorderItemUp => 'ზემოთ გადატანა';

  @override
  String get rowsPerPageTitle => 'მწკრივი გვერდზე:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'ძიება';

  @override
  String get selectAllButtonLabel => 'ყველას არჩევა';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'არჩეულია 1 ერთეული';

  @override
  String get selectedRowCountTitleOther => 'არჩეულია \$selectedRowCount ერთეული';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'ანგარიშების ჩვენება';

  @override
  String get showMenuTooltip => 'მენიუს ჩვენება';

  @override
  String get signedInLabel => 'შესული';

  @override
  String get tabLabelRaw => 'ჩანართი \$tabIndex / \$tabCount-დან';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'აირჩიეთ საათები';

  @override
  String get timePickerMinuteModeAnnouncement => 'აირჩიეთ წუთები';

  @override
  String get viewLicensesButtonLabel => 'ლიცენზიების ნახვა';
}

/// The translations for Kazakh (`kk`).
class MaterialLocalizationKk extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Kazakh.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationKk({
    String localeName = 'kk',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName туралы';

  @override
  String get alertDialogLabel => 'Дабыл';

  @override
  String get anteMeridiemAbbreviation => 'түстен кейін';

  @override
  String get backButtonTooltip => 'Артқа';

  @override
  String get cancelButtonLabel => 'БАС ТАРТУ';

  @override
  String get closeButtonLabel => 'ЖАБУ';

  @override
  String get closeButtonTooltip => 'Жабу';

  @override
  String get collapsedIconTapHint => 'Жаю';

  @override
  String get continueButtonLabel => 'ЖАЛҒАСТЫРУ';

  @override
  String get copyButtonLabel => 'КӨШІРУ';

  @override
  String get cutButtonLabel => 'ҚИЮ';

  @override
  String get deleteButtonTooltip => 'Жою';

  @override
  String get dialogLabel => 'Диалогтық терезе';

  @override
  String get drawerLabel => 'Навигация мәзірі';

  @override
  String get expandedIconTapHint => 'Жию';

  @override
  String get hideAccountsLabel => 'Есептік жазбаларды жасыру';

  @override
  String get licensesPageTitle => 'Лицензиялар';

  @override
  String get modalBarrierDismissLabel => 'Жабу';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Келесі ай';

  @override
  String get nextPageTooltip => 'Келесі бет';

  @override
  String get okButtonLabel => 'Иә';

  @override
  String get openAppDrawerTooltip => 'Навигация мәзірін ашу';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount ішінен \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'Шамамен \$rowCount ішінен \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'ҚОЮ';

  @override
  String get popupMenuLabel => 'Қалқымалы терезе мәзірі';

  @override
  String get postMeridiemAbbreviation => 'түстен кейін';

  @override
  String get previousMonthTooltip => 'Өткен ай';

  @override
  String get previousPageTooltip => 'Алдыңғы бет';

  @override
  String get refreshIndicatorSemanticLabel => 'Жаңарту';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 таңба қалды.';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount таңба қалды.';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'Таңбалар қалмады';

  @override
  String get reorderItemDown => 'Төменге жылжыту';

  @override
  String get reorderItemLeft => 'Солға жылжыту';

  @override
  String get reorderItemRight => 'Оңға жылжыту';

  @override
  String get reorderItemToEnd => 'Соңына өту';

  @override
  String get reorderItemToStart => 'Басына өту';

  @override
  String get reorderItemUp => 'Жоғарыға жылжыту';

  @override
  String get rowsPerPageTitle => 'Әр беттегі жолдар саны:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Іздеу';

  @override
  String get selectAllButtonLabel => 'БАРЛЫҒЫН ТАҢДАУ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 элемент таңдалды.';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount элемент таңдалды.';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Тармақ таңдалмаған';

  @override
  String get showAccountsLabel => 'Есептік жазбаларды көрсету';

  @override
  String get showMenuTooltip => 'Мәзірді көрсету';

  @override
  String get signedInLabel => 'Есептік жазбаға кірген';

  @override
  String get tabLabelRaw => '\$tabCount/\$tabIndex қойынды';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Сағаттарды таңдаңыз';

  @override
  String get timePickerMinuteModeAnnouncement => 'Минуттарды таңдаңыз';

  @override
  String get viewLicensesButtonLabel => 'ЛИЦЕНЗИЯЛАРДЫ КӨРУ';
}

/// The translations for Khmer Central Khmer (`km`).
class MaterialLocalizationKm extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Khmer Central Khmer.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationKm({
    String localeName = 'km',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'អំពី \$applicationName';

  @override
  String get alertDialogLabel => 'ជូនដំណឹង';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'ថយក្រោយ';

  @override
  String get cancelButtonLabel => 'បោះបង់';

  @override
  String get closeButtonLabel => 'បិទ';

  @override
  String get closeButtonTooltip => 'បិទ';

  @override
  String get collapsedIconTapHint => 'ពង្រីក';

  @override
  String get continueButtonLabel => 'បន្ត';

  @override
  String get copyButtonLabel => 'ចម្លង';

  @override
  String get cutButtonLabel => 'កាត់';

  @override
  String get deleteButtonTooltip => 'លុប';

  @override
  String get dialogLabel => 'ប្រអប់';

  @override
  String get drawerLabel => 'ម៉ឺនុយរុករក';

  @override
  String get expandedIconTapHint => 'បង្រួម';

  @override
  String get hideAccountsLabel => 'លាក់គណនី';

  @override
  String get licensesPageTitle => 'អាជ្ញាបណ្ណ';

  @override
  String get modalBarrierDismissLabel => 'ច្រាន​ចោល';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ខែ​​ក្រោយ';

  @override
  String get nextPageTooltip => 'ទំព័របន្ទាប់';

  @override
  String get okButtonLabel => 'យល់ព្រម';

  @override
  String get openAppDrawerTooltip => 'បើក​ម៉ឺនុយរុករក';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow ក្នុង​ចំណោម​ \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow ក្នុង​ចំណោម​ប្រហែល \$rowCount';

  @override
  String get pasteButtonLabel => 'ដាក់​ចូល';

  @override
  String get popupMenuLabel => '​ម៉ឺនុយ​លោត​ឡើង';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'ខែមុន';

  @override
  String get previousPageTooltip => 'ទំព័រមុន';

  @override
  String get refreshIndicatorSemanticLabel => 'ផ្ទុកឡើងវិញ';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'នៅសល់​ 1 តួ​ទៀត';

  @override
  String get remainingTextFieldCharacterCountOther => 'នៅសល់ \$remainingCount តួ​ទៀត';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'ផ្លាស់ទី​ចុះ​ក្រោម';

  @override
  String get reorderItemLeft => 'ផ្លាស់ទី​ទៅ​ឆ្វេង';

  @override
  String get reorderItemRight => 'ផ្លាស់ទីទៅ​ស្តាំ';

  @override
  String get reorderItemToEnd => 'ផ្លាស់ទីទៅ​ចំណុចបញ្ចប់';

  @override
  String get reorderItemToStart => 'ផ្លាស់ទីទៅ​ចំណុច​ចាប់ផ្ដើម';

  @override
  String get reorderItemUp => 'ផ្លាស់ទី​ឡើង​លើ';

  @override
  String get rowsPerPageTitle => 'ជួរ​ដេក​ក្នុង​មួយ​ទំព័រ៖';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => 'ស្វែងរក';

  @override
  String get selectAllButtonLabel => 'ជ្រើសរើស​ទាំង​អស់';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'បាន​ជ្រើស​រើស​ធាតុ 1';

  @override
  String get selectedRowCountTitleOther => 'បាន​ជ្រើស​រើស​ធាតុ \$selectedRowCount';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'បង្ហាញគណនី';

  @override
  String get showMenuTooltip => 'បង្ហាញ​ម៉ឺនុយ';

  @override
  String get signedInLabel => 'បានចូល​គណនី';

  @override
  String get tabLabelRaw => 'ផ្ទាំង \$tabIndex ក្នុង​ចំណោម​ \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'ជ្រើសរើស​ម៉ោង';

  @override
  String get timePickerMinuteModeAnnouncement => 'ជ្រើសរើស​នាទី';

  @override
  String get viewLicensesButtonLabel => 'មើលអាជ្ញាបណ្ណ';
}

/// The translations for Kannada (`kn`).
class MaterialLocalizationKn extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Kannada.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationKn({
    String localeName = 'kn',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\u{24}\u{61}\u{70}\u{70}\u{6c}\u{69}\u{63}\u{61}\u{74}\u{69}\u{6f}\u{6e}\u{4e}\u{61}\u{6d}\u{65}\u{20}\u{cac}\u{c97}\u{ccd}\u{c97}\u{cc6}';

  @override
  String get alertDialogLabel => '\u{c8e}\u{c9a}\u{ccd}\u{c9a}\u{cb0}\u{cbf}\u{c95}\u{cc6}';

  @override
  String get anteMeridiemAbbreviation => '\u{cac}\u{cc6}\u{cb3}\u{cbf}\u{c97}\u{ccd}\u{c97}\u{cc6}';

  @override
  String get backButtonTooltip => '\u{cb9}\u{cbf}\u{c82}\u{ca4}\u{cbf}\u{cb0}\u{cc1}\u{c97}\u{cbf}';

  @override
  String get cancelButtonLabel => '\u{cb0}\u{ca6}\u{ccd}\u{ca6}\u{cc1}\u{cae}\u{cbe}\u{ca1}\u{cbf}';

  @override
  String get closeButtonLabel => '\u{cae}\u{cc1}\u{c9a}\u{ccd}\u{c9a}\u{cbf}\u{cb0}\u{cbf}';

  @override
  String get closeButtonTooltip => '\u{cae}\u{cc1}\u{c9a}\u{ccd}\u{c9a}\u{cbf}\u{cb0}\u{cbf}';

  @override
  String get collapsedIconTapHint => '\u{cb5}\u{cbf}\u{cb8}\u{ccd}\u{ca4}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get continueButtonLabel => '\u{cae}\u{cc1}\u{c82}\u{ca6}\u{cc1}\u{cb5}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get copyButtonLabel => '\u{ca8}\u{c95}\u{cb2}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get cutButtonLabel => '\u{c95}\u{ca4}\u{ccd}\u{ca4}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get deleteButtonTooltip => '\u{c85}\u{cb3}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get dialogLabel => '\u{ca1}\u{cc8}\u{cb2}\u{cbe}\u{c97}\u{ccd}';

  @override
  String get drawerLabel => '\u{ca8}\u{ccd}\u{caf}\u{cbe}\u{cb5}\u{cbf}\u{c97}\u{cc7}\u{cb6}\u{ca8}\u{ccd}\u{200c}\u{20}\u{cae}\u{cc6}\u{ca8}\u{cc1}';

  @override
  String get expandedIconTapHint => '\u{c95}\u{cc1}\u{c97}\u{ccd}\u{c97}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get hideAccountsLabel => '\u{c96}\u{cbe}\u{ca4}\u{cc6}\u{c97}\u{cb3}\u{ca8}\u{ccd}\u{ca8}\u{cc1}\u{20}\u{cae}\u{cb0}\u{cc6}\u{cae}\u{cbe}\u{ca1}\u{cbf}';

  @override
  String get licensesPageTitle => '\u{caa}\u{cb0}\u{cb5}\u{cbe}\u{ca8}\u{c97}\u{cbf}\u{c97}\u{cb3}\u{cc1}';

  @override
  String get modalBarrierDismissLabel => '\u{cb5}\u{c9c}\u{cbe}\u{c97}\u{cca}\u{cb3}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => '\u{cae}\u{cc1}\u{c82}\u{ca6}\u{cbf}\u{ca8}\u{20}\u{ca4}\u{cbf}\u{c82}\u{c97}\u{cb3}\u{cc1}';

  @override
  String get nextPageTooltip => '\u{cae}\u{cc1}\u{c82}\u{ca6}\u{cbf}\u{ca8}\u{20}\u{caa}\u{cc1}\u{c9f}';

  @override
  String get okButtonLabel => '\u{cb8}\u{cb0}\u{cbf}';

  @override
  String get openAppDrawerTooltip => '\u{ca8}\u{ccd}\u{caf}\u{cbe}\u{cb5}\u{cbf}\u{c97}\u{cc7}\u{cb6}\u{ca8}\u{ccd}\u{200c}\u{20}\u{cae}\u{cc6}\u{ca8}\u{cc1}\u{20}\u{ca4}\u{cc6}\u{cb0}\u{cc6}\u{caf}\u{cbf}\u{cb0}\u{cbf}';

  @override
  String get pageRowsInfoTitleRaw => '\u{24}\u{72}\u{6f}\u{77}\u{43}\u{6f}\u{75}\u{6e}\u{74}\u{20}\u{cb0}\u{cb2}\u{ccd}\u{cb2}\u{cbf}\u{20}\u{24}\u{66}\u{69}\u{72}\u{73}\u{74}\u{52}\u{6f}\u{77}\u{2013}\u{24}\u{6c}\u{61}\u{73}\u{74}\u{52}\u{6f}\u{77}';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\u{24}\u{72}\u{6f}\u{77}\u{43}\u{6f}\u{75}\u{6e}\u{74}\u{20}\u{cb0}\u{cb2}\u{ccd}\u{cb2}\u{cbf}\u{20}\u{24}\u{66}\u{69}\u{72}\u{73}\u{74}\u{52}\u{6f}\u{77}\u{2013}\u{24}\u{6c}\u{61}\u{73}\u{74}\u{52}\u{6f}\u{77}';

  @override
  String get pasteButtonLabel => '\u{c85}\u{c82}\u{c9f}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get popupMenuLabel => '\u{caa}\u{cbe}\u{caa}\u{ccd}\u{c85}\u{caa}\u{ccd}\u{20}\u{cae}\u{cc6}\u{ca8}\u{cc1}';

  @override
  String get postMeridiemAbbreviation => '\u{cb8}\u{c82}\u{c9c}\u{cc6}';

  @override
  String get previousMonthTooltip => '\u{cb9}\u{cbf}\u{c82}\u{ca6}\u{cbf}\u{ca8}\u{20}\u{ca4}\u{cbf}\u{c82}\u{c97}\u{cb3}\u{cc1}';

  @override
  String get previousPageTooltip => '\u{cb9}\u{cbf}\u{c82}\u{ca6}\u{cbf}\u{ca8}\u{20}\u{caa}\u{cc1}\u{c9f}';

  @override
  String get refreshIndicatorSemanticLabel => '\u{cb0}\u{cbf}\u{cab}\u{ccd}\u{cb0}\u{cc6}\u{cb6}\u{ccd}\u{20}\u{cae}\u{cbe}\u{ca1}\u{cbf}';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '\u{31}\u{20}\u{c85}\u{c95}\u{ccd}\u{cb7}\u{cb0}\u{20}\u{c89}\u{cb3}\u{cbf}\u{ca6}\u{cbf}\u{ca6}\u{cc6}';

  @override
  String get remainingTextFieldCharacterCountOther => '\u{24}\u{72}\u{65}\u{6d}\u{61}\u{69}\u{6e}\u{69}\u{6e}\u{67}\u{43}\u{6f}\u{75}\u{6e}\u{74}\u{20}\u{c85}\u{c95}\u{ccd}\u{cb7}\u{cb0}\u{c97}\u{cb3}\u{cc1}\u{20}\u{c89}\u{cb3}\u{cbf}\u{ca6}\u{cbf}\u{cb5}\u{cc6}';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => '\u{c95}\u{cc6}\u{cb3}\u{c97}\u{cc6}\u{20}\u{cb8}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get reorderItemLeft => '\u{c8e}\u{ca1}\u{c95}\u{ccd}\u{c95}\u{cc6}\u{20}\u{cb8}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get reorderItemRight => '\u{cac}\u{cb2}\u{c95}\u{ccd}\u{c95}\u{cc6}\u{20}\u{cb8}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get reorderItemToEnd => '\u{c95}\u{cca}\u{ca8}\u{cc6}\u{c97}\u{cc6}\u{20}\u{cb8}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get reorderItemToStart => '\u{caa}\u{ccd}\u{cb0}\u{cbe}\u{cb0}\u{c82}\u{cad}\u{c95}\u{ccd}\u{c95}\u{cc6}\u{20}\u{cb8}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get reorderItemUp => '\u{cae}\u{cc7}\u{cb2}\u{cc6}\u{20}\u{cb8}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get rowsPerPageTitle => '\u{caa}\u{ccd}\u{cb0}\u{ca4}\u{cbf}\u{20}\u{caa}\u{cc1}\u{c9f}\u{c95}\u{ccd}\u{c95}\u{cc6}\u{20}\u{cb8}\u{cbe}\u{cb2}\u{cc1}\u{c97}\u{cb3}\u{cc1}\u{3a}';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => '\u{cb9}\u{cc1}\u{ca1}\u{cc1}\u{c95}\u{cbf}';

  @override
  String get selectAllButtonLabel => '\u{c8e}\u{cb2}\u{ccd}\u{cb2}\u{cb5}\u{ca8}\u{ccd}\u{ca8}\u{cc2}\u{20}\u{c86}\u{caf}\u{ccd}\u{c95}\u{cc6}\u{cae}\u{cbe}\u{ca1}\u{cbf}';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '\u{31}\u{20}\u{c90}\u{c9f}\u{c82}\u{20}\u{c86}\u{caf}\u{ccd}\u{c95}\u{cc6}\u{20}\u{cae}\u{cbe}\u{ca1}\u{cb2}\u{cbe}\u{c97}\u{cbf}\u{ca6}\u{cc6}';

  @override
  String get selectedRowCountTitleOther => '\u{24}\u{73}\u{65}\u{6c}\u{65}\u{63}\u{74}\u{65}\u{64}\u{52}\u{6f}\u{77}\u{43}\u{6f}\u{75}\u{6e}\u{74}\u{20}\u{c90}\u{c9f}\u{c82}\u{c97}\u{cb3}\u{ca8}\u{ccd}\u{ca8}\u{cc1}\u{20}\u{c86}\u{caf}\u{ccd}\u{c95}\u{cc6}\u{20}\u{cae}\u{cbe}\u{ca1}\u{cb2}\u{cbe}\u{c97}\u{cbf}\u{ca6}\u{cc6}';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => '\u{c96}\u{cbe}\u{ca4}\u{cc6}\u{c97}\u{cb3}\u{ca8}\u{ccd}\u{ca8}\u{cc1}\u{20}\u{ca4}\u{ccb}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get showMenuTooltip => '\u{cae}\u{cc6}\u{ca8}\u{cc1}\u{20}\u{ca4}\u{ccb}\u{cb0}\u{cbf}\u{cb8}\u{cbf}';

  @override
  String get signedInLabel => '\u{cb8}\u{cc8}\u{ca8}\u{ccd}\u{20}\u{c87}\u{ca8}\u{ccd}\u{20}\u{cae}\u{cbe}\u{ca1}\u{cb2}\u{cbe}\u{c97}\u{cbf}\u{ca6}\u{cc6}';

  @override
  String get tabLabelRaw => '\u{24}\u{74}\u{61}\u{62}\u{43}\u{6f}\u{75}\u{6e}\u{74}\u{20}\u{cb0}\u{cb2}\u{ccd}\u{cb2}\u{cbf}\u{ca8}\u{20}\u{24}\u{74}\u{61}\u{62}\u{49}\u{6e}\u{64}\u{65}\u{78}\u{20}\u{c9f}\u{ccd}\u{caf}\u{cbe}\u{cac}\u{ccd}';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => '\u{c97}\u{c82}\u{c9f}\u{cc6}\u{c97}\u{cb3}\u{ca8}\u{ccd}\u{ca8}\u{cc1}\u{20}\u{c86}\u{caf}\u{ccd}\u{c95}\u{cc6}\u{cae}\u{cbe}\u{ca1}\u{cbf}';

  @override
  String get timePickerMinuteModeAnnouncement => '\u{ca8}\u{cbf}\u{cae}\u{cbf}\u{cb7}\u{c97}\u{cb3}\u{ca8}\u{ccd}\u{ca8}\u{cc1}\u{20}\u{c86}\u{caf}\u{ccd}\u{c95}\u{cc6}\u{cae}\u{cbe}\u{ca1}\u{cbf}';

  @override
  String get viewLicensesButtonLabel => '\u{caa}\u{cb0}\u{cb5}\u{cbe}\u{ca8}\u{c97}\u{cbf}\u{c97}\u{cb3}\u{ca8}\u{ccd}\u{ca8}\u{cc1}\u{20}\u{cb5}\u{cbf}\u{cd5}\u{c95}\u{ccd}\u{cb7}\u{cbf}\u{cb8}\u{cbf}';
}

/// The translations for Korean (`ko`).
class MaterialLocalizationKo extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Korean.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationKo({
    String localeName = 'ko',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName 정보';

  @override
  String get alertDialogLabel => '알림';

  @override
  String get anteMeridiemAbbreviation => '오전';

  @override
  String get backButtonTooltip => '뒤로';

  @override
  String get cancelButtonLabel => '취소';

  @override
  String get closeButtonLabel => '닫기';

  @override
  String get closeButtonTooltip => '닫기';

  @override
  String get collapsedIconTapHint => '펼치기';

  @override
  String get continueButtonLabel => '계속';

  @override
  String get copyButtonLabel => '복사';

  @override
  String get cutButtonLabel => '잘라내기';

  @override
  String get deleteButtonTooltip => '삭제';

  @override
  String get dialogLabel => '대화상자';

  @override
  String get drawerLabel => '탐색 메뉴';

  @override
  String get expandedIconTapHint => '접기';

  @override
  String get hideAccountsLabel => '계정 숨기기';

  @override
  String get licensesPageTitle => '라이선스';

  @override
  String get modalBarrierDismissLabel => '닫기';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => '다음 달';

  @override
  String get nextPageTooltip => '다음 페이지';

  @override
  String get okButtonLabel => '확인';

  @override
  String get openAppDrawerTooltip => '탐색 메뉴 열기';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount행 중 \$firstRow~\$lastRow행';

  @override
  String get pageRowsInfoTitleApproximateRaw => '약 \$rowCount행 중 \$firstRow~\$lastRow행';

  @override
  String get pasteButtonLabel => '붙여넣기';

  @override
  String get popupMenuLabel => '팝업 메뉴';

  @override
  String get postMeridiemAbbreviation => '오후';

  @override
  String get previousMonthTooltip => '지난달';

  @override
  String get previousPageTooltip => '이전 페이지';

  @override
  String get refreshIndicatorSemanticLabel => '새로고침';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1자 남음';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount자 남음';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => '아래로 이동';

  @override
  String get reorderItemLeft => '왼쪽으로 이동';

  @override
  String get reorderItemRight => '오른쪽으로 이동';

  @override
  String get reorderItemToEnd => '끝으로 이동';

  @override
  String get reorderItemToStart => '시작으로 이동';

  @override
  String get reorderItemUp => '위로 이동';

  @override
  String get rowsPerPageTitle => '페이지당 행 수:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => '검색';

  @override
  String get selectAllButtonLabel => '전체 선택';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '항목 1개 선택됨';

  @override
  String get selectedRowCountTitleOther => '항목 \$selectedRowCount개 선택됨';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => '계정 표시';

  @override
  String get showMenuTooltip => '메뉴 표시';

  @override
  String get signedInLabel => '로그인됨';

  @override
  String get tabLabelRaw => '탭 \$tabCount개 중 \$tabIndex번째';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.a_space_h_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => '시간 선택';

  @override
  String get timePickerMinuteModeAnnouncement => '분 선택';

  @override
  String get viewLicensesButtonLabel => '라이선스 보기';
}

/// The translations for Kirghiz Kyrgyz (`ky`).
class MaterialLocalizationKy extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Kirghiz Kyrgyz.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationKy({
    String localeName = 'ky',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName каналы жөнүндө';

  @override
  String get alertDialogLabel => 'Эскертүү';

  @override
  String get anteMeridiemAbbreviation => 'түшкө чейин';

  @override
  String get backButtonTooltip => 'Артка';

  @override
  String get cancelButtonLabel => 'ЖОККО ЧЫГАРУУ';

  @override
  String get closeButtonLabel => 'ЖАБУУ';

  @override
  String get closeButtonTooltip => 'Жабуу';

  @override
  String get collapsedIconTapHint => 'Жайып көрсөтүү';

  @override
  String get continueButtonLabel => 'УЛАНТУУ';

  @override
  String get copyButtonLabel => 'КӨЧҮРҮҮ';

  @override
  String get cutButtonLabel => 'КЕСҮҮ';

  @override
  String get deleteButtonTooltip => 'Жок кылуу';

  @override
  String get dialogLabel => 'Диалог';

  @override
  String get drawerLabel => 'Чабыттоо менюсу';

  @override
  String get expandedIconTapHint => 'Жыйыштыруу';

  @override
  String get hideAccountsLabel => 'Аккаунттарды жашыруу';

  @override
  String get licensesPageTitle => 'Уруксаттамалар';

  @override
  String get modalBarrierDismissLabel => 'Жабуу';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Кийинки ай';

  @override
  String get nextPageTooltip => 'Кийинки бет';

  @override
  String get okButtonLabel => 'Макул';

  @override
  String get openAppDrawerTooltip => 'Чабыттоо менюсун ачуу';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount ичинен \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'Болжол менен \$rowCount ичинен \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'ЧАПТОО';

  @override
  String get popupMenuLabel => 'Калкып чыгуучу меню';

  @override
  String get postMeridiemAbbreviation => 'түштөн кийин';

  @override
  String get previousMonthTooltip => 'Мурунку ай';

  @override
  String get previousPageTooltip => 'Мурунку бет';

  @override
  String get refreshIndicatorSemanticLabel => 'Жаңыртуу';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 белги калды';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount белги калды';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Төмөн жылдыруу';

  @override
  String get reorderItemLeft => 'Солго жылдыруу';

  @override
  String get reorderItemRight => 'Оңго жылдыруу';

  @override
  String get reorderItemToEnd => 'Аягына жылдыруу';

  @override
  String get reorderItemToStart => 'Башына жылдыруу';

  @override
  String get reorderItemUp => 'Жогору жылдыруу';

  @override
  String get rowsPerPageTitle => 'Бир бетте көрсөтүлүүчү саптардын саны:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Издөө';

  @override
  String get selectAllButtonLabel => 'БААРЫН ТАНДОО';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 нерсе тандалды';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount нерсе тандалды';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Аккаунттарды көрсөтүү';

  @override
  String get showMenuTooltip => 'Менюну көрсөтүү';

  @override
  String get signedInLabel => 'Аккаунтуңузга кирдиңиз';

  @override
  String get tabLabelRaw => '\$tabCount кыналма ичинен \$tabIndex';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Саатты тандаңыз';

  @override
  String get timePickerMinuteModeAnnouncement => 'Мүнөттөрдү тандаңыз';

  @override
  String get viewLicensesButtonLabel => 'УРУКСАТТАМАЛАРДЫ КӨРҮҮ';
}

/// The translations for Lao (`lo`).
class MaterialLocalizationLo extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Lao.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationLo({
    String localeName = 'lo',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'ກ່ຽວກັບ \$applicationName';

  @override
  String get alertDialogLabel => 'ການເຕືອນ';

  @override
  String get anteMeridiemAbbreviation => 'ກ່ອນທ່ຽງ';

  @override
  String get backButtonTooltip => 'ກັບຄືນ';

  @override
  String get cancelButtonLabel => 'ຍົກເລີກ';

  @override
  String get closeButtonLabel => 'ປິດ';

  @override
  String get closeButtonTooltip => 'ປິດ';

  @override
  String get collapsedIconTapHint => 'ຂະຫຍາຍ';

  @override
  String get continueButtonLabel => 'ສືບຕໍ່';

  @override
  String get copyButtonLabel => 'ສຳເນົາ';

  @override
  String get cutButtonLabel => 'ຕັດ';

  @override
  String get deleteButtonTooltip => 'ລຶບ';

  @override
  String get dialogLabel => 'ຂໍ້ຄວາມ';

  @override
  String get drawerLabel => 'ເມນູນຳທາງ';

  @override
  String get expandedIconTapHint => 'ຫຍໍ້ເຂົ້າ';

  @override
  String get hideAccountsLabel => 'ເຊື່ອງບັນຊີ';

  @override
  String get licensesPageTitle => 'ໃບອະນຸຍາດ';

  @override
  String get modalBarrierDismissLabel => 'ປິດໄວ້';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ເດືອນໜ້າ';

  @override
  String get nextPageTooltip => 'ໜ້າຕໍ່ໄປ';

  @override
  String get okButtonLabel => 'ຕົກລົງ';

  @override
  String get openAppDrawerTooltip => 'ເປີດເມນູການນຳທາງ';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow ຈາກທັງໝົດ \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow ຈາກປະມານ \$rowCount';

  @override
  String get pasteButtonLabel => 'ວາງ';

  @override
  String get popupMenuLabel => 'ເມນູປັອບອັບ';

  @override
  String get postMeridiemAbbreviation => 'ຫຼັງທ່ຽງ';

  @override
  String get previousMonthTooltip => 'ເດືອນແລ້ວ';

  @override
  String get previousPageTooltip => 'ໜ້າກ່ອນໜ້າ';

  @override
  String get refreshIndicatorSemanticLabel => 'ໂຫຼດຄືນໃໝ່';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'ຍັງອີກ 1 ຕົວອັກສອນ';

  @override
  String get remainingTextFieldCharacterCountOther => 'ຍັງອີກ \$remainingCount ຕົວອັກສອນ';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'ຍ້າຍລົງ';

  @override
  String get reorderItemLeft => 'ຍ້າຍໄປຊ້າຍ';

  @override
  String get reorderItemRight => 'ຍ້າຍໄປຂວາ';

  @override
  String get reorderItemToEnd => 'ຍ້າຍໄປສິ້ນສຸດ';

  @override
  String get reorderItemToStart => 'ຍ້າຍໄປເລີ່ມຕົ້ນ';

  @override
  String get reorderItemUp => 'ຍ້າຍຂຶ້ນ';

  @override
  String get rowsPerPageTitle => 'ແຖວຕໍ່ໜ້າ:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'ຊອກຫາ';

  @override
  String get selectAllButtonLabel => 'ເລືອກທັງໝົດ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'ເລືອກ 1 ລາຍການແລ້ວ';

  @override
  String get selectedRowCountTitleOther => 'ເລືອກ \$selectedRowCount ລາຍການແລ້ວ';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'ສະແດງບັນຊີ';

  @override
  String get showMenuTooltip => 'ສະແດງເມນູ';

  @override
  String get signedInLabel => 'ເຂົ້າສູ່ລະບົບແລ້ວ';

  @override
  String get tabLabelRaw => 'ແຖບທີ \$tabIndex ຈາກທັງໝົດ \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'ເລືອກໂມງ';

  @override
  String get timePickerMinuteModeAnnouncement => 'ເລືອກນາທີ';

  @override
  String get viewLicensesButtonLabel => 'ເບິ່ງໃບອະນຸຍາດ';
}

/// The translations for Lithuanian (`lt`).
class MaterialLocalizationLt extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Lithuanian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationLt({
    String localeName = 'lt',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Apie „\$applicationName“';

  @override
  String get alertDialogLabel => 'Įspėjimas';

  @override
  String get anteMeridiemAbbreviation => 'priešpiet';

  @override
  String get backButtonTooltip => 'Atgal';

  @override
  String get cancelButtonLabel => 'ATŠAUKTI';

  @override
  String get closeButtonLabel => 'UŽDARYTI';

  @override
  String get closeButtonTooltip => 'Uždaryti';

  @override
  String get collapsedIconTapHint => 'Išskleisti';

  @override
  String get continueButtonLabel => 'TĘSTI';

  @override
  String get copyButtonLabel => 'KOPIJUOTI';

  @override
  String get cutButtonLabel => 'IŠKIRPTI';

  @override
  String get deleteButtonTooltip => 'Ištrinti';

  @override
  String get dialogLabel => 'Dialogo langas';

  @override
  String get drawerLabel => 'Naršymo meniu';

  @override
  String get expandedIconTapHint => 'Sutraukti';

  @override
  String get hideAccountsLabel => 'Slėpti paskyras';

  @override
  String get licensesPageTitle => 'Licencijos';

  @override
  String get modalBarrierDismissLabel => 'Atsisakyti';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Kitas mėnuo';

  @override
  String get nextPageTooltip => 'Kitas puslapis';

  @override
  String get okButtonLabel => 'GERAI';

  @override
  String get openAppDrawerTooltip => 'Atidaryti naršymo meniu';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow iš \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow iš maždaug \$rowCount';

  @override
  String get pasteButtonLabel => 'ĮKLIJUOTI';

  @override
  String get popupMenuLabel => 'Iššokantysis meniu';

  @override
  String get postMeridiemAbbreviation => 'popiet';

  @override
  String get previousMonthTooltip => 'Ankstesnis mėnuo';

  @override
  String get previousPageTooltip => 'Ankstesnis puslapis';

  @override
  String get refreshIndicatorSemanticLabel => 'Atnaujinti';

  @override
  String get remainingTextFieldCharacterCountFew => 'Liko \$remainingCount simboliai';

  @override
  String get remainingTextFieldCharacterCountMany => 'Liko \$remainingCount simbolio';

  @override
  String get remainingTextFieldCharacterCountOne => 'Liko 1 simbolis';

  @override
  String get remainingTextFieldCharacterCountOther => 'Liko \$remainingCount simbolių';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Perkelti žemyn';

  @override
  String get reorderItemLeft => 'Perkelti kairėn';

  @override
  String get reorderItemRight => 'Perkelti dešinėn';

  @override
  String get reorderItemToEnd => 'Perkelti į pabaigą';

  @override
  String get reorderItemToStart => 'Perkelti į pradžią';

  @override
  String get reorderItemUp => 'Perkelti aukštyn';

  @override
  String get rowsPerPageTitle => 'Eilučių puslapyje:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Paieška';

  @override
  String get selectAllButtonLabel => 'PASIRINKTI VISKĄ';

  @override
  String get selectedRowCountTitleFew => 'Pasirinkti \$selectedRowCount elementai';

  @override
  String get selectedRowCountTitleMany => 'Pasirinkta \$selectedRowCount elemento';

  @override
  String get selectedRowCountTitleOne => 'Pasirinktas 1 elementas';

  @override
  String get selectedRowCountTitleOther => 'Pasirinkta \$selectedRowCount elementų';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Rodyti paskyras';

  @override
  String get showMenuTooltip => 'Rodyti meniu';

  @override
  String get signedInLabel => 'Prisijungta';

  @override
  String get tabLabelRaw => '\$tabIndex skirtukas iš \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Pasirinkite valandas';

  @override
  String get timePickerMinuteModeAnnouncement => 'Pasirinkite minutes';

  @override
  String get viewLicensesButtonLabel => 'PERŽIŪRĖTI LICENCIJAS';
}

/// The translations for Latvian (`lv`).
class MaterialLocalizationLv extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Latvian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationLv({
    String localeName = 'lv',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Par \$applicationName';

  @override
  String get alertDialogLabel => 'Brīdinājums';

  @override
  String get anteMeridiemAbbreviation => 'priekšpusdienā';

  @override
  String get backButtonTooltip => 'Atpakaļ';

  @override
  String get cancelButtonLabel => 'ATCELT';

  @override
  String get closeButtonLabel => 'AIZVĒRT';

  @override
  String get closeButtonTooltip => 'Aizvērt';

  @override
  String get collapsedIconTapHint => 'Izvērst';

  @override
  String get continueButtonLabel => 'TURPINĀT';

  @override
  String get copyButtonLabel => 'KOPĒT';

  @override
  String get cutButtonLabel => 'IZGRIEZT';

  @override
  String get deleteButtonTooltip => 'Dzēst';

  @override
  String get dialogLabel => 'Dialoglodziņš';

  @override
  String get drawerLabel => 'Navigācijas izvēlne';

  @override
  String get expandedIconTapHint => 'Sakļaut';

  @override
  String get hideAccountsLabel => 'Slēpt kontus';

  @override
  String get licensesPageTitle => 'Licences';

  @override
  String get modalBarrierDismissLabel => 'Nerādīt';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Nākamais mēnesis';

  @override
  String get nextPageTooltip => 'Nākamā lapa';

  @override
  String get okButtonLabel => 'LABI';

  @override
  String get openAppDrawerTooltip => 'Atvērt navigācijas izvēlni';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow.–\$lastRow. no \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow.–\$lastRow. no aptuveni \$rowCount';

  @override
  String get pasteButtonLabel => 'IELĪMĒT';

  @override
  String get popupMenuLabel => 'Uznirstošā izvēlne';

  @override
  String get postMeridiemAbbreviation => 'pēcpusdienā';

  @override
  String get previousMonthTooltip => 'Iepriekšējais mēnesis';

  @override
  String get previousPageTooltip => 'Iepriekšējā lapa';

  @override
  String get refreshIndicatorSemanticLabel => 'Atsvaidzināt';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Atlikusi 1 rakstzīme.';

  @override
  String get remainingTextFieldCharacterCountOther => 'Atlikušas \$remainingCount rakstzīmes.';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'Nav atlikusi neviena rakstzīme.';

  @override
  String get reorderItemDown => 'Pārvietot uz leju';

  @override
  String get reorderItemLeft => 'Pārvietot pa kreisi';

  @override
  String get reorderItemRight => 'Pārvietot pa labi';

  @override
  String get reorderItemToEnd => 'Pārvietot uz beigām';

  @override
  String get reorderItemToStart => 'Pārvietot uz sākumu';

  @override
  String get reorderItemUp => 'Pārvietot uz augšu';

  @override
  String get rowsPerPageTitle => 'Rindas lapā:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Meklēt';

  @override
  String get selectAllButtonLabel => 'ATLASĪT VISU';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Atlasīts 1 vienums';

  @override
  String get selectedRowCountTitleOther => 'Atlasīti \$selectedRowCount vienumi';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Nav atlasītu vienumu';

  @override
  String get showAccountsLabel => 'Rādīt kontus';

  @override
  String get showMenuTooltip => 'Rādīt izvēlni';

  @override
  String get signedInLabel => 'Esat pierakstījies';

  @override
  String get tabLabelRaw => '\$tabIndex. cilne no \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Atlasiet stundas';

  @override
  String get timePickerMinuteModeAnnouncement => 'Atlasiet minūtes';

  @override
  String get viewLicensesButtonLabel => 'SKATĪT LICENCES';
}

/// The translations for Macedonian (`mk`).
class MaterialLocalizationMk extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Macedonian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationMk({
    String localeName = 'mk',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'За \$applicationName';

  @override
  String get alertDialogLabel => 'Предупредување';

  @override
  String get anteMeridiemAbbreviation => 'ПРЕТПЛАДНЕ';

  @override
  String get backButtonTooltip => 'Назад';

  @override
  String get cancelButtonLabel => 'ОТКАЖИ';

  @override
  String get closeButtonLabel => 'ЗАТВОРИ';

  @override
  String get closeButtonTooltip => 'Затвори';

  @override
  String get collapsedIconTapHint => 'Прошири';

  @override
  String get continueButtonLabel => 'ПРОДОЛЖИ';

  @override
  String get copyButtonLabel => 'КОПИРАЈ';

  @override
  String get cutButtonLabel => 'ИСЕЧИ';

  @override
  String get deleteButtonTooltip => 'Избриши';

  @override
  String get dialogLabel => 'Дијалог';

  @override
  String get drawerLabel => 'Мени за навигација';

  @override
  String get expandedIconTapHint => 'Собери';

  @override
  String get hideAccountsLabel => 'Сокриј сметки';

  @override
  String get licensesPageTitle => 'Лиценци';

  @override
  String get modalBarrierDismissLabel => 'Отфрли';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Следниот месец';

  @override
  String get nextPageTooltip => 'Следна страница';

  @override
  String get okButtonLabel => 'Во ред';

  @override
  String get openAppDrawerTooltip => 'Отворете го менито за навигација';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow - \$lastRow од \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow - \$lastRow од приближно \$rowCount';

  @override
  String get pasteButtonLabel => 'ЗАЛЕПИ';

  @override
  String get popupMenuLabel => 'Скокачко мени';

  @override
  String get postMeridiemAbbreviation => 'ПОПЛАДНЕ';

  @override
  String get previousMonthTooltip => 'Претходниот месец';

  @override
  String get previousPageTooltip => 'Претходна страница';

  @override
  String get refreshIndicatorSemanticLabel => 'Освежи';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Преостанува уште 1 знак';

  @override
  String get remainingTextFieldCharacterCountOther => 'Преостануваат уште \$remainingCount знаци';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Преместете надолу';

  @override
  String get reorderItemLeft => 'Преместете налево';

  @override
  String get reorderItemRight => 'Преместете надесно';

  @override
  String get reorderItemToEnd => 'Преместете на крајот';

  @override
  String get reorderItemToStart => 'Преместете на почеток';

  @override
  String get reorderItemUp => 'Преместете нагоре';

  @override
  String get rowsPerPageTitle => 'Редови на страница:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Пребарувајте';

  @override
  String get selectAllButtonLabel => 'ИЗБЕРИ ГИ СИТЕ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Избрана е 1 ставка';

  @override
  String get selectedRowCountTitleOther => 'Избрани се \$selectedRowCount ставки';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Прикажи сметки';

  @override
  String get showMenuTooltip => 'Прикажи мени';

  @override
  String get signedInLabel => 'Најавени сте';

  @override
  String get tabLabelRaw => 'Картичка \$tabIndex од \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Изберете часови';

  @override
  String get timePickerMinuteModeAnnouncement => 'Изберете минути';

  @override
  String get viewLicensesButtonLabel => 'ПРИКАЖИ ЛИЦЕНЦИ';
}

/// The translations for Malayalam (`ml`).
class MaterialLocalizationMl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Malayalam.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationMl({
    String localeName = 'ml',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName എന്നതിനെക്കുറിച്ച്';

  @override
  String get alertDialogLabel => 'മുന്നറിയിപ്പ്';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'മടങ്ങുക';

  @override
  String get cancelButtonLabel => 'റദ്ദാക്കുക';

  @override
  String get closeButtonLabel => 'അടയ്‌ക്കുക';

  @override
  String get closeButtonTooltip => 'അടയ്‌ക്കുക';

  @override
  String get collapsedIconTapHint => 'വികസിപ്പിക്കുക';

  @override
  String get continueButtonLabel => 'തുടരുക';

  @override
  String get copyButtonLabel => 'പകർത്തുക';

  @override
  String get cutButtonLabel => 'മുറിക്കുക';

  @override
  String get deleteButtonTooltip => 'ഇല്ലാതാക്കുക';

  @override
  String get dialogLabel => 'ഡയലോഗ്';

  @override
  String get drawerLabel => 'നാവിഗേഷൻ മെനു';

  @override
  String get expandedIconTapHint => 'ചുരുക്കുക';

  @override
  String get hideAccountsLabel => 'അക്കൗണ്ടുകൾ മറയ്‌ക്കുക';

  @override
  String get licensesPageTitle => 'ലൈസൻസുകൾ';

  @override
  String get modalBarrierDismissLabel => 'നിരസിക്കുക';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'അടുത്ത മാസം';

  @override
  String get nextPageTooltip => 'അടുത്ത പേജ്';

  @override
  String get okButtonLabel => 'ശരി';

  @override
  String get openAppDrawerTooltip => 'നാവിഗേഷൻ മെനു തുറക്കുക';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount-ൽ \$firstRow –\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'ഏകദേശം \$rowCount-ൽ \$firstRow –\$lastRow';

  @override
  String get pasteButtonLabel => 'ഒട്ടിക്കുക';

  @override
  String get popupMenuLabel => 'പോപ്പ് അപ്പ് മെനു';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'മുമ്പത്തെ മാസം';

  @override
  String get previousPageTooltip => 'മുമ്പത്തെ പേജ്';

  @override
  String get refreshIndicatorSemanticLabel => 'പുതുക്കിയെടുക്കുക';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'ഒരു പ്രതീകം ശേഷിക്കുന്നു';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount പ്രതീകങ്ങൾ ശേഷിക്കുന്നു';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'താഴോട്ട് നീക്കുക';

  @override
  String get reorderItemLeft => 'ഇടത്തോട്ട് നീക്കുക';

  @override
  String get reorderItemRight => 'വലത്തോട്ട് നീക്കുക';

  @override
  String get reorderItemToEnd => 'അവസാന ഭാഗത്തേക്ക് പോവുക';

  @override
  String get reorderItemToStart => 'തുടക്കത്തിലേക്ക് പോവുക';

  @override
  String get reorderItemUp => 'മുകളിലോട്ട് നീക്കുക';

  @override
  String get rowsPerPageTitle => 'ഓരോ പേജിലുമുള്ള വരികൾ:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'തിരയുക';

  @override
  String get selectAllButtonLabel => 'എല്ലാം തിരഞ്ഞെടുക്കുക';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'ഒരു ഇനം തിരഞ്ഞെടുത്തു';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount ഇനങ്ങൾ തിരഞ്ഞെടുത്തു';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'അക്കൗണ്ടുകൾ കാണിക്കുക';

  @override
  String get showMenuTooltip => 'മെനു കാണിക്കുക';

  @override
  String get signedInLabel => 'സൈൻ ഇൻ ചെയ്‌തു';

  @override
  String get tabLabelRaw => '\$tabCount-ൽ \$tabIndex';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'മണിക്കൂർ തിരഞ്ഞെടുക്കുക';

  @override
  String get timePickerMinuteModeAnnouncement => 'മിനിറ്റ് തിരഞ്ഞെടുക്കുക';

  @override
  String get viewLicensesButtonLabel => 'ലൈസൻസുകൾ കാണുക';
}

/// The translations for Mongolian (`mn`).
class MaterialLocalizationMn extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Mongolian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationMn({
    String localeName = 'mn',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName-н тухай';

  @override
  String get alertDialogLabel => 'Сэрэмжлүүлэг';

  @override
  String get anteMeridiemAbbreviation => 'ӨГЛӨӨ';

  @override
  String get backButtonTooltip => 'Буцах';

  @override
  String get cancelButtonLabel => 'БОЛИХ';

  @override
  String get closeButtonLabel => 'ХААХ';

  @override
  String get closeButtonTooltip => 'Хаах';

  @override
  String get collapsedIconTapHint => 'Дэлгэх';

  @override
  String get continueButtonLabel => 'ҮРГЭЛЖЛҮҮЛЭХ';

  @override
  String get copyButtonLabel => 'ХУУЛАХ';

  @override
  String get cutButtonLabel => 'ТАСЛАХ';

  @override
  String get deleteButtonTooltip => 'Устгах';

  @override
  String get dialogLabel => 'Харилцах цонх';

  @override
  String get drawerLabel => 'Навигацийн цэс';

  @override
  String get expandedIconTapHint => 'Буулгах';

  @override
  String get hideAccountsLabel => 'Бүртгэлүүдийг нуух';

  @override
  String get licensesPageTitle => 'Лиценз';

  @override
  String get modalBarrierDismissLabel => 'Үл хэрэгсэх';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Дараах сар';

  @override
  String get nextPageTooltip => 'Дараах хуудас';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Навигацийн цэсийг нээх';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount-н \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'Ойролцоогоор \$rowCount-н \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'БУУЛГАХ';

  @override
  String get popupMenuLabel => 'Попап цэс';

  @override
  String get postMeridiemAbbreviation => 'ОРОЙ';

  @override
  String get previousMonthTooltip => 'Өмнөх сар';

  @override
  String get previousPageTooltip => 'Өмнөх хуудас';

  @override
  String get refreshIndicatorSemanticLabel => 'Сэргээх';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 тэмдэгт үлдсэн';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount тэмдэгт үлдсэн';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'No characters remaining';

  @override
  String get reorderItemDown => 'Доош зөөх';

  @override
  String get reorderItemLeft => 'Зүүн тийш зөөх';

  @override
  String get reorderItemRight => 'Баруун тийш зөөх';

  @override
  String get reorderItemToEnd => 'Төгсгөл рүү зөөх';

  @override
  String get reorderItemToStart => 'Эхлэл рүү зөөх';

  @override
  String get reorderItemUp => 'Дээш зөөх';

  @override
  String get rowsPerPageTitle => 'Хуудсан дахь мөрийн тоо:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Хайх';

  @override
  String get selectAllButtonLabel => 'БҮГДИЙГ СОНГОХ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 зүйл сонгосон';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount зүйл сонгосон';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Бичлэг сонгоогүй байна';

  @override
  String get showAccountsLabel => 'Бүртгэлүүдийг харуулах';

  @override
  String get showMenuTooltip => 'Цэсийг харуулах';

  @override
  String get signedInLabel => 'Нэвтэрсэн';

  @override
  String get tabLabelRaw => '\$tabCount-н \$tabIndex-р таб';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Цаг сонгоно уу';

  @override
  String get timePickerMinuteModeAnnouncement => 'Минут сонгоно уу';

  @override
  String get viewLicensesButtonLabel => 'ЛИЦЕНЗИЙГ ХАРАХ';
}

/// The translations for Marathi (`mr`).
class MaterialLocalizationMr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Marathi.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationMr({
    String localeName = 'mr',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName बद्दल';

  @override
  String get alertDialogLabel => 'सूचना';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'मागे';

  @override
  String get cancelButtonLabel => 'रद्द करा';

  @override
  String get closeButtonLabel => 'बंद करा';

  @override
  String get closeButtonTooltip => 'बंद करा';

  @override
  String get collapsedIconTapHint => 'विस्तार करा';

  @override
  String get continueButtonLabel => 'सुरू ठेवा';

  @override
  String get copyButtonLabel => 'कॉपी करा';

  @override
  String get cutButtonLabel => 'कट करा';

  @override
  String get deleteButtonTooltip => 'हटवा';

  @override
  String get dialogLabel => 'डायलॉग';

  @override
  String get drawerLabel => 'नेव्हिगेशन मेनू';

  @override
  String get expandedIconTapHint => 'कोलॅप्स करा';

  @override
  String get hideAccountsLabel => 'खाती लपवा';

  @override
  String get licensesPageTitle => 'परवाने';

  @override
  String get modalBarrierDismissLabel => 'डिसमिस करा';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'पुढील महिना';

  @override
  String get nextPageTooltip => 'पुढील पेज';

  @override
  String get okButtonLabel => 'ओके';

  @override
  String get openAppDrawerTooltip => 'नेव्हिगेशन मेनू उघडा';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount पैकी \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$rowCount च्या बद्दल \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'पेस्ट करा';

  @override
  String get popupMenuLabel => 'पॉपअप मेनू';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'मागील महिना';

  @override
  String get previousPageTooltip => 'मागील पेज';

  @override
  String get refreshIndicatorSemanticLabel => 'रिफ्रेश करा';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'एक वर्ण शिल्लक';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount वर्ण शिल्लक';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'कोणतेही वर्ण शिल्लक नाहीत';

  @override
  String get reorderItemDown => 'खाली हलवा';

  @override
  String get reorderItemLeft => 'डावीकडे हलवा';

  @override
  String get reorderItemRight => 'उजवीकडे हलवा';

  @override
  String get reorderItemToEnd => 'शेवटाकडे हलवा';

  @override
  String get reorderItemToStart => 'सुरुवातीला हलवा';

  @override
  String get reorderItemUp => 'वर हलवा';

  @override
  String get rowsPerPageTitle => 'प्रति पेज पंक्ती:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => 'शोध';

  @override
  String get selectAllButtonLabel => 'सर्व निवडा';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'एक अायटम निवडला';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount अायटम निवडले';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'कोणतेही आयटम निवडलेले नाहीत';

  @override
  String get showAccountsLabel => 'खाती दर्शवा';

  @override
  String get showMenuTooltip => 'मेनू दाखवा';

  @override
  String get signedInLabel => 'साइन इन केले आहे';

  @override
  String get tabLabelRaw => '\$tabCount पैकी \$tabIndex टॅब';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'तास निवडा';

  @override
  String get timePickerMinuteModeAnnouncement => 'मिनिटे निवडा';

  @override
  String get viewLicensesButtonLabel => 'परवाने पाहा';
}

/// The translations for Malay (`ms`).
class MaterialLocalizationMs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Malay.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationMs({
    String localeName = 'ms',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Perihal \$applicationName';

  @override
  String get alertDialogLabel => 'Makluman';

  @override
  String get anteMeridiemAbbreviation => 'PG';

  @override
  String get backButtonTooltip => 'Kembali';

  @override
  String get cancelButtonLabel => 'BATAL';

  @override
  String get closeButtonLabel => 'TUTUP';

  @override
  String get closeButtonTooltip => 'Tutup';

  @override
  String get collapsedIconTapHint => 'Kembangkan';

  @override
  String get continueButtonLabel => 'TERUSKAN';

  @override
  String get copyButtonLabel => 'SALIN';

  @override
  String get cutButtonLabel => 'POTONG';

  @override
  String get deleteButtonTooltip => 'Padam';

  @override
  String get dialogLabel => 'Dialog';

  @override
  String get drawerLabel => 'Menu navigasi';

  @override
  String get expandedIconTapHint => 'Runtuhkan';

  @override
  String get hideAccountsLabel => 'Sembunyikan akaun';

  @override
  String get licensesPageTitle => 'Lesen';

  @override
  String get modalBarrierDismissLabel => 'Tolak';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Bulan depan';

  @override
  String get nextPageTooltip => 'Halaman seterusnya';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Buka menu navigasi';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow dari \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow dari kira-kira \$rowCount';

  @override
  String get pasteButtonLabel => 'TAMPAL';

  @override
  String get popupMenuLabel => 'Menu pop timbul';

  @override
  String get postMeridiemAbbreviation => 'PTG';

  @override
  String get previousMonthTooltip => 'Bulan sebelumnya';

  @override
  String get previousPageTooltip => 'Halaman sebelumnya';

  @override
  String get refreshIndicatorSemanticLabel => 'Muat semula';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 aksara lagi';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount aksara lagi';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Alih ke bawah';

  @override
  String get reorderItemLeft => 'Alih ke kiri';

  @override
  String get reorderItemRight => 'Alih ke kanan';

  @override
  String get reorderItemToEnd => 'Alih ke penghujung';

  @override
  String get reorderItemToStart => 'Alih ke permulaan';

  @override
  String get reorderItemUp => 'Alih ke atas';

  @override
  String get rowsPerPageTitle => 'Baris setiap halaman:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Cari';

  @override
  String get selectAllButtonLabel => 'PILIH SEMUA';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item dipilih';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount item dipilih';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Tiada item dipilih';

  @override
  String get showAccountsLabel => 'Tunjukkan akaun';

  @override
  String get showMenuTooltip => 'Tunjukkan menu';

  @override
  String get signedInLabel => 'Dilog masuk';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex dari \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'Pilih jam';

  @override
  String get timePickerMinuteModeAnnouncement => 'Pilih minit';

  @override
  String get viewLicensesButtonLabel => 'LIHAT LESEN';
}

/// The translations for Burmese (`my`).
class MaterialLocalizationMy extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Burmese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationMy({
    String localeName = 'my',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName အကြောင်း';

  @override
  String get alertDialogLabel => 'သတိပေးချက်';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'နောက်သို့';

  @override
  String get cancelButtonLabel => 'မလုပ်တော့';

  @override
  String get closeButtonLabel => 'ပိတ်ရန်';

  @override
  String get closeButtonTooltip => 'ပိတ်ရန်';

  @override
  String get collapsedIconTapHint => 'ချဲ့ရန်';

  @override
  String get continueButtonLabel => 'ရှေ့ဆက်ရန်';

  @override
  String get copyButtonLabel => 'မိတ္တူကူးရန်';

  @override
  String get cutButtonLabel => 'ဖြတ်ယူရန်';

  @override
  String get deleteButtonTooltip => 'ဖျက်ရန်';

  @override
  String get dialogLabel => 'ဒိုင်ယာလော့';

  @override
  String get drawerLabel => 'လမ်းညွှန် မီနူး';

  @override
  String get expandedIconTapHint => 'လျှော့ပြရန်';

  @override
  String get hideAccountsLabel => 'အကောင့်များကို ဝှက်ရန်';

  @override
  String get licensesPageTitle => 'လိုင်စင်များ';

  @override
  String get modalBarrierDismissLabel => 'ပယ်ရန်';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'နောက်လ';

  @override
  String get nextPageTooltip => 'နောက်စာမျက်နှာ';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'လမ်းညွှန်မီနူးကို ဖွင့်ရန်';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount အနက် \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$rowCount ခန့်မှ \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'ကူးထည့်ရန်';

  @override
  String get popupMenuLabel => 'ပေါ့ပ်အပ်မီနူး';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'ယခင်လ';

  @override
  String get previousPageTooltip => 'ယခင်စာမျက်နှာ';

  @override
  String get refreshIndicatorSemanticLabel => 'ပြန်လည်စတင်ရန်';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'အက္ခရာ ၁ လုံးကျန်သည်';

  @override
  String get remainingTextFieldCharacterCountOther => 'အက္ခရာ \$remainingCount လုံးကျန်သည်';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'အောက်သို့ရွှေ့ရန်';

  @override
  String get reorderItemLeft => 'ဘယ်ဘက်သို့ရွှေ့ရန်';

  @override
  String get reorderItemRight => 'ညာဘက်သို့ရွှေ့ရန်';

  @override
  String get reorderItemToEnd => 'အဆုံးသို့ ‌ရွှေ့ရန်';

  @override
  String get reorderItemToStart => 'အစသို့ ရွှေ့ရန်';

  @override
  String get reorderItemUp => 'အပေါ်သို့ ရွှေ့ရန်';

  @override
  String get rowsPerPageTitle => 'စာတစ်မျက်နှာပါ လိုင်းအရေအတွက်−';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'ရှာဖွေရန်';

  @override
  String get selectAllButtonLabel => 'အားလုံး ရွေးရန်';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '၁ ခု ရွေးထားသည်';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount ခု ရွေးထားသည်';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'အကောင့်များကို ပြရန်';

  @override
  String get showMenuTooltip => 'မီနူး ပြရန်';

  @override
  String get signedInLabel => 'လက်မှတ်ထိုး ဝင်ထားသည်';

  @override
  String get tabLabelRaw => 'တဘ် \$tabCount အနက် \$tabIndex ခု';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'နာရီကို ရွေးပါ';

  @override
  String get timePickerMinuteModeAnnouncement => 'မိနစ်ကို ရွေးပါ';

  @override
  String get viewLicensesButtonLabel => 'လိုင်စင်များကို ကြည့်ရန်';
}

/// The translations for Norwegian Bokmål (`nb`).
class MaterialLocalizationNb extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Norwegian Bokmål.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationNb({
    String localeName = 'nb',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Om \$applicationName';

  @override
  String get alertDialogLabel => 'Varsel';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Tilbake';

  @override
  String get cancelButtonLabel => 'AVBRYT';

  @override
  String get closeButtonLabel => 'LUKK';

  @override
  String get closeButtonTooltip => 'Lukk';

  @override
  String get collapsedIconTapHint => 'Vis';

  @override
  String get continueButtonLabel => 'FORTSETT';

  @override
  String get copyButtonLabel => 'KOPIÉR';

  @override
  String get cutButtonLabel => 'KLIPP UT';

  @override
  String get deleteButtonTooltip => 'Slett';

  @override
  String get dialogLabel => 'Dialogboks';

  @override
  String get drawerLabel => 'Navigasjonsmeny';

  @override
  String get expandedIconTapHint => 'Skjul';

  @override
  String get hideAccountsLabel => 'Skjul kontoer';

  @override
  String get licensesPageTitle => 'Lisenser';

  @override
  String get modalBarrierDismissLabel => 'Avvis';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Neste måned';

  @override
  String get nextPageTooltip => 'Neste side';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Åpne navigasjonsmenyen';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow av \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow av omtrent \$rowCount';

  @override
  String get pasteButtonLabel => 'LIM INN';

  @override
  String get popupMenuLabel => 'Forgrunnsmeny';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Forrige måned';

  @override
  String get previousPageTooltip => 'Forrige side';

  @override
  String get refreshIndicatorSemanticLabel => 'Laster inn på nytt';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 tegn gjenstår';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount tegn gjenstår';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Flytt ned';

  @override
  String get reorderItemLeft => 'Flytt til venstre';

  @override
  String get reorderItemRight => 'Flytt til høyre';

  @override
  String get reorderItemToEnd => 'Flytt til slutten';

  @override
  String get reorderItemToStart => 'Flytt til starten';

  @override
  String get reorderItemUp => 'Flytt opp';

  @override
  String get rowsPerPageTitle => 'Rader per side:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Søk';

  @override
  String get selectAllButtonLabel => 'VELG ALLE';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 element er valgt';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount elementer er valgt';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Vis kontoer';

  @override
  String get showMenuTooltip => 'Vis meny';

  @override
  String get signedInLabel => 'Pålogget';

  @override
  String get tabLabelRaw => 'Fane \$tabIndex av \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Angi timer';

  @override
  String get timePickerMinuteModeAnnouncement => 'Angi minutter';

  @override
  String get viewLicensesButtonLabel => 'SE LISENSER';
}

/// The translations for Nepali (`ne`).
class MaterialLocalizationNe extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Nepali.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationNe({
    String localeName = 'ne',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName बारे';

  @override
  String get alertDialogLabel => 'अलर्ट';

  @override
  String get anteMeridiemAbbreviation => 'पूर्वाह्न';

  @override
  String get backButtonTooltip => 'पछाडि जानुहोस्';

  @override
  String get cancelButtonLabel => 'रद्द गर्नुहोस्';

  @override
  String get closeButtonLabel => 'बन्द गर्नुहोस्';

  @override
  String get closeButtonTooltip => 'बन्द गर्नुहोस्';

  @override
  String get collapsedIconTapHint => 'विस्तार गर्नुहोस्';

  @override
  String get continueButtonLabel => 'जारी राख्नुहोस्';

  @override
  String get copyButtonLabel => 'प्रतिलिपि गर्नुहोस्';

  @override
  String get cutButtonLabel => 'काट्नुहोस्';

  @override
  String get deleteButtonTooltip => 'मेट्नुहोस्';

  @override
  String get dialogLabel => 'संवाद';

  @override
  String get drawerLabel => 'नेभिगेसन मेनु';

  @override
  String get expandedIconTapHint => 'संक्षिप्त गर्नुहोस्';

  @override
  String get hideAccountsLabel => 'खाताहरू लुकाउनुहोस्';

  @override
  String get licensesPageTitle => 'इजाजतपत्रहरू';

  @override
  String get modalBarrierDismissLabel => 'खारेज गर्नुहोस्';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'अर्को महिना';

  @override
  String get nextPageTooltip => 'अर्को पृष्ठ';

  @override
  String get okButtonLabel => 'ठिक छ';

  @override
  String get openAppDrawerTooltip => 'नेभिगेसन मेनु खोल्नुहोस्';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount मध्ये \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'लगभग \$rowCount को \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'टाँस्नुहोस्';

  @override
  String get popupMenuLabel => 'पपअप मेनु';

  @override
  String get postMeridiemAbbreviation => 'अपराह्न';

  @override
  String get previousMonthTooltip => 'अघिल्लो महिना';

  @override
  String get previousPageTooltip => 'अघिल्लो पृष्ठ';

  @override
  String get refreshIndicatorSemanticLabel => 'पुनः ताजा गर्नुहोस्';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '१ वर्ण बाँकी';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount वर्णहरू बाँकी';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'तल सार्नुहोस्';

  @override
  String get reorderItemLeft => 'बायाँ सार्नुहोस्';

  @override
  String get reorderItemRight => 'दायाँ सार्नुहोस्';

  @override
  String get reorderItemToEnd => 'अन्त्यमा जानुहोस्';

  @override
  String get reorderItemToStart => 'सुरुमा सार्नुहोस्';

  @override
  String get reorderItemUp => 'माथि सार्नुहोस्';

  @override
  String get rowsPerPageTitle => 'प्रत्येक पृष्ठमा रहेका पङ्क्तिहरूको सङ्ख्या:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'खोज्नुहोस्';

  @override
  String get selectAllButtonLabel => 'सबै चयन गर्नुहोस्';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '१ वस्तु चयन गरियो';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount वस्तुहरू चयन गरिए';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'खाताहरू देखाउनुहोस्';

  @override
  String get showMenuTooltip => 'मेनु देखाउनुहोस्';

  @override
  String get signedInLabel => 'साइन इन गरियो';

  @override
  String get tabLabelRaw => '\$tabCount मध्ये \$tabIndex ट्याब';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'घन्टा चयन गर्नुहोस्';

  @override
  String get timePickerMinuteModeAnnouncement => 'मिनेट चयन गर्नुहोस्';

  @override
  String get viewLicensesButtonLabel => 'इजाजतपत्रहरू हेर्नुहोस्';
}

/// The translations for Dutch Flemish (`nl`).
class MaterialLocalizationNl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Dutch Flemish.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationNl({
    String localeName = 'nl',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Over \$applicationName';

  @override
  String get alertDialogLabel => 'Melding';

  @override
  String get anteMeridiemAbbreviation => 'am';

  @override
  String get backButtonTooltip => 'Terug';

  @override
  String get cancelButtonLabel => 'ANNULEREN';

  @override
  String get closeButtonLabel => 'SLUITEN';

  @override
  String get closeButtonTooltip => 'Sluiten';

  @override
  String get collapsedIconTapHint => 'Uitvouwen';

  @override
  String get continueButtonLabel => 'DOORGAAN';

  @override
  String get copyButtonLabel => 'KOPIËREN';

  @override
  String get cutButtonLabel => 'KNIPPEN';

  @override
  String get deleteButtonTooltip => 'Verwijderen';

  @override
  String get dialogLabel => 'Dialoogvenster';

  @override
  String get drawerLabel => 'Navigatiemenu';

  @override
  String get expandedIconTapHint => 'Samenvouwen';

  @override
  String get hideAccountsLabel => 'Accounts verbergen';

  @override
  String get licensesPageTitle => 'Licenties';

  @override
  String get modalBarrierDismissLabel => 'Sluiten';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Volgende maand';

  @override
  String get nextPageTooltip => 'Volgende pagina';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Navigatiemenu openen';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow van \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow van ongeveer \$rowCount';

  @override
  String get pasteButtonLabel => 'PLAKKEN';

  @override
  String get popupMenuLabel => 'Pop-upmenu';

  @override
  String get postMeridiemAbbreviation => 'pm';

  @override
  String get previousMonthTooltip => 'Vorige maand';

  @override
  String get previousPageTooltip => 'Vorige pagina';

  @override
  String get refreshIndicatorSemanticLabel => 'Vernieuwen';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 teken resterend';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount tekens resterend';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Omlaag verplaatsen';

  @override
  String get reorderItemLeft => 'Naar links verplaatsen';

  @override
  String get reorderItemRight => 'Naar rechts verplaatsen';

  @override
  String get reorderItemToEnd => 'Naar het einde verplaatsen';

  @override
  String get reorderItemToStart => 'Naar het begin verplaatsen';

  @override
  String get reorderItemUp => 'Omhoog verplaatsen';

  @override
  String get rowsPerPageTitle => 'Rijen per pagina:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Zoeken';

  @override
  String get selectAllButtonLabel => 'ALLES SELECTEREN';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item geselecteerd';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount items geselecteerd';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Accounts weergeven';

  @override
  String get showMenuTooltip => 'Menu weergeven';

  @override
  String get signedInLabel => 'Ingelogd';

  @override
  String get tabLabelRaw => 'Tabblad \$tabIndex van \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Uren selecteren';

  @override
  String get timePickerMinuteModeAnnouncement => 'Minuten selecteren';

  @override
  String get viewLicensesButtonLabel => 'LICENTIES BEKIJKEN';
}

/// The translations for Oriya (`or`).
class MaterialLocalizationOr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Oriya.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationOr({
    String localeName = 'or',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName ବିଷୟରେ';

  @override
  String get alertDialogLabel => 'ଆଲର୍ଟ';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'ପଛକୁ ଫେରନ୍ତୁ';

  @override
  String get cancelButtonLabel => 'ବାତିଲ୍ କରନ୍ତୁ';

  @override
  String get closeButtonLabel => 'ବନ୍ଦ କରନ୍ତୁ';

  @override
  String get closeButtonTooltip => 'ବନ୍ଦ କରନ୍ତୁ';

  @override
  String get collapsedIconTapHint => 'ପ୍ରସାରିତ କରନ୍ତୁ';

  @override
  String get continueButtonLabel => 'ଜାରି ରଖନ୍ତୁ';

  @override
  String get copyButtonLabel => 'କପି କରନ୍ତୁ';

  @override
  String get cutButtonLabel => 'କଟ୍ କରନ୍ତୁ';

  @override
  String get deleteButtonTooltip => 'ଡିଲିଟ୍ କରନ୍ତୁ';

  @override
  String get dialogLabel => 'ଡାୟଲଗ୍';

  @override
  String get drawerLabel => 'ନେଭିଗେସନ୍ ମେନୁ';

  @override
  String get expandedIconTapHint => 'ସଙ୍କୁଚିତ କରନ୍ତୁ';

  @override
  String get hideAccountsLabel => 'ଆକାଉଣ୍ଟଗୁଡ଼ିକୁ ଲୁଚାନ୍ତୁ';

  @override
  String get licensesPageTitle => 'ଲାଇସେନ୍ସଗୁଡ଼କ';

  @override
  String get modalBarrierDismissLabel => 'ଖାରଜ କରନ୍ତୁ';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ପରବର୍ତ୍ତୀ ମାସ';

  @override
  String get nextPageTooltip => 'ପରବର୍ତ୍ତୀ ପେଜ୍';

  @override
  String get okButtonLabel => 'ଠିକ୍ ଅଛି';

  @override
  String get openAppDrawerTooltip => 'ନାଭିଗେସନ୍ ମେନୁ ଖୋଲନ୍ତୁ';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCountର \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'ପାଖାପାଖି \$rowCountର \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'ପେଷ୍ଟ କରନ୍ତୁ';

  @override
  String get popupMenuLabel => 'ପପ୍-ଅପ୍ ମେନୁ';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'ପୂର୍ବ ମାସ';

  @override
  String get previousPageTooltip => 'ପୂର୍ବବର୍ତ୍ତୀ ପେଜ୍';

  @override
  String get refreshIndicatorSemanticLabel => 'ରିଫ୍ରେସ୍ କରନ୍ତୁ';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1ଟି ଅକ୍ଷର ବାକି ଅଛି';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCountଟି ଅକ୍ଷର ବାକି ଅଛି';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'ତଳକୁ ଯାଆନ୍ତୁ';

  @override
  String get reorderItemLeft => 'ବାମକୁ ଯାଆନ୍ତୁ';

  @override
  String get reorderItemRight => 'ଡାହାଣକୁ ଯାଆନ୍ତୁ';

  @override
  String get reorderItemToEnd => 'ଶେଷକୁ ଯାଆନ୍ତୁ';

  @override
  String get reorderItemToStart => 'ଆରମ୍ଭକୁ ଯାଆନ୍ତୁ';

  @override
  String get reorderItemUp => 'ଉପରକୁ ନିଅନ୍ତୁ';

  @override
  String get rowsPerPageTitle => 'ପୃଷ୍ଠା ପିଛା ଧାଡ଼ି:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'ଖୋଜନ୍ତୁ';

  @override
  String get selectAllButtonLabel => 'ସମସ୍ତ ଚୟନ କରନ୍ତୁ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1ଟି ଆଇଟମ୍ ଚୟନ କରାଯାଇଛି';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCountଟି ଆଇଟମ୍ ଚୟନ କରାଯାଇଛି';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'ଆକାଉଣ୍ଟ ଦେଖାନ୍ତୁ';

  @override
  String get showMenuTooltip => 'ମେନୁ ଦେଖାନ୍ତୁ';

  @override
  String get signedInLabel => 'ସାଇନ୍ ଇନ୍ କରାଯାଇଛି';

  @override
  String get tabLabelRaw => '\$tabCountର \$tabIndex ଟାବ୍';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'ଘଣ୍ଟା ଚୟନ କରନ୍ତୁ';

  @override
  String get timePickerMinuteModeAnnouncement => 'ମିନିଟ୍ ଚୟନ କରନ୍ତୁ';

  @override
  String get viewLicensesButtonLabel => 'ଲାଇସେନ୍ସ ଦେଖାନ୍ତୁ';
}

/// The translations for Panjabi Punjabi (`pa`).
class MaterialLocalizationPa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Panjabi Punjabi.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationPa({
    String localeName = 'pa',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName ਬਾਰੇ';

  @override
  String get alertDialogLabel => 'ਸੁਚੇਤਨਾ';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'ਪਿੱਛੇ';

  @override
  String get cancelButtonLabel => 'ਰੱਦ ਕਰੋ';

  @override
  String get closeButtonLabel => 'ਬੰਦ ਕਰੋ';

  @override
  String get closeButtonTooltip => 'ਬੰਦ ਕਰੋ';

  @override
  String get collapsedIconTapHint => 'ਵਿਸਤਾਰ ਕਰੋ';

  @override
  String get continueButtonLabel => 'ਜਾਰੀ ਰੱਖੋ';

  @override
  String get copyButtonLabel => 'ਕਾਪੀ ਕਰੋ';

  @override
  String get cutButtonLabel => 'ਕੱਟ ਕਰੋ';

  @override
  String get deleteButtonTooltip => 'ਮਿਟਾਓ';

  @override
  String get dialogLabel => 'ਵਿੰਡੋ';

  @override
  String get drawerLabel => 'ਨੈਵੀਗੇਸ਼ਨ ਮੀਨੂ';

  @override
  String get expandedIconTapHint => 'ਸਮੇਟੋ';

  @override
  String get hideAccountsLabel => 'ਖਾਤੇ ਲੁਕਾਓ';

  @override
  String get licensesPageTitle => 'ਲਾਇਸੰਸ';

  @override
  String get modalBarrierDismissLabel => 'ਖਾਰਜ ਕਰੋ';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ਅਗਲਾ ਮਹੀਨਾ';

  @override
  String get nextPageTooltip => 'ਅਗਲਾ ਪੰਨਾ';

  @override
  String get okButtonLabel => 'ਠੀਕ ਹੈ';

  @override
  String get openAppDrawerTooltip => 'ਨੈਵੀਗੇਸ਼ਨ ਮੀਨੂ ਖੋਲ੍ਹੋ';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCount ਵਿੱਚੋਂ \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => 'ਲਗਭਗ \$rowCount ਵਿੱਚੋਂ \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'ਪੇਸਟ ਕਰੋ';

  @override
  String get popupMenuLabel => 'ਪੌਪਅੱਪ ਮੀਨੂ';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'ਪਿਛਲਾ ਮਹੀਨਾ';

  @override
  String get previousPageTooltip => 'ਪਿਛਲਾ ਪੰਨਾ';

  @override
  String get refreshIndicatorSemanticLabel => 'ਰਿਫ੍ਰੈਸ਼ ਕਰੋ';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 ਅੱਖਰ-ਚਿੰਨ੍ਹ ਬਾਕੀ';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount ਅੱਖਰ-ਚਿੰਨ੍ਹ ਬਾਕੀ';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'ਹੇਠਾਂ ਲਿਜਾਓ';

  @override
  String get reorderItemLeft => 'ਖੱਬੇ ਲਿਜਾਓ';

  @override
  String get reorderItemRight => 'ਸੱਜੇ ਲਿਜਾਓ';

  @override
  String get reorderItemToEnd => 'ਅੰਤ ਵਿੱਚ ਲਿਜਾਓ';

  @override
  String get reorderItemToStart => 'ਸ਼ੁਰੂ ਵਿੱਚ ਲਿਜਾਓ';

  @override
  String get reorderItemUp => 'ਉੱਪਰ ਲਿਜਾਓ';

  @override
  String get rowsPerPageTitle => 'ਹਰ ਪੰਨੇ \'ਤੇ ਕਤਾਰਾਂ:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'ਖੋਜੋ';

  @override
  String get selectAllButtonLabel => 'ਸਭ ਚੁਣੋ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 ਆਈਟਮ ਚੁਣੀ ਗਈ';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount ਆਈਟਮਾਂ ਚੁਣੀਆਂ ਗਈਆਂ';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'ਖਾਤੇ ਦਿਖਾਓ';

  @override
  String get showMenuTooltip => 'ਮੀਨੂ ਦਿਖਾਓ';

  @override
  String get signedInLabel => 'ਸਾਈਨ-ਇਨ ਕੀਤਾ ਗਿਆ';

  @override
  String get tabLabelRaw => '\$tabCount ਵਿੱਚੋਂ \$tabIndex ਟੈਬ';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'ਘੰਟੇ ਚੁਣੋ';

  @override
  String get timePickerMinuteModeAnnouncement => 'ਮਿੰਟ ਚੁਣੋ';

  @override
  String get viewLicensesButtonLabel => 'ਲਾਇਸੰਸ ਦੇਖੋ';
}

/// The translations for Polish (`pl`).
class MaterialLocalizationPl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Polish.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationPl({
    String localeName = 'pl',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName – informacje';

  @override
  String get alertDialogLabel => 'Alert';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Wstecz';

  @override
  String get cancelButtonLabel => 'ANULUJ';

  @override
  String get closeButtonLabel => 'ZAMKNIJ';

  @override
  String get closeButtonTooltip => 'Zamknij';

  @override
  String get collapsedIconTapHint => 'Rozwiń';

  @override
  String get continueButtonLabel => 'DALEJ';

  @override
  String get copyButtonLabel => 'KOPIUJ';

  @override
  String get cutButtonLabel => 'WYTNIJ';

  @override
  String get deleteButtonTooltip => 'Usuń';

  @override
  String get dialogLabel => 'Okno dialogowe';

  @override
  String get drawerLabel => 'Menu nawigacyjne';

  @override
  String get expandedIconTapHint => 'Zwiń';

  @override
  String get hideAccountsLabel => 'Ukryj konta';

  @override
  String get licensesPageTitle => 'Licencje';

  @override
  String get modalBarrierDismissLabel => 'Zamknij';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Następny miesiąc';

  @override
  String get nextPageTooltip => 'Następna strona';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Otwórz menu nawigacyjne';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow z \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow z około \$rowCount';

  @override
  String get pasteButtonLabel => 'WKLEJ';

  @override
  String get popupMenuLabel => 'Menu kontekstowe';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Poprzedni miesiąc';

  @override
  String get previousPageTooltip => 'Poprzednia strona';

  @override
  String get refreshIndicatorSemanticLabel => 'Odśwież';

  @override
  String get remainingTextFieldCharacterCountFew => 'Pozostały \$remainingCount znaki';

  @override
  String get remainingTextFieldCharacterCountMany => 'Pozostało \$remainingCount znaków';

  @override
  String get remainingTextFieldCharacterCountOne => 'Jeszcze 1 znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Pozostało \$remainingCount znaków';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Przenieś w dół';

  @override
  String get reorderItemLeft => 'Przenieś w lewo';

  @override
  String get reorderItemRight => 'Przenieś w prawo';

  @override
  String get reorderItemToEnd => 'Przenieś na koniec';

  @override
  String get reorderItemToStart => 'Przenieś na początek';

  @override
  String get reorderItemUp => 'Przenieś w górę';

  @override
  String get rowsPerPageTitle => 'Wiersze na stronie:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Szukaj';

  @override
  String get selectAllButtonLabel => 'ZAZNACZ WSZYSTKO';

  @override
  String get selectedRowCountTitleFew => '\$selectedRowCount wybrane elementy';

  @override
  String get selectedRowCountTitleMany => '\$selectedRowCount wybranych elementów';

  @override
  String get selectedRowCountTitleOne => '1 wybrany element';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount wybranych elementów';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Pokaż konta';

  @override
  String get showMenuTooltip => 'Pokaż menu';

  @override
  String get signedInLabel => 'Zalogowani użytkownicy';

  @override
  String get tabLabelRaw => 'Karta \$tabIndex z \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Wybierz godziny';

  @override
  String get timePickerMinuteModeAnnouncement => 'Wybierz minuty';

  @override
  String get viewLicensesButtonLabel => 'WYŚWIETL LICENCJE';
}

/// The translations for Pushto Pashto (`ps`).
class MaterialLocalizationPs extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Pushto Pashto.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationPs({
    String localeName = 'ps',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'د \$applicationName په اړه';

  @override
  String get alertDialogLabel => 'خبرتیا';

  @override
  String get anteMeridiemAbbreviation => null;

  @override
  String get backButtonTooltip => 'شاته';

  @override
  String get cancelButtonLabel => 'لغوه کول';

  @override
  String get closeButtonLabel => 'تړل';

  @override
  String get closeButtonTooltip => 'بنده';

  @override
  String get collapsedIconTapHint => 'TBD';

  @override
  String get continueButtonLabel => 'منځپانګې';

  @override
  String get copyButtonLabel => 'کاپی';

  @override
  String get cutButtonLabel => 'کم کړئ';

  @override
  String get deleteButtonTooltip => '';

  @override
  String get dialogLabel => 'خبرې اترې';

  @override
  String get drawerLabel => 'د نیویگیشن مینو';

  @override
  String get expandedIconTapHint => 'TBD';

  @override
  String get hideAccountsLabel => 'حسابونه پټ کړئ';

  @override
  String get licensesPageTitle => 'جوازونه';

  @override
  String get modalBarrierDismissLabel => 'رد کړه';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'بله میاشت';

  @override
  String get nextPageTooltip => 'بله پاڼه';

  @override
  String get okButtonLabel => 'سمه ده';

  @override
  String get openAppDrawerTooltip => 'د پرانیستی نیینګ مینو';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow د \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow څخه \$rowCount د';

  @override
  String get pasteButtonLabel => 'پیټ کړئ';

  @override
  String get popupMenuLabel => 'د پاپ اپ مینو';

  @override
  String get postMeridiemAbbreviation => null;

  @override
  String get previousMonthTooltip => 'تیره میاشت';

  @override
  String get previousPageTooltip => 'مخکینی مخ';

  @override
  String get refreshIndicatorSemanticLabel => 'TBD';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'TBD';

  @override
  String get remainingTextFieldCharacterCountOther => 'TBD';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'TBD';

  @override
  String get reorderItemLeft => 'TBD';

  @override
  String get reorderItemRight => 'TBD';

  @override
  String get reorderItemToEnd => 'TBD';

  @override
  String get reorderItemToStart => 'TBD';

  @override
  String get reorderItemUp => 'TBD';

  @override
  String get rowsPerPageTitle => 'د هرې پاڼې پاڼې:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'لټون';

  @override
  String get selectAllButtonLabel => 'غوره کړئ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => null;

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount توکي غوره شوي';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'حسابونه ښکاره کړئ';

  @override
  String get showMenuTooltip => 'غورنۍ ښودل';

  @override
  String get signedInLabel => 'ننوتل';

  @override
  String get tabLabelRaw => '\$tabIndex د \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'وختونه وټاکئ';

  @override
  String get timePickerMinuteModeAnnouncement => 'منې غوره کړئ';

  @override
  String get viewLicensesButtonLabel => 'لیدلس وګورئ';
}

/// The translations for Portuguese (`pt`).
class MaterialLocalizationPt extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Portuguese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationPt({
    String localeName = 'pt',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Sobre o app \$applicationName';

  @override
  String get alertDialogLabel => 'Alerta';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Voltar';

  @override
  String get cancelButtonLabel => 'CANCELAR';

  @override
  String get closeButtonLabel => 'FECHAR';

  @override
  String get closeButtonTooltip => 'Fechar';

  @override
  String get collapsedIconTapHint => 'Expandir';

  @override
  String get continueButtonLabel => 'CONTINUAR';

  @override
  String get copyButtonLabel => 'COPIAR';

  @override
  String get cutButtonLabel => 'RECORTAR';

  @override
  String get deleteButtonTooltip => 'Excluir';

  @override
  String get dialogLabel => 'Caixa de diálogo';

  @override
  String get drawerLabel => 'Menu de navegação';

  @override
  String get expandedIconTapHint => 'Recolher';

  @override
  String get hideAccountsLabel => 'Ocultar contas';

  @override
  String get licensesPageTitle => 'Licenças';

  @override
  String get modalBarrierDismissLabel => 'Dispensar';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Próximo mês';

  @override
  String get nextPageTooltip => 'Próxima página';

  @override
  String get okButtonLabel => 'Ok';

  @override
  String get openAppDrawerTooltip => 'Abrir menu de navegação';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow de aproximadamente \$rowCount';

  @override
  String get pasteButtonLabel => 'COLAR';

  @override
  String get popupMenuLabel => 'Menu pop-up';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Mês anterior';

  @override
  String get previousPageTooltip => 'Página anterior';

  @override
  String get refreshIndicatorSemanticLabel => 'Atualizar';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 caractere restante';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount caracteres restantes';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Mover para baixo';

  @override
  String get reorderItemLeft => 'Mover para a esquerda';

  @override
  String get reorderItemRight => 'Mover para a direita';

  @override
  String get reorderItemToEnd => 'Mover para o final';

  @override
  String get reorderItemToStart => 'Mover para o início';

  @override
  String get reorderItemUp => 'Mover para cima';

  @override
  String get rowsPerPageTitle => 'Linhas por página:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Pesquisa';

  @override
  String get selectAllButtonLabel => 'SELECIONAR TUDO';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item selecionado';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount itens selecionados';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Mostrar contas';

  @override
  String get showMenuTooltip => 'Mostrar menu';

  @override
  String get signedInLabel => 'Conectado a';

  @override
  String get tabLabelRaw => 'Guia \$tabIndex de \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Selecione as horas';

  @override
  String get timePickerMinuteModeAnnouncement => 'Selecione os minutos';

  @override
  String get viewLicensesButtonLabel => 'VER LICENÇAS';
}

/// The translations for Portuguese, as used in Portugal (`pt_PT`).
class MaterialLocalizationPtPt extends MaterialLocalizationPt {
  /// Create an instance of the translation bundle for Portuguese, as used in Portugal.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationPtPt({
    String localeName = 'pt_PT',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get tabLabelRaw => 'Separador \$tabIndex de \$tabCount';

  @override
  String get signedInLabel => 'Com sessão iniciada';

  @override
  String get timePickerMinuteModeAnnouncement => 'Selecionar minutos';

  @override
  String get timePickerHourModeAnnouncement => 'Selecionar horas';

  @override
  String get deleteButtonTooltip => 'Eliminar';

  @override
  String get nextMonthTooltip => 'Mês seguinte';

  @override
  String get nextPageTooltip => 'Página seguinte';

  @override
  String get aboutListTileTitleRaw => 'Acerca de \$applicationName';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow a \$lastRow de \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow a \$lastRow de cerca de \$rowCount';

  @override
  String get cutButtonLabel => 'CORTAR';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get modalBarrierDismissLabel => 'Ignorar';

  @override
  String get searchFieldLabel => 'Pesquisar';

  @override
  String get reorderItemToEnd => 'Mover para o fim';

  @override
  String get expandedIconTapHint => 'Reduzir';

  @override
  String get remainingTextFieldCharacterCountOne => 'Resta 1 caráter';

  @override
  String get remainingTextFieldCharacterCountOther => 'Restam \$remainingCount carateres';
}

/// The translations for Romanian Moldavian Moldovan (`ro`).
class MaterialLocalizationRo extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Romanian Moldavian Moldovan.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationRo({
    String localeName = 'ro',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Despre \$applicationName';

  @override
  String get alertDialogLabel => 'Alertă';

  @override
  String get anteMeridiemAbbreviation => 'a.m.';

  @override
  String get backButtonTooltip => 'Înapoi';

  @override
  String get cancelButtonLabel => 'ANULAȚI';

  @override
  String get closeButtonLabel => 'ÎNCHIDEȚI';

  @override
  String get closeButtonTooltip => 'Închideți';

  @override
  String get collapsedIconTapHint => 'Extindeți';

  @override
  String get continueButtonLabel => 'CONTINUAȚI';

  @override
  String get copyButtonLabel => 'COPIAȚI';

  @override
  String get cutButtonLabel => 'DECUPAȚI';

  @override
  String get deleteButtonTooltip => 'Ștergeți';

  @override
  String get dialogLabel => 'Casetă de dialog';

  @override
  String get drawerLabel => 'Meniu de navigare';

  @override
  String get expandedIconTapHint => 'Restrângeți';

  @override
  String get hideAccountsLabel => 'Ascundeți conturile';

  @override
  String get licensesPageTitle => 'Licențe';

  @override
  String get modalBarrierDismissLabel => 'Închideți';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Luna viitoare';

  @override
  String get nextPageTooltip => 'Pagina următoare';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Deschideți meniul de navigare';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow din \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow din aproximativ \$rowCount';

  @override
  String get pasteButtonLabel => 'INSERAȚI';

  @override
  String get popupMenuLabel => 'Meniu pop-up';

  @override
  String get postMeridiemAbbreviation => 'p.m.';

  @override
  String get previousMonthTooltip => 'Luna trecută';

  @override
  String get previousPageTooltip => 'Pagina anterioară';

  @override
  String get refreshIndicatorSemanticLabel => 'Actualizați';

  @override
  String get remainingTextFieldCharacterCountFew => '\$remainingCount caractere rămase';

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'un caracter rămas';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount de caractere rămase';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Mutați în jos';

  @override
  String get reorderItemLeft => 'Mutați la stânga';

  @override
  String get reorderItemRight => 'Mutați la dreapta';

  @override
  String get reorderItemToEnd => 'Mutați la sfârșit';

  @override
  String get reorderItemToStart => 'Mutați la început';

  @override
  String get reorderItemUp => 'Mutați în sus';

  @override
  String get rowsPerPageTitle => 'Rânduri pe pagină:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Căutați';

  @override
  String get selectAllButtonLabel => 'SELECTAȚI TOATE';

  @override
  String get selectedRowCountTitleFew => '\$selectedRowCount articole selectate';

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Un articol selectat';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount de articole selectate';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Nu există elemente selectate';

  @override
  String get showAccountsLabel => 'Afișați conturile';

  @override
  String get showMenuTooltip => 'Afișați meniul';

  @override
  String get signedInLabel => 'V-ați conectat';

  @override
  String get tabLabelRaw => 'Fila \$tabIndex din \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Selectați orele';

  @override
  String get timePickerMinuteModeAnnouncement => 'Selectați minutele';

  @override
  String get viewLicensesButtonLabel => 'VEDEȚI LICENȚELE';
}

/// The translations for Russian (`ru`).
class MaterialLocalizationRu extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Russian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationRu({
    String localeName = 'ru',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName: сведения';

  @override
  String get alertDialogLabel => 'Оповещение';

  @override
  String get anteMeridiemAbbreviation => 'АМ';

  @override
  String get backButtonTooltip => 'Назад';

  @override
  String get cancelButtonLabel => 'ОТМЕНА';

  @override
  String get closeButtonLabel => 'ЗАКРЫТЬ';

  @override
  String get closeButtonTooltip => 'Закрыть';

  @override
  String get collapsedIconTapHint => 'Развернуть';

  @override
  String get continueButtonLabel => 'ПРОДОЛЖИТЬ';

  @override
  String get copyButtonLabel => 'КОПИРОВАТЬ';

  @override
  String get cutButtonLabel => 'ВЫРЕЗАТЬ';

  @override
  String get deleteButtonTooltip => 'Удалить';

  @override
  String get dialogLabel => 'Диалоговое окно';

  @override
  String get drawerLabel => 'Меню навигации';

  @override
  String get expandedIconTapHint => 'Свернуть';

  @override
  String get hideAccountsLabel => 'Скрыть аккаунты';

  @override
  String get licensesPageTitle => 'Лицензии';

  @override
  String get modalBarrierDismissLabel => 'Закрыть';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Следующий месяц';

  @override
  String get nextPageTooltip => 'Следующая страница';

  @override
  String get okButtonLabel => 'ОК';

  @override
  String get openAppDrawerTooltip => 'Открыть меню навигации';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow из \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow из примерно \$rowCount';

  @override
  String get pasteButtonLabel => 'ВСТАВИТЬ';

  @override
  String get popupMenuLabel => 'Всплывающее меню';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Предыдущий месяц';

  @override
  String get previousPageTooltip => 'Предыдущая страница';

  @override
  String get refreshIndicatorSemanticLabel => 'Обновление';

  @override
  String get remainingTextFieldCharacterCountFew => 'Осталось \$remainingCount символа';

  @override
  String get remainingTextFieldCharacterCountMany => 'Осталось \$remainingCount символов';

  @override
  String get remainingTextFieldCharacterCountOne => 'Остался 1 символ';

  @override
  String get remainingTextFieldCharacterCountOther => 'Осталось \$remainingCount символа';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Переместить вниз';

  @override
  String get reorderItemLeft => 'Переместить влево';

  @override
  String get reorderItemRight => 'Переместить вправо';

  @override
  String get reorderItemToEnd => 'Переместить в конец';

  @override
  String get reorderItemToStart => 'Переместить в начало';

  @override
  String get reorderItemUp => 'Переместить вверх';

  @override
  String get rowsPerPageTitle => 'Строк на странице:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Поиск';

  @override
  String get selectAllButtonLabel => 'ВЫБРАТЬ ВСЕ';

  @override
  String get selectedRowCountTitleFew => 'Выбрано \$selectedRowCount объекта';

  @override
  String get selectedRowCountTitleMany => 'Выбрано \$selectedRowCount объектов';

  @override
  String get selectedRowCountTitleOne => 'Выбран 1 объект';

  @override
  String get selectedRowCountTitleOther => 'Выбрано \$selectedRowCount объекта';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Строки не выбраны';

  @override
  String get showAccountsLabel => 'Показать аккаунты';

  @override
  String get showMenuTooltip => 'Показать меню';

  @override
  String get signedInLabel => 'Вход выполнен';

  @override
  String get tabLabelRaw => 'Вкладка \$tabIndex из \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Выберите часы';

  @override
  String get timePickerMinuteModeAnnouncement => 'Выберите минуты';

  @override
  String get viewLicensesButtonLabel => 'ЛИЦЕНЗИИ';
}

/// The translations for Sinhala Sinhalese (`si`).
class MaterialLocalizationSi extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Sinhala Sinhalese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSi({
    String localeName = 'si',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName ගැන';

  @override
  String get alertDialogLabel => 'ඇඟවීම';

  @override
  String get anteMeridiemAbbreviation => 'පෙ.ව.';

  @override
  String get backButtonTooltip => 'ආපසු';

  @override
  String get cancelButtonLabel => 'අවලංගු කරන්න';

  @override
  String get closeButtonLabel => 'වසන්න';

  @override
  String get closeButtonTooltip => 'වසන්න';

  @override
  String get collapsedIconTapHint => 'දිග හරින්න';

  @override
  String get continueButtonLabel => 'ඉදිරියට';

  @override
  String get copyButtonLabel => 'පිටපත් කරන්න';

  @override
  String get cutButtonLabel => 'කපන්න';

  @override
  String get deleteButtonTooltip => 'මකන්න';

  @override
  String get dialogLabel => 'සංවාදය';

  @override
  String get drawerLabel => 'සංචාලන මෙනුව';

  @override
  String get expandedIconTapHint => 'හකුළන්න';

  @override
  String get hideAccountsLabel => 'ගිණුම් සඟවන්න';

  @override
  String get licensesPageTitle => 'බලපත්‍ර';

  @override
  String get modalBarrierDismissLabel => 'ඉවත ලන්න';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'ඊළඟ මාසය';

  @override
  String get nextPageTooltip => 'ඊළඟ පිටුව';

  @override
  String get okButtonLabel => 'හරි';

  @override
  String get openAppDrawerTooltip => 'සංචාලන මෙනුව විවෘත කරන්න';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCountන් \$firstRow–\$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$rowCountකින් පමණ \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'අලවන්න';

  @override
  String get popupMenuLabel => 'උත්පතන මෙනුව';

  @override
  String get postMeridiemAbbreviation => 'ප.ව.';

  @override
  String get previousMonthTooltip => 'පෙර මාසය';

  @override
  String get previousPageTooltip => 'පෙර පිටුව';

  @override
  String get refreshIndicatorSemanticLabel => 'නැවුම් කරන්න';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'අනුලකුණු 1ක් ඉතිරිය';

  @override
  String get remainingTextFieldCharacterCountOther => 'අනුලකුණු \$remainingCountක් ඉතිරිය';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'පහළට ගෙන යන්න';

  @override
  String get reorderItemLeft => 'වමට ගෙන යන්න';

  @override
  String get reorderItemRight => 'දකුණට ගෙන යන්න';

  @override
  String get reorderItemToEnd => 'අවසානයට යන්න';

  @override
  String get reorderItemToStart => 'ආරම්භය වෙත යන්න';

  @override
  String get reorderItemUp => 'ඉහළට ගෙන යන්න';

  @override
  String get rowsPerPageTitle => 'පිටුවකට පේළි:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'සෙවීම';

  @override
  String get selectAllButtonLabel => 'සියල්ල තෝරන්න';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'අයිතම 1ක් තෝරන ලදී';

  @override
  String get selectedRowCountTitleOther => 'අයිතම \$selectedRowCountක් තෝරන ලදී';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'ගිණුම් පෙන්වන්න';

  @override
  String get showMenuTooltip => 'මෙනුව පෙන්වන්න';

  @override
  String get signedInLabel => 'පුරන ලදී';

  @override
  String get tabLabelRaw => 'ටැබ \$tabIndexකින් \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'පැය ගණන තෝරන්න';

  @override
  String get timePickerMinuteModeAnnouncement => 'මිනිත්තු ගණන තෝරන්න';

  @override
  String get viewLicensesButtonLabel => 'බලපත්‍ර බලන්න';
}

/// The translations for Slovak (`sk`).
class MaterialLocalizationSk extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Slovak.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSk({
    String localeName = 'sk',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName – informácie';

  @override
  String get alertDialogLabel => 'Upozornenie';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Späť';

  @override
  String get cancelButtonLabel => 'ZRUŠIŤ';

  @override
  String get closeButtonLabel => 'ZAVRIEŤ';

  @override
  String get closeButtonTooltip => 'Zavrieť';

  @override
  String get collapsedIconTapHint => 'Rozbaliť';

  @override
  String get continueButtonLabel => 'POKRAČOVAŤ';

  @override
  String get copyButtonLabel => 'KOPÍROVAŤ';

  @override
  String get cutButtonLabel => 'VYSTRIHNÚŤ';

  @override
  String get deleteButtonTooltip => 'Odstrániť';

  @override
  String get dialogLabel => 'Dialógové okno';

  @override
  String get drawerLabel => 'Navigačná ponuka';

  @override
  String get expandedIconTapHint => 'Zbaliť';

  @override
  String get hideAccountsLabel => 'Skryť účty';

  @override
  String get licensesPageTitle => 'Licencie';

  @override
  String get modalBarrierDismissLabel => 'Odmietnuť';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Budúci mesiac';

  @override
  String get nextPageTooltip => 'Ďalšia strana';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Otvoriť navigačnú ponuku';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow z \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow z približne \$rowCount';

  @override
  String get pasteButtonLabel => 'PRILEPIŤ';

  @override
  String get popupMenuLabel => 'Kontextová ponuka';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Predošlý mesiac';

  @override
  String get previousPageTooltip => 'Predchádzajúca stránka';

  @override
  String get refreshIndicatorSemanticLabel => 'Obnoviť';

  @override
  String get remainingTextFieldCharacterCountFew => 'Zostávajú \$remainingCount znaky';

  @override
  String get remainingTextFieldCharacterCountMany => '\$remainingCount characters remaining';

  @override
  String get remainingTextFieldCharacterCountOne => 'Zostáva 1 znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Zostáva \$remainingCount znakov';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Presunúť nadol';

  @override
  String get reorderItemLeft => 'Presunúť doľava';

  @override
  String get reorderItemRight => 'Presunúť doprava';

  @override
  String get reorderItemToEnd => 'Presunúť na koniec';

  @override
  String get reorderItemToStart => 'Presunúť na začiatok';

  @override
  String get reorderItemUp => 'Presunúť nahor';

  @override
  String get rowsPerPageTitle => 'Počet riadkov na stránku:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Hľadať';

  @override
  String get selectAllButtonLabel => 'VYBRAŤ VŠETKO';

  @override
  String get selectedRowCountTitleFew => '\$selectedRowCount vybraté položky';

  @override
  String get selectedRowCountTitleMany => '\$selectedRowCount items selected';

  @override
  String get selectedRowCountTitleOne => '1 vybratá položka';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount vybratých položiek';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Zobraziť účty';

  @override
  String get showMenuTooltip => 'Zobraziť ponuku';

  @override
  String get signedInLabel => 'Prihlásili ste sa';

  @override
  String get tabLabelRaw => 'Karta \$tabIndex z \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Vybrať hodiny';

  @override
  String get timePickerMinuteModeAnnouncement => 'Vybrať minúty';

  @override
  String get viewLicensesButtonLabel => 'ZOBRAZIŤ LICENCIE';
}

/// The translations for Slovenian (`sl`).
class MaterialLocalizationSl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Slovenian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSl({
    String localeName = 'sl',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'O aplikaciji \$applicationName';

  @override
  String get alertDialogLabel => 'Opozorilo';

  @override
  String get anteMeridiemAbbreviation => 'DOP.';

  @override
  String get backButtonTooltip => 'Nazaj';

  @override
  String get cancelButtonLabel => 'PREKLIČI';

  @override
  String get closeButtonLabel => 'ZAPRI';

  @override
  String get closeButtonTooltip => 'Zapiranje';

  @override
  String get collapsedIconTapHint => 'Razširiti';

  @override
  String get continueButtonLabel => 'NAPREJ';

  @override
  String get copyButtonLabel => 'KOPIRAJ';

  @override
  String get cutButtonLabel => 'IZREŽI';

  @override
  String get deleteButtonTooltip => 'Brisanje';

  @override
  String get dialogLabel => 'Pogovorno okno';

  @override
  String get drawerLabel => 'Meni za krmarjenje';

  @override
  String get expandedIconTapHint => 'Strniti';

  @override
  String get hideAccountsLabel => 'Skrivanje računov';

  @override
  String get licensesPageTitle => 'Licence';

  @override
  String get modalBarrierDismissLabel => 'Opusti';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Naslednji mesec';

  @override
  String get nextPageTooltip => 'Naslednja stran';

  @override
  String get okButtonLabel => 'V REDU';

  @override
  String get openAppDrawerTooltip => 'Odpiranje menija za krmarjenje';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow od \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow od približno \$rowCount';

  @override
  String get pasteButtonLabel => 'PRILEPI';

  @override
  String get popupMenuLabel => 'Pojavni meni';

  @override
  String get postMeridiemAbbreviation => 'POP.';

  @override
  String get previousMonthTooltip => 'Prejšnji mesec';

  @override
  String get previousPageTooltip => 'Prejšnja stran';

  @override
  String get refreshIndicatorSemanticLabel => 'Osveži';

  @override
  String get remainingTextFieldCharacterCountFew => 'Še \$remainingCount znaki';

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Še 1 znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Še \$remainingCount znakov';

  @override
  String get remainingTextFieldCharacterCountTwo => 'Še \$remainingCount znaka';

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Premakni navzdol';

  @override
  String get reorderItemLeft => 'Premakni levo';

  @override
  String get reorderItemRight => 'Premakni desno';

  @override
  String get reorderItemToEnd => 'Premakni na konec';

  @override
  String get reorderItemToStart => 'Premakni na začetek';

  @override
  String get reorderItemUp => 'Premakni navzgor';

  @override
  String get rowsPerPageTitle => 'Vrstice na stran:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Iskanje';

  @override
  String get selectAllButtonLabel => 'IZBERI VSE';

  @override
  String get selectedRowCountTitleFew => 'Izbrani so \$selectedRowCount elementi';

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Izbran je 1 element';

  @override
  String get selectedRowCountTitleOther => 'Izbranih je \$selectedRowCount elementov';

  @override
  String get selectedRowCountTitleTwo => 'Izbrana sta \$selectedRowCount elementa';

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Prikaz računov';

  @override
  String get showMenuTooltip => 'Prikaz menija';

  @override
  String get signedInLabel => 'Prijavljen';

  @override
  String get tabLabelRaw => 'Zavihek \$tabIndex od \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Izberite ure';

  @override
  String get timePickerMinuteModeAnnouncement => 'Izberite minute';

  @override
  String get viewLicensesButtonLabel => 'PRIKAŽI LICENCE';
}

/// The translations for Albanian (`sq`).
class MaterialLocalizationSq extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Albanian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSq({
    String localeName = 'sq',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Rreth \$applicationName';

  @override
  String get alertDialogLabel => 'Sinjalizim';

  @override
  String get anteMeridiemAbbreviation => 'paradite';

  @override
  String get backButtonTooltip => 'Prapa';

  @override
  String get cancelButtonLabel => 'ANULO';

  @override
  String get closeButtonLabel => 'MBYLL';

  @override
  String get closeButtonTooltip => 'Mbyll';

  @override
  String get collapsedIconTapHint => 'Zgjero';

  @override
  String get continueButtonLabel => 'VAZHDO';

  @override
  String get copyButtonLabel => 'KOPJO';

  @override
  String get cutButtonLabel => 'PRIT';

  @override
  String get deleteButtonTooltip => 'Fshi';

  @override
  String get dialogLabel => 'Dialogu';

  @override
  String get drawerLabel => 'Menyja e navigimit';

  @override
  String get expandedIconTapHint => 'Palos';

  @override
  String get hideAccountsLabel => 'Fshih llogaritë';

  @override
  String get licensesPageTitle => 'Licencat';

  @override
  String get modalBarrierDismissLabel => 'Hiq';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Muaji i ardhshëm';

  @override
  String get nextPageTooltip => 'Faqja tjetër';

  @override
  String get okButtonLabel => 'Në rregull';

  @override
  String get openAppDrawerTooltip => 'Hap menynë e navigimit';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow nga \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow nga rreth \$rowCount';

  @override
  String get pasteButtonLabel => 'NGJIT';

  @override
  String get popupMenuLabel => 'Menyja kërcyese';

  @override
  String get postMeridiemAbbreviation => 'pasdite';

  @override
  String get previousMonthTooltip => 'Muaji i mëparshëm';

  @override
  String get previousPageTooltip => 'Faqja e mëparshme';

  @override
  String get refreshIndicatorSemanticLabel => 'Rifresko';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 karakter i mbetur';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount karaktere të mbetura';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Lëvize poshtë';

  @override
  String get reorderItemLeft => 'Lëvize majtas';

  @override
  String get reorderItemRight => 'Lëvize djathtas';

  @override
  String get reorderItemToEnd => 'Lëvize në fund';

  @override
  String get reorderItemToStart => 'Lëvize në fillim';

  @override
  String get reorderItemUp => 'Lëvize lart';

  @override
  String get rowsPerPageTitle => 'Rreshtat për faqe:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Kërko';

  @override
  String get selectAllButtonLabel => 'ZGJIDHI TË GJITHA';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'U zgjodh 1 artikull';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount artikuj u zgjodhën';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Shfaq llogaritë';

  @override
  String get showMenuTooltip => 'Shfaq menynë';

  @override
  String get signedInLabel => 'Je identifikuar';

  @override
  String get tabLabelRaw => 'Skeda \$tabIndex nga \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Zgjidh orët';

  @override
  String get timePickerMinuteModeAnnouncement => 'Zgjidh minutat';

  @override
  String get viewLicensesButtonLabel => 'SHIKO LICENCAT';
}

/// The translations for Serbian (`sr`).
class MaterialLocalizationSr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Serbian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSr({
    String localeName = 'sr',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'О апликацији \$applicationName';

  @override
  String get alertDialogLabel => 'Обавештење';

  @override
  String get anteMeridiemAbbreviation => 'пре подне';

  @override
  String get backButtonTooltip => 'Назад';

  @override
  String get cancelButtonLabel => 'ОТКАЖИ';

  @override
  String get closeButtonLabel => 'ЗАТВОРИ';

  @override
  String get closeButtonTooltip => 'Затворите';

  @override
  String get collapsedIconTapHint => 'Прошири';

  @override
  String get continueButtonLabel => 'НАСТАВИ';

  @override
  String get copyButtonLabel => 'КОПИРАЈ';

  @override
  String get cutButtonLabel => 'ИСЕЦИ';

  @override
  String get deleteButtonTooltip => 'Избришите';

  @override
  String get dialogLabel => 'Дијалог';

  @override
  String get drawerLabel => 'Мени за навигацију';

  @override
  String get expandedIconTapHint => 'Скупи';

  @override
  String get hideAccountsLabel => 'Сакриј налоге';

  @override
  String get licensesPageTitle => 'Лиценце';

  @override
  String get modalBarrierDismissLabel => 'Одбаци';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Следећи месец';

  @override
  String get nextPageTooltip => 'Следећа страница';

  @override
  String get okButtonLabel => 'Потврди';

  @override
  String get openAppDrawerTooltip => 'Отворите мени за навигацију';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow oд \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow oд приближно \$rowCount';

  @override
  String get pasteButtonLabel => 'НАЛЕПИ';

  @override
  String get popupMenuLabel => 'Искачући мени';

  @override
  String get postMeridiemAbbreviation => 'по подне';

  @override
  String get previousMonthTooltip => 'Претходни месец';

  @override
  String get previousPageTooltip => 'Претходна страница';

  @override
  String get refreshIndicatorSemanticLabel => 'Освежи';

  @override
  String get remainingTextFieldCharacterCountFew => 'Преостала су \$remainingCount знака';

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Преостао је 1 знак';

  @override
  String get remainingTextFieldCharacterCountOther => 'Преостало је \$remainingCount знакова';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Померите надоле';

  @override
  String get reorderItemLeft => 'Померите улево';

  @override
  String get reorderItemRight => 'Померите удесно';

  @override
  String get reorderItemToEnd => 'Померите на крај';

  @override
  String get reorderItemToStart => 'Померите на почетак';

  @override
  String get reorderItemUp => 'Померите нагоре';

  @override
  String get rowsPerPageTitle => 'Редова по страници:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Претражите';

  @override
  String get selectAllButtonLabel => 'ИЗАБЕРИ СВЕ';

  @override
  String get selectedRowCountTitleFew => 'Изабране су \$selectedRowCount ставке';

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Изабрана је 1 ставка';

  @override
  String get selectedRowCountTitleOther => 'Изабрано је \$selectedRowCount ставки';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Прикажи налоге';

  @override
  String get showMenuTooltip => 'Прикажи мени';

  @override
  String get signedInLabel => 'Пријављени сте';

  @override
  String get tabLabelRaw => '\$tabIndex. картица од \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Изаберите сате';

  @override
  String get timePickerMinuteModeAnnouncement => 'Изаберите минуте';

  @override
  String get viewLicensesButtonLabel => 'ПРИКАЖИ ЛИЦЕНЦЕ';
}

/// The translations for Serbian, using the Cyrillic script (`sr_Cyrl`).
class MaterialLocalizationSrCyrl extends MaterialLocalizationSr {
  /// Create an instance of the translation bundle for Serbian, using the Cyrillic script.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSrCyrl({
    String localeName = 'sr_Cyrl',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );
}

/// The translations for Serbian, using the Latin script (`sr_Latn`).
class MaterialLocalizationSrLatn extends MaterialLocalizationSr {
  /// Create an instance of the translation bundle for Serbian, using the Latin script.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSrLatn({
    String localeName = 'sr_Latn',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'O aplikaciji \$applicationName';

  @override
  String get alertDialogLabel => 'Obaveštenje';

  @override
  String get anteMeridiemAbbreviation => 'pre podne';

  @override
  String get backButtonTooltip => 'Nazad';

  @override
  String get cancelButtonLabel => 'OTKAŽI';

  @override
  String get closeButtonLabel => 'ZATVORI';

  @override
  String get closeButtonTooltip => 'Zatvorite';

  @override
  String get collapsedIconTapHint => 'Proširi';

  @override
  String get continueButtonLabel => 'NASTAVI';

  @override
  String get copyButtonLabel => 'KOPIRAJ';

  @override
  String get cutButtonLabel => 'ISECI';

  @override
  String get deleteButtonTooltip => 'Izbrišite';

  @override
  String get dialogLabel => 'Dijalog';

  @override
  String get drawerLabel => 'Meni za navigaciju';

  @override
  String get expandedIconTapHint => 'Skupi';

  @override
  String get hideAccountsLabel => 'Sakrij naloge';

  @override
  String get licensesPageTitle => 'Licence';

  @override
  String get modalBarrierDismissLabel => 'Odbaci';

  @override
  String get nextMonthTooltip => 'Sledeći mesec';

  @override
  String get nextPageTooltip => 'Sledeća stranica';

  @override
  String get okButtonLabel => 'Potvrdi';

  @override
  String get openAppDrawerTooltip => 'Otvorite meni za navigaciju';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow – \$lastRow od \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow – \$lastRow od približno \$rowCount';

  @override
  String get pasteButtonLabel => 'NALEPI';

  @override
  String get popupMenuLabel => 'Iskačući meni';

  @override
  String get postMeridiemAbbreviation => 'po podne';

  @override
  String get previousMonthTooltip => 'Prethodni mesec';

  @override
  String get previousPageTooltip => 'Prethodna stranica';

  @override
  String get refreshIndicatorSemanticLabel => 'Osveži';

  @override
  String get remainingTextFieldCharacterCountFew => 'Preostala su \$remainingCount znaka';

  @override
  String get remainingTextFieldCharacterCountOne => 'Preostao je 1 znak';

  @override
  String get remainingTextFieldCharacterCountOther => 'Preostalo je \$remainingCount znakova';

  @override
  String get reorderItemDown => 'Pomerite nadole';

  @override
  String get reorderItemLeft => 'Pomerite ulevo';

  @override
  String get reorderItemRight => 'Pomerite udesno';

  @override
  String get reorderItemToEnd => 'Pomerite na kraj';

  @override
  String get reorderItemToStart => 'Pomerite na početak';

  @override
  String get reorderItemUp => 'Pomerite nagore';

  @override
  String get rowsPerPageTitle => 'Redova po stranici:';

  @override
  String get searchFieldLabel => 'Pretražite';

  @override
  String get selectAllButtonLabel => 'IZABERI SVE';

  @override
  String get selectedRowCountTitleFew => 'Izabrane su \$selectedRowCount stavke';

  @override
  String get selectedRowCountTitleOne => 'Izabrana je 1 stavka';

  @override
  String get selectedRowCountTitleOther => 'Izabrano je \$selectedRowCount stavki';

  @override
  String get showAccountsLabel => 'Prikaži naloge';

  @override
  String get showMenuTooltip => 'Prikaži meni';

  @override
  String get signedInLabel => 'Prijavljeni ste';

  @override
  String get tabLabelRaw => '\$tabIndex. kartica od \$tabCount';

  @override
  String get timePickerHourModeAnnouncement => 'Izaberite sate';

  @override
  String get timePickerMinuteModeAnnouncement => 'Izaberite minute';

  @override
  String get viewLicensesButtonLabel => 'PRIKAŽI LICENCE';
}

/// The translations for Swedish (`sv`).
class MaterialLocalizationSv extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Swedish.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSv({
    String localeName = 'sv',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Om \$applicationName';

  @override
  String get alertDialogLabel => 'Varning';

  @override
  String get anteMeridiemAbbreviation => 'FM';

  @override
  String get backButtonTooltip => 'Tillbaka';

  @override
  String get cancelButtonLabel => 'AVBRYT';

  @override
  String get closeButtonLabel => 'STÄNG';

  @override
  String get closeButtonTooltip => 'Stäng';

  @override
  String get collapsedIconTapHint => 'Utöka';

  @override
  String get continueButtonLabel => 'FORTSÄTT';

  @override
  String get copyButtonLabel => 'KOPIERA';

  @override
  String get cutButtonLabel => 'KLIPP UT';

  @override
  String get deleteButtonTooltip => 'Radera';

  @override
  String get dialogLabel => 'Dialogruta';

  @override
  String get drawerLabel => 'Navigeringsmeny';

  @override
  String get expandedIconTapHint => 'Dölj';

  @override
  String get hideAccountsLabel => 'Dölj konton';

  @override
  String get licensesPageTitle => 'Licenser';

  @override
  String get modalBarrierDismissLabel => 'Stäng';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Nästa månad';

  @override
  String get nextPageTooltip => 'Nästa sida';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Öppna navigeringsmenyn';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow av \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow av ungefär \$rowCount';

  @override
  String get pasteButtonLabel => 'KLISTRA IN';

  @override
  String get popupMenuLabel => 'Popup-meny';

  @override
  String get postMeridiemAbbreviation => 'EM';

  @override
  String get previousMonthTooltip => 'Föregående månad';

  @override
  String get previousPageTooltip => 'Föregående sida';

  @override
  String get refreshIndicatorSemanticLabel => 'Uppdatera';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 tecken kvar';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount tecken kvar';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Flytta nedåt';

  @override
  String get reorderItemLeft => 'Flytta åt vänster';

  @override
  String get reorderItemRight => 'Flytta åt höger';

  @override
  String get reorderItemToEnd => 'Flytta till slutet';

  @override
  String get reorderItemToStart => 'Flytta till början';

  @override
  String get reorderItemUp => 'Flytta uppåt';

  @override
  String get rowsPerPageTitle => 'Rader per sida:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Sök';

  @override
  String get selectAllButtonLabel => 'MARKERA ALLA';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 objekt har markerats';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount objekt har markerats';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Visa konton';

  @override
  String get showMenuTooltip => 'Visa meny';

  @override
  String get signedInLabel => 'Inloggad';

  @override
  String get tabLabelRaw => 'Flik \$tabIndex av \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Välj timmar';

  @override
  String get timePickerMinuteModeAnnouncement => 'Välj minuter';

  @override
  String get viewLicensesButtonLabel => 'VISA LICENSER';
}

/// The translations for Swahili (`sw`).
class MaterialLocalizationSw extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Swahili.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationSw({
    String localeName = 'sw',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Kuhusu \$applicationName';

  @override
  String get alertDialogLabel => 'Arifa';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Rudi Nyuma';

  @override
  String get cancelButtonLabel => 'GHAIRI';

  @override
  String get closeButtonLabel => 'FUNGA';

  @override
  String get closeButtonTooltip => 'Funga';

  @override
  String get collapsedIconTapHint => 'Panua';

  @override
  String get continueButtonLabel => 'ENDELEA';

  @override
  String get copyButtonLabel => 'NAKILI';

  @override
  String get cutButtonLabel => 'KATA';

  @override
  String get deleteButtonTooltip => 'Futa';

  @override
  String get dialogLabel => 'Kidirisha';

  @override
  String get drawerLabel => 'Menyu ya kusogeza';

  @override
  String get expandedIconTapHint => 'Kunja';

  @override
  String get hideAccountsLabel => 'Ficha akaunti';

  @override
  String get licensesPageTitle => 'Leseni';

  @override
  String get modalBarrierDismissLabel => 'Ondoa';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Mwezi ujao';

  @override
  String get nextPageTooltip => 'Ukurasa unaofuata';

  @override
  String get okButtonLabel => 'Sawa';

  @override
  String get openAppDrawerTooltip => 'Fungua menyu ya kusogeza';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow hadi \$lastRow kati ya \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow hadi \$lastRow kati ya takriban \$rowCount';

  @override
  String get pasteButtonLabel => 'BANDIKA';

  @override
  String get popupMenuLabel => 'Menyu ibukizi';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Mwezi uliopita';

  @override
  String get previousPageTooltip => 'Ukurasa uliotangulia';

  @override
  String get refreshIndicatorSemanticLabel => 'Onyesha upya';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Imesalia herufi 1';

  @override
  String get remainingTextFieldCharacterCountOther => 'Zimesalia herufi \$remainingCount';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'Hapana herufi zilizo baki';

  @override
  String get reorderItemDown => 'Sogeza chini';

  @override
  String get reorderItemLeft => 'Sogeza kushoto';

  @override
  String get reorderItemRight => 'Sogeza kulia';

  @override
  String get reorderItemToEnd => 'Sogeza hadi mwisho';

  @override
  String get reorderItemToStart => 'Sogeza hadi mwanzo';

  @override
  String get reorderItemUp => 'Sogeza juu';

  @override
  String get rowsPerPageTitle => 'Safu mlalo kwa kila ukurasa:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Tafuta';

  @override
  String get selectAllButtonLabel => 'CHAGUA ZOTE';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Umechagua kipengee 1';

  @override
  String get selectedRowCountTitleOther => 'Umechagua vipengee \$selectedRowCount';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'Hamna kilicho chaguliwa';

  @override
  String get showAccountsLabel => 'Onyesha akaunti';

  @override
  String get showMenuTooltip => 'Onyesha menyu';

  @override
  String get signedInLabel => 'Umeingia katika akaunti';

  @override
  String get tabLabelRaw => 'Kichupo cha \$tabIndex kati ya \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'Chagua saa';

  @override
  String get timePickerMinuteModeAnnouncement => 'Chagua dakika';

  @override
  String get viewLicensesButtonLabel => 'ANGALIA LESENI';
}

/// The translations for Tamil (`ta`).
class MaterialLocalizationTa extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Tamil.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationTa({
    String localeName = 'ta',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName பற்றி';

  @override
  String get alertDialogLabel => 'விழிப்பூட்டல்';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'முந்தைய பக்கம்';

  @override
  String get cancelButtonLabel => 'ரத்துசெய்';

  @override
  String get closeButtonLabel => 'மூடுக';

  @override
  String get closeButtonTooltip => 'மூடுக';

  @override
  String get collapsedIconTapHint => 'விரிக்கும்';

  @override
  String get continueButtonLabel => 'தொடர்க';

  @override
  String get copyButtonLabel => 'நகலெடு';

  @override
  String get cutButtonLabel => 'வெட்டு';

  @override
  String get deleteButtonTooltip => 'நீக்கு';

  @override
  String get dialogLabel => 'உரையாடல்';

  @override
  String get drawerLabel => 'வழிசெலுத்தல் மெனு';

  @override
  String get expandedIconTapHint => 'சுருக்கும்';

  @override
  String get hideAccountsLabel => 'கணக்குகளை மறைக்கும்';

  @override
  String get licensesPageTitle => 'உரிமங்கள்';

  @override
  String get modalBarrierDismissLabel => 'நிராகரிக்கும்';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'அடுத்த மாதம்';

  @override
  String get nextPageTooltip => 'அடுத்த பக்கம்';

  @override
  String get okButtonLabel => 'சரி';

  @override
  String get openAppDrawerTooltip => 'வழிசெலுத்தல் மெனுவைத் திற';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow / \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow / \$rowCount';

  @override
  String get pasteButtonLabel => 'ஒட்டு';

  @override
  String get popupMenuLabel => 'பாப் அப் மெனு';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'முந்தைய மாதம்';

  @override
  String get previousPageTooltip => 'முந்தைய பக்கம்';

  @override
  String get refreshIndicatorSemanticLabel => 'ரெஃப்ரெஷ் செய்யும்';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 எழுத்து மீதமுள்ளது';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount எழுத்துகள் மீதமுள்ளன';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'எழுத்துக்கள் எதுவும் இல்லை';

  @override
  String get reorderItemDown => 'கீழே நகர்த்தவும்';

  @override
  String get reorderItemLeft => 'இடப்புறம் நகர்த்தவும்';

  @override
  String get reorderItemRight => 'வலப்புறம் நகர்த்தவும்';

  @override
  String get reorderItemToEnd => 'இறுதிக்கு நகர்த்தவும்';

  @override
  String get reorderItemToStart => 'தொடக்கத்திற்கு நகர்த்தவும்';

  @override
  String get reorderItemUp => 'மேலே நகர்த்தவும்';

  @override
  String get rowsPerPageTitle => 'ஒரு பக்கத்திற்கான வரிசைகள்:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => 'தேடல்';

  @override
  String get selectAllButtonLabel => 'அனைத்தையும் தேர்ந்தெடு';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 வரிசை தேர்ந்தெடுக்கப்பட்டது';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount வரிசைகள் தேர்ந்தெடுக்கப்பட்டன';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => 'எந்த வரிசையும் தேர்ந்தெடுக்கவில்லை';

  @override
  String get showAccountsLabel => 'கணக்குகளைக் காட்டும்';

  @override
  String get showMenuTooltip => 'மெனுவைக் காட்டு';

  @override
  String get signedInLabel => 'உள்நுழைந்துள்ளீர்கள்';

  @override
  String get tabLabelRaw => 'தாவல் \$tabIndex / \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.a_space_h_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'மணிநேரத்தைத் தேர்ந்தெடுக்கவும்';

  @override
  String get timePickerMinuteModeAnnouncement => 'நிமிடங்களைத் தேர்ந்தெடுக்கவும்';

  @override
  String get viewLicensesButtonLabel => 'உரிமங்களைக் காட்டு';
}

/// The translations for Telugu (`te`).
class MaterialLocalizationTe extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Telugu.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationTe({
    String localeName = 'te',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName గురించి';

  @override
  String get alertDialogLabel => 'అలర్ట్';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'వెనుకకు';

  @override
  String get cancelButtonLabel => 'రద్దు చేయి';

  @override
  String get closeButtonLabel => 'మూసివేయి';

  @override
  String get closeButtonTooltip => 'మూసివేయి';

  @override
  String get collapsedIconTapHint => 'విస్తరించు';

  @override
  String get continueButtonLabel => 'కొనసాగించు';

  @override
  String get copyButtonLabel => 'కాపీ చేయి';

  @override
  String get cutButtonLabel => 'కత్తిరించు';

  @override
  String get deleteButtonTooltip => 'తొలగించు';

  @override
  String get dialogLabel => 'డైలాగ్';

  @override
  String get drawerLabel => 'నావిగేషన్ మెను';

  @override
  String get expandedIconTapHint => 'కుదించు';

  @override
  String get hideAccountsLabel => 'ఖాతాలను దాచు';

  @override
  String get licensesPageTitle => 'లైసెన్స్‌లు';

  @override
  String get modalBarrierDismissLabel => 'విస్మరించు';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'తర్వాత నెల';

  @override
  String get nextPageTooltip => 'తర్వాత పేజీ';

  @override
  String get okButtonLabel => 'సరే';

  @override
  String get openAppDrawerTooltip => 'నావిగేషన్ మెనూను తెరువు';

  @override
  String get pageRowsInfoTitleRaw => '\$rowCountలో \$firstRow - \$lastRow';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$rowCountలో \$firstRow–\$lastRow';

  @override
  String get pasteButtonLabel => 'అతికించు';

  @override
  String get popupMenuLabel => 'పాప్‌అప్ మెను';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'మునుపటి నెల';

  @override
  String get previousPageTooltip => 'మునుపటి పేజీ';

  @override
  String get refreshIndicatorSemanticLabel => 'రిఫ్రెష్ చేయి';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 అక్షరం మిగిలి ఉంది';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount అక్షరాలు మిగిలి ఉన్నాయి';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'కిందికు జరుపు';

  @override
  String get reorderItemLeft => 'ఎడమవైపుగా జరపండి';

  @override
  String get reorderItemRight => 'కుడివైపుగా జరపండి';

  @override
  String get reorderItemToEnd => 'చివరకు తరలించండి';

  @override
  String get reorderItemToStart => 'ప్రారంభానికి తరలించండి';

  @override
  String get reorderItemUp => 'పైకి జరపండి';

  @override
  String get rowsPerPageTitle => 'పేజీకి ఉండే అడ్డు వరుసలు:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'వెతుకు';

  @override
  String get selectAllButtonLabel => 'అన్నింటినీ ఎంచుకోండి';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 అంశం ఎంచుకోబడింది';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount అంశాలు ఎంచుకోబడ్డాయి';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'ఖాతాలను చూపు';

  @override
  String get showMenuTooltip => 'మెనూను చూపు';

  @override
  String get signedInLabel => 'సైన్ ఇన్ చేసారు';

  @override
  String get tabLabelRaw => '\$tabCountలో \$tabIndexవ ట్యాబ్';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'గంటలను ఎంచుకోండి';

  @override
  String get timePickerMinuteModeAnnouncement => 'నిమిషాలను ఎంచుకోండి';

  @override
  String get viewLicensesButtonLabel => 'లైసెన్స్‌లను చూడండి';
}

/// The translations for Thai (`th`).
class MaterialLocalizationTh extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Thai.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationTh({
    String localeName = 'th',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'เกี่ยวกับ \$applicationName';

  @override
  String get alertDialogLabel => 'การแจ้งเตือน';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'กลับ';

  @override
  String get cancelButtonLabel => 'ยกเลิก';

  @override
  String get closeButtonLabel => 'ปิด';

  @override
  String get closeButtonTooltip => 'ปิด';

  @override
  String get collapsedIconTapHint => 'ขยาย';

  @override
  String get continueButtonLabel => 'ต่อไป';

  @override
  String get copyButtonLabel => 'คัดลอก';

  @override
  String get cutButtonLabel => 'ตัด';

  @override
  String get deleteButtonTooltip => 'ลบ';

  @override
  String get dialogLabel => 'กล่องโต้ตอบ';

  @override
  String get drawerLabel => 'เมนูการนำทาง';

  @override
  String get expandedIconTapHint => 'ยุบ';

  @override
  String get hideAccountsLabel => 'ซ่อนบัญชี';

  @override
  String get licensesPageTitle => 'ใบอนุญาต';

  @override
  String get modalBarrierDismissLabel => 'ปิด';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'เดือนหน้า';

  @override
  String get nextPageTooltip => 'หน้าถัดไป';

  @override
  String get okButtonLabel => 'ตกลง';

  @override
  String get openAppDrawerTooltip => 'เปิดเมนูการนำทาง';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow จาก \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow จากประมาณ \$rowCount';

  @override
  String get pasteButtonLabel => 'วาง';

  @override
  String get popupMenuLabel => 'เมนูป๊อปอัป';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'เดือนที่แล้ว';

  @override
  String get previousPageTooltip => 'หน้าก่อน';

  @override
  String get refreshIndicatorSemanticLabel => 'รีเฟรช';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'เหลือ 1 อักขระ';

  @override
  String get remainingTextFieldCharacterCountOther => 'เหลือ \$remainingCount อักขระ';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'ย้ายลง';

  @override
  String get reorderItemLeft => 'ย้ายไปทางซ้าย';

  @override
  String get reorderItemRight => 'ย้ายไปทางขวา';

  @override
  String get reorderItemToEnd => 'ย้ายไปท้ายรายการ';

  @override
  String get reorderItemToStart => 'ย้ายไปต้นรายการ';

  @override
  String get reorderItemUp => 'ย้ายขึ้น';

  @override
  String get rowsPerPageTitle => 'แถวต่อหน้า:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'ค้นหา';

  @override
  String get selectAllButtonLabel => 'เลือกทั้งหมด';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'เลือกแล้ว 1 รายการ';

  @override
  String get selectedRowCountTitleOther => 'เลือกแล้ว \$selectedRowCount รายการ';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'แสดงบัญชี';

  @override
  String get showMenuTooltip => 'แสดงเมนู';

  @override
  String get signedInLabel => 'ลงชื่อเข้าใช้';

  @override
  String get tabLabelRaw => 'แท็บที่ \$tabIndex จาก \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.a_space_h_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'เลือกชั่วโมง';

  @override
  String get timePickerMinuteModeAnnouncement => 'เลือกนาที';

  @override
  String get viewLicensesButtonLabel => 'ดูใบอนุญาต';
}

/// The translations for Tagalog (`tl`).
class MaterialLocalizationTl extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Tagalog.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationTl({
    String localeName = 'tl',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Tungkol sa \$applicationName';

  @override
  String get alertDialogLabel => 'Alerto';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Bumalik';

  @override
  String get cancelButtonLabel => 'KANSELAHIN';

  @override
  String get closeButtonLabel => 'ISARA';

  @override
  String get closeButtonTooltip => 'Isara';

  @override
  String get collapsedIconTapHint => 'I-expand';

  @override
  String get continueButtonLabel => 'MAGPATULOY';

  @override
  String get copyButtonLabel => 'KOPYAHIN';

  @override
  String get cutButtonLabel => 'I-CUT';

  @override
  String get deleteButtonTooltip => 'I-delete';

  @override
  String get dialogLabel => 'Dialog';

  @override
  String get drawerLabel => 'Menu ng navigation';

  @override
  String get expandedIconTapHint => 'I-collapse';

  @override
  String get hideAccountsLabel => 'Itago ang mga account';

  @override
  String get licensesPageTitle => 'Mga Lisensya';

  @override
  String get modalBarrierDismissLabel => 'I-dismiss';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Susunod na buwan';

  @override
  String get nextPageTooltip => 'Susunod na page';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Buksan ang menu ng navigation';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow ng \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow ng humigit kumulang \$rowCount';

  @override
  String get pasteButtonLabel => 'I-PASTE';

  @override
  String get popupMenuLabel => 'Popup na menu';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Nakaraang buwan';

  @override
  String get previousPageTooltip => 'Nakaraang page';

  @override
  String get refreshIndicatorSemanticLabel => 'Nagre-refresh';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 character ang natitira';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount na character ang natitira';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Ilipat pababa';

  @override
  String get reorderItemLeft => 'Ilipat pakaliwa';

  @override
  String get reorderItemRight => 'Ilipat pakanan';

  @override
  String get reorderItemToEnd => 'Ilipat sa dulo';

  @override
  String get reorderItemToStart => 'Ilipat sa simula';

  @override
  String get reorderItemUp => 'Ilipat pataas';

  @override
  String get rowsPerPageTitle => 'Mga row bawat page:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Maghanap';

  @override
  String get selectAllButtonLabel => 'PILIIN LAHAT';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 item ang napili';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount na item ang napili';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Ipakita ang mga account';

  @override
  String get showMenuTooltip => 'Ipakita ang menu';

  @override
  String get signedInLabel => 'Naka-sign in';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex ng \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Pumili ng mga oras';

  @override
  String get timePickerMinuteModeAnnouncement => 'Pumili ng mga minuto';

  @override
  String get viewLicensesButtonLabel => 'TINGNAN ANG MGA LISENSYA';
}

/// The translations for Turkish (`tr`).
class MaterialLocalizationTr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Turkish.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationTr({
    String localeName = 'tr',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName Hakkında';

  @override
  String get alertDialogLabel => 'Uyarı';

  @override
  String get anteMeridiemAbbreviation => 'ÖÖ';

  @override
  String get backButtonTooltip => 'Geri';

  @override
  String get cancelButtonLabel => 'İPTAL';

  @override
  String get closeButtonLabel => 'KAPAT';

  @override
  String get closeButtonTooltip => 'Kapat';

  @override
  String get collapsedIconTapHint => 'Genişlet';

  @override
  String get continueButtonLabel => 'DEVAM';

  @override
  String get copyButtonLabel => 'KOPYALA';

  @override
  String get cutButtonLabel => 'KES';

  @override
  String get deleteButtonTooltip => 'Sil';

  @override
  String get dialogLabel => 'İletişim kutusu';

  @override
  String get drawerLabel => 'Gezinme menüsü';

  @override
  String get expandedIconTapHint => 'Daralt';

  @override
  String get hideAccountsLabel => 'Hesapları gizle';

  @override
  String get licensesPageTitle => 'Lisanslar';

  @override
  String get modalBarrierDismissLabel => 'Kapat';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Gelecek ay';

  @override
  String get nextPageTooltip => 'Sonraki sayfa';

  @override
  String get okButtonLabel => 'Tamam';

  @override
  String get openAppDrawerTooltip => 'Gezinme menüsünü aç';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow-\$lastRow / \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow-\$lastRow / \$rowCount';

  @override
  String get pasteButtonLabel => 'YAPIŞTIR';

  @override
  String get popupMenuLabel => 'Popup menü';

  @override
  String get postMeridiemAbbreviation => 'ÖS';

  @override
  String get previousMonthTooltip => 'Önceki ay';

  @override
  String get previousPageTooltip => 'Önceki sayfa';

  @override
  String get refreshIndicatorSemanticLabel => 'Yenile';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 karakter kaldı';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount karakter kaldı';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Aşağı taşı';

  @override
  String get reorderItemLeft => 'Sola taşı';

  @override
  String get reorderItemRight => 'Sağa taşı';

  @override
  String get reorderItemToEnd => 'Sona taşı';

  @override
  String get reorderItemToStart => 'Başa taşı';

  @override
  String get reorderItemUp => 'Yukarı taşı';

  @override
  String get rowsPerPageTitle => 'Sayfa başına satır sayısı:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Ara';

  @override
  String get selectAllButtonLabel => 'TÜMÜNÜ SEÇ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 öğe seçildi';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount öğe seçildi';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Hesapları göster';

  @override
  String get showMenuTooltip => 'Menüyü göster';

  @override
  String get signedInLabel => 'Oturum açıldı';

  @override
  String get tabLabelRaw => 'Sekme \$tabIndex / \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Saati seçin';

  @override
  String get timePickerMinuteModeAnnouncement => 'Dakikayı seçin';

  @override
  String get viewLicensesButtonLabel => 'LİSANSLARI GÖSTER';
}

/// The translations for Ukrainian (`uk`).
class MaterialLocalizationUk extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Ukrainian.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationUk({
    String localeName = 'uk',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Про додаток \$applicationName';

  @override
  String get alertDialogLabel => 'Сповіщення';

  @override
  String get anteMeridiemAbbreviation => 'дп';

  @override
  String get backButtonTooltip => 'Назад';

  @override
  String get cancelButtonLabel => 'СКАСУВАТИ';

  @override
  String get closeButtonLabel => 'ЗАКРИТИ';

  @override
  String get closeButtonTooltip => 'Закрити';

  @override
  String get collapsedIconTapHint => 'Розгорнути';

  @override
  String get continueButtonLabel => 'ПРОДОВЖИТИ';

  @override
  String get copyButtonLabel => 'КОПІЮВАТИ';

  @override
  String get cutButtonLabel => 'ВИРІЗАТИ';

  @override
  String get deleteButtonTooltip => 'Видалити';

  @override
  String get dialogLabel => 'Вікно';

  @override
  String get drawerLabel => 'Меню навігації';

  @override
  String get expandedIconTapHint => 'Згорнути';

  @override
  String get hideAccountsLabel => 'Сховати облікові записи';

  @override
  String get licensesPageTitle => 'Ліцензії';

  @override
  String get modalBarrierDismissLabel => 'Закрити';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Наступний місяць';

  @override
  String get nextPageTooltip => 'Наступна сторінка';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Відкрити меню навігації';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow з \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow з приблизно \$rowCount';

  @override
  String get pasteButtonLabel => 'ВСТАВИТИ';

  @override
  String get popupMenuLabel => 'Спливаюче меню';

  @override
  String get postMeridiemAbbreviation => 'пп';

  @override
  String get previousMonthTooltip => 'Попередній місяць';

  @override
  String get previousPageTooltip => 'Попередня сторінка';

  @override
  String get refreshIndicatorSemanticLabel => 'Оновити';

  @override
  String get remainingTextFieldCharacterCountFew => 'Залишилося \$remainingCount символи';

  @override
  String get remainingTextFieldCharacterCountMany => 'Залишилося \$remainingCount символів';

  @override
  String get remainingTextFieldCharacterCountOne => 'Залишився 1 символ';

  @override
  String get remainingTextFieldCharacterCountOther => 'Залишилося \$remainingCount символу';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Перемістити вниз';

  @override
  String get reorderItemLeft => 'Перемістити ліворуч';

  @override
  String get reorderItemRight => 'Перемістити праворуч';

  @override
  String get reorderItemToEnd => 'Перемістити в кінець';

  @override
  String get reorderItemToStart => 'Перемістити на початок';

  @override
  String get reorderItemUp => 'Перемістити вгору';

  @override
  String get rowsPerPageTitle => 'Рядків на сторінці:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Пошук';

  @override
  String get selectAllButtonLabel => 'ВИБРАТИ ВСІ';

  @override
  String get selectedRowCountTitleFew => 'Вибрано \$selectedRowCount елементи';

  @override
  String get selectedRowCountTitleMany => 'Вибрано \$selectedRowCount елементів';

  @override
  String get selectedRowCountTitleOne => 'Вибрано 1 елемент';

  @override
  String get selectedRowCountTitleOther => 'Вибрано \$selectedRowCount елемента';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Показати облікові записи';

  @override
  String get showMenuTooltip => 'Показати меню';

  @override
  String get signedInLabel => 'Ви ввійшли';

  @override
  String get tabLabelRaw => 'Вкладка \$tabIndex з \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Виберіть години';

  @override
  String get timePickerMinuteModeAnnouncement => 'Виберіть хвилини';

  @override
  String get viewLicensesButtonLabel => 'ПЕРЕГЛЯНУТИ ЛІЦЕНЗІЇ';
}

/// The translations for Urdu (`ur`).
class MaterialLocalizationUr extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Urdu.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationUr({
    String localeName = 'ur',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName کے بارے میں';

  @override
  String get alertDialogLabel => 'الرٹ';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'پیچھے';

  @override
  String get cancelButtonLabel => 'منسوخ کریں';

  @override
  String get closeButtonLabel => 'بند کریں';

  @override
  String get closeButtonTooltip => 'بند کریں';

  @override
  String get collapsedIconTapHint => 'پھیلائیں';

  @override
  String get continueButtonLabel => 'جاری رکھیں';

  @override
  String get copyButtonLabel => 'کاپی کریں';

  @override
  String get cutButtonLabel => 'کٹ کریں';

  @override
  String get deleteButtonTooltip => 'حذف کریں';

  @override
  String get dialogLabel => 'ڈائلاگ';

  @override
  String get drawerLabel => 'نیویگیشن مینو';

  @override
  String get expandedIconTapHint => 'سکیڑیں';

  @override
  String get hideAccountsLabel => 'اکاؤنٹس چھپائیں';

  @override
  String get licensesPageTitle => 'لائسنسز';

  @override
  String get modalBarrierDismissLabel => 'برخاست کریں';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'اگلا مہینہ';

  @override
  String get nextPageTooltip => 'اگلا صفحہ';

  @override
  String get okButtonLabel => 'ٹھیک ہے';

  @override
  String get openAppDrawerTooltip => 'نیویگیشن مینو کھولیں';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow از \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow \$rowCount میں سے تقریباً';

  @override
  String get pasteButtonLabel => 'پیسٹ کریں';

  @override
  String get popupMenuLabel => 'پاپ اپ مینو';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'پچھلا مہینہ';

  @override
  String get previousPageTooltip => 'گزشتہ صفحہ';

  @override
  String get refreshIndicatorSemanticLabel => 'ریفریش کریں';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 حرف باقی ہے';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount حروف باقی ہیں';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'نیچے منتقل کریں';

  @override
  String get reorderItemLeft => 'بائیں منتقل کریں';

  @override
  String get reorderItemRight => 'دائیں منتقل کریں';

  @override
  String get reorderItemToEnd => 'آخر میں منتقل کریں';

  @override
  String get reorderItemToStart => 'شروع میں منتقل کریں';

  @override
  String get reorderItemUp => 'اوپر منتقل کریں';

  @override
  String get rowsPerPageTitle => 'قطاریں فی صفحہ:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.tall;

  @override
  String get searchFieldLabel => 'تلاش';

  @override
  String get selectAllButtonLabel => 'سبھی منتخب کریں';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 آئٹم منتخب کیا گیا';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount آئٹمز منتخب کیے گئے';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'اکاؤنٹس دکھائیں';

  @override
  String get showMenuTooltip => 'مینو دکھائیں';

  @override
  String get signedInLabel => 'سائن ان کردہ ہے';

  @override
  String get tabLabelRaw => '\$tabCount میں سے \$tabIndex ٹیب';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.h_colon_mm_space_a;

  @override
  String get timePickerHourModeAnnouncement => 'گھنٹے منتخب کریں';

  @override
  String get timePickerMinuteModeAnnouncement => 'منٹ منتخب کریں';

  @override
  String get viewLicensesButtonLabel => 'لائسنسز دیکھیں';
}

/// The translations for Uzbek (`uz`).
class MaterialLocalizationUz extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Uzbek.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationUz({
    String localeName = 'uz',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '\$applicationName haqida';

  @override
  String get alertDialogLabel => 'Ogohlantirish';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Orqaga';

  @override
  String get cancelButtonLabel => 'BEKOR QILISH';

  @override
  String get closeButtonLabel => 'YOPISH';

  @override
  String get closeButtonTooltip => 'Yopish';

  @override
  String get collapsedIconTapHint => 'Yoyish';

  @override
  String get continueButtonLabel => 'DAVOM ETISH';

  @override
  String get copyButtonLabel => 'NUSXA OLISH';

  @override
  String get cutButtonLabel => 'KESIB OLISH';

  @override
  String get deleteButtonTooltip => 'Olib tashlash';

  @override
  String get dialogLabel => 'Muloqot oynasi';

  @override
  String get drawerLabel => 'Navigatsiya menyusi';

  @override
  String get expandedIconTapHint => 'Kichraytirish';

  @override
  String get hideAccountsLabel => 'Hisoblarni berkitish';

  @override
  String get licensesPageTitle => 'Litsenziyalar';

  @override
  String get modalBarrierDismissLabel => 'Yopish';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Keyingi oy';

  @override
  String get nextPageTooltip => 'Keyingi sahifa';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Navigatsiya menyusini ochish';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow, jami: \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow, jami: \$rowCount';

  @override
  String get pasteButtonLabel => 'JOYLASH';

  @override
  String get popupMenuLabel => 'Pop-ap menyusi';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Avvalgi oy';

  @override
  String get previousPageTooltip => 'Avvalgi sahifa';

  @override
  String get refreshIndicatorSemanticLabel => 'Yangilash';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 ta belgi qoldi';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount ta belgi qoldi';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Pastga siljitish';

  @override
  String get reorderItemLeft => 'Chapga siljitish';

  @override
  String get reorderItemRight => 'Oʻngga siljitish';

  @override
  String get reorderItemToEnd => 'Oxiriga siljitish';

  @override
  String get reorderItemToStart => 'Boshiga siljitish';

  @override
  String get reorderItemUp => 'Tepaga siljitish';

  @override
  String get rowsPerPageTitle => 'Har bir sahifadagi qatorlar soni:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Qidirish';

  @override
  String get selectAllButtonLabel => 'BARCHASINI TANLASH';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 ta element tanlandi';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount ta element tanlandi';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Hisoblarni koʻrsatish';

  @override
  String get showMenuTooltip => 'Menyuni koʻrsatish';

  @override
  String get signedInLabel => 'Hisobingizga kirgansiz';

  @override
  String get tabLabelRaw => '\$tabCount varaqdan \$tabIndex';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Soatni tanlang';

  @override
  String get timePickerMinuteModeAnnouncement => 'Daqiqani tanlang';

  @override
  String get viewLicensesButtonLabel => 'Litsenziyalarni koʻrish';
}

/// The translations for Vietnamese (`vi`).
class MaterialLocalizationVi extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Vietnamese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationVi({
    String localeName = 'vi',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Giới thiệu về \$applicationName';

  @override
  String get alertDialogLabel => 'Thông báo';

  @override
  String get anteMeridiemAbbreviation => 'SÁNG';

  @override
  String get backButtonTooltip => 'Quay lại';

  @override
  String get cancelButtonLabel => 'HỦY';

  @override
  String get closeButtonLabel => 'ĐÓNG';

  @override
  String get closeButtonTooltip => 'Đóng';

  @override
  String get collapsedIconTapHint => 'Mở rộng';

  @override
  String get continueButtonLabel => 'TIẾP TỤC';

  @override
  String get copyButtonLabel => 'SAO CHÉP';

  @override
  String get cutButtonLabel => 'CẮT';

  @override
  String get deleteButtonTooltip => 'Xóa';

  @override
  String get dialogLabel => 'Hộp thoại';

  @override
  String get drawerLabel => 'Menu di chuyển';

  @override
  String get expandedIconTapHint => 'Thu gọn';

  @override
  String get hideAccountsLabel => 'Ẩn tài khoản';

  @override
  String get licensesPageTitle => 'Giấy phép';

  @override
  String get modalBarrierDismissLabel => 'Bỏ qua';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Tháng sau';

  @override
  String get nextPageTooltip => 'Trang tiếp theo';

  @override
  String get okButtonLabel => 'OK';

  @override
  String get openAppDrawerTooltip => 'Mở menu di chuyển';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow trong tổng số \$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow trong tổng số khoảng \$rowCount';

  @override
  String get pasteButtonLabel => 'DÁN';

  @override
  String get popupMenuLabel => 'Menu bật lên';

  @override
  String get postMeridiemAbbreviation => 'CHIỀU';

  @override
  String get previousMonthTooltip => 'Tháng trước';

  @override
  String get previousPageTooltip => 'Trang trước';

  @override
  String get refreshIndicatorSemanticLabel => 'Làm mới';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => 'Còn lại 1 ký tự';

  @override
  String get remainingTextFieldCharacterCountOther => 'Còn lại \$remainingCount ký tự';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => 'Di chuyển xuống';

  @override
  String get reorderItemLeft => 'Di chuyển sang trái';

  @override
  String get reorderItemRight => 'Di chuyển sang phải';

  @override
  String get reorderItemToEnd => 'Di chuyển xuống cuối danh sách';

  @override
  String get reorderItemToStart => 'Di chuyển lên đầu danh sách';

  @override
  String get reorderItemUp => 'Di chuyển lên';

  @override
  String get rowsPerPageTitle => 'Số hàng mỗi trang:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Tìm kiếm';

  @override
  String get selectAllButtonLabel => 'CHỌN TẤT CẢ';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => 'Đã chọn 1 mục';

  @override
  String get selectedRowCountTitleOther => 'Đã chọn \$selectedRowCount mục';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Hiển thị tài khoản';

  @override
  String get showMenuTooltip => 'Hiển thị menu';

  @override
  String get signedInLabel => 'Đã đăng nhập';

  @override
  String get tabLabelRaw => 'Tab \$tabIndex trong tổng số \$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.HH_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Chọn giờ';

  @override
  String get timePickerMinuteModeAnnouncement => 'Chọn phút';

  @override
  String get viewLicensesButtonLabel => 'XEM GIẤY PHÉP';
}

/// The translations for Chinese (`zh`).
class MaterialLocalizationZh extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Chinese.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationZh({
    String localeName = 'zh',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '关于\$applicationName';

  @override
  String get alertDialogLabel => '提醒';

  @override
  String get anteMeridiemAbbreviation => '上午';

  @override
  String get backButtonTooltip => '返回';

  @override
  String get cancelButtonLabel => '取消';

  @override
  String get closeButtonLabel => '关闭';

  @override
  String get closeButtonTooltip => '关闭';

  @override
  String get collapsedIconTapHint => '展开';

  @override
  String get continueButtonLabel => '继续';

  @override
  String get copyButtonLabel => '复制';

  @override
  String get cutButtonLabel => '剪切';

  @override
  String get deleteButtonTooltip => '删除';

  @override
  String get dialogLabel => '对话框';

  @override
  String get drawerLabel => '导航菜单';

  @override
  String get expandedIconTapHint => '收起';

  @override
  String get hideAccountsLabel => '隐藏帐号';

  @override
  String get licensesPageTitle => '许可';

  @override
  String get modalBarrierDismissLabel => '关闭';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => '下个月';

  @override
  String get nextPageTooltip => '下一页';

  @override
  String get okButtonLabel => '确定';

  @override
  String get openAppDrawerTooltip => '打开导航菜单';

  @override
  String get pageRowsInfoTitleRaw => '第 \$firstRow-\$lastRow 行（共 \$rowCount 行）';

  @override
  String get pageRowsInfoTitleApproximateRaw => '第 \$firstRow-\$lastRow 行（共约 \$rowCount 行）';

  @override
  String get pasteButtonLabel => '粘贴';

  @override
  String get popupMenuLabel => '弹出菜单';

  @override
  String get postMeridiemAbbreviation => '下午';

  @override
  String get previousMonthTooltip => '上个月';

  @override
  String get previousPageTooltip => '上一页';

  @override
  String get refreshIndicatorSemanticLabel => '刷新';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '还可输入 1 个字符';

  @override
  String get remainingTextFieldCharacterCountOther => '还可输入 \$remainingCount 个字符';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => 'TBD';

  @override
  String get reorderItemDown => '下移';

  @override
  String get reorderItemLeft => '左移';

  @override
  String get reorderItemRight => '右移';

  @override
  String get reorderItemToEnd => '移到末尾';

  @override
  String get reorderItemToStart => '移到开头';

  @override
  String get reorderItemUp => '上移';

  @override
  String get rowsPerPageTitle => '每页行数：';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.dense;

  @override
  String get searchFieldLabel => '搜索';

  @override
  String get selectAllButtonLabel => '全选';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '已选择 1 项内容';

  @override
  String get selectedRowCountTitleOther => '已选择 \$selectedRowCount 项内容';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => '显示帐号';

  @override
  String get showMenuTooltip => '显示菜单';

  @override
  String get signedInLabel => '已登录';

  @override
  String get tabLabelRaw => '第 \$tabIndex 个标签，共 \$tabCount 个';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.a_space_h_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => '选择小时';

  @override
  String get timePickerMinuteModeAnnouncement => '选择分钟';

  @override
  String get viewLicensesButtonLabel => '查看许可';
}

/// The translations for Chinese, using the Han script (`zh_Hans`).
class MaterialLocalizationZhHans extends MaterialLocalizationZh {
  /// Create an instance of the translation bundle for Chinese, using the Han script.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationZhHans({
    String localeName = 'zh_Hans',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );
}

/// The translations for Chinese, using the Han script (`zh_Hant`).
class MaterialLocalizationZhHant extends MaterialLocalizationZh {
  /// Create an instance of the translation bundle for Chinese, using the Han script.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationZhHant({
    String localeName = 'zh_Hant',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => '關於\$applicationName';

  @override
  String get alertDialogLabel => '通知';

  @override
  String get closeButtonLabel => '關閉';

  @override
  String get closeButtonTooltip => '關閉';

  @override
  String get collapsedIconTapHint => '展開';

  @override
  String get continueButtonLabel => '繼續';

  @override
  String get copyButtonLabel => '複製';

  @override
  String get cutButtonLabel => '剪下';

  @override
  String get deleteButtonTooltip => '刪除';

  @override
  String get dialogLabel => '對話方塊';

  @override
  String get drawerLabel => '導覽選單';

  @override
  String get expandedIconTapHint => '收合';

  @override
  String get hideAccountsLabel => '隱藏帳戶';

  @override
  String get licensesPageTitle => '授權';

  @override
  String get modalBarrierDismissLabel => '拒絕';

  @override
  String get nextMonthTooltip => '下個月';

  @override
  String get nextPageTooltip => '下一頁';

  @override
  String get okButtonLabel => '確定';

  @override
  String get openAppDrawerTooltip => '開啟導覽選單';

  @override
  String get pageRowsInfoTitleRaw => '第 \$firstRow 至 \$lastRow 列，共 \$rowCount 列';

  @override
  String get pageRowsInfoTitleApproximateRaw => '第 \$firstRow 至 \$lastRow 列，共約 \$rowCount 列';

  @override
  String get pasteButtonLabel => '貼上';

  @override
  String get popupMenuLabel => '彈出式選單';

  @override
  String get previousMonthTooltip => '上個月';

  @override
  String get previousPageTooltip => '上一頁';

  @override
  String get refreshIndicatorSemanticLabel => '重新整理';

  @override
  String get remainingTextFieldCharacterCountOne => '尚餘 1 個字元';

  @override
  String get remainingTextFieldCharacterCountOther => '尚餘 \$remainingCount 個字元';

  @override
  String get reorderItemDown => '向下移';

  @override
  String get reorderItemLeft => '向左移';

  @override
  String get reorderItemRight => '向右移';

  @override
  String get reorderItemToEnd => '移到最後';

  @override
  String get reorderItemToStart => '移到開頭';

  @override
  String get reorderItemUp => '向上移';

  @override
  String get rowsPerPageTitle => '每頁列數：';

  @override
  String get searchFieldLabel => '搜尋';

  @override
  String get selectAllButtonLabel => '全選';

  @override
  String get selectedRowCountTitleOne => '已選取 1 個項目';

  @override
  String get selectedRowCountTitleOther => '已選取 \$selectedRowCount 個項目';

  @override
  String get showAccountsLabel => '顯示帳戶';

  @override
  String get showMenuTooltip => '顯示選單';

  @override
  String get signedInLabel => '已登入';

  @override
  String get tabLabelRaw => '第 \$tabIndex 個標籤，總共 \$tabCount 個';

  @override
  String get timePickerHourModeAnnouncement => '揀選小時';

  @override
  String get timePickerMinuteModeAnnouncement => '揀選分鐘';

  @override
  String get viewLicensesButtonLabel => '查看授權';
}

/// The translations for Chinese, as used in Hong Kong, using the Han script (`zh_Hant_HK`).
class MaterialLocalizationZhHantHk extends MaterialLocalizationZhHant {
  /// Create an instance of the translation bundle for Chinese, as used in Hong Kong, using the Han script.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationZhHantHk({
    String localeName = 'zh_Hant_HK',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );
}

/// The translations for Chinese, as used in Taiwan, using the Han script (`zh_Hant_TW`).
class MaterialLocalizationZhHantTw extends MaterialLocalizationZhHant {
  /// Create an instance of the translation bundle for Chinese, as used in Taiwan, using the Han script.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationZhHantTw({
    String localeName = 'zh_Hant_TW',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get tabLabelRaw => '第 \$tabIndex 個分頁 (共 \$tabCount 個)';

  @override
  String get modalBarrierDismissLabel => '關閉';

  @override
  String get signedInLabel => '已登入帳戶';

  @override
  String get aboutListTileTitleRaw => '關於「\$applicationName」';

  @override
  String get pageRowsInfoTitleRaw => '第 \$firstRow - \$lastRow 列 (總共 \$rowCount 列)';

  @override
  String get pageRowsInfoTitleApproximateRaw => '第 \$firstRow - \$lastRow 列 (總共約 \$rowCount 列)';

  @override
  String get timePickerHourModeAnnouncement => '選取小時數';

  @override
  String get timePickerMinuteModeAnnouncement => '選取分鐘數';

  @override
  String get alertDialogLabel => '快訊';

  @override
  String get reorderItemToStart => '移至開頭';

  @override
  String get reorderItemToEnd => '移至結尾';

  @override
  String get remainingTextFieldCharacterCountOne => '還可輸入 1 個字元';

  @override
  String get remainingTextFieldCharacterCountOther => '還可輸入 \$remainingCount 個字元';
}

/// The translations for Zulu (`zu`).
class MaterialLocalizationZu extends GlobalMaterialLocalizations {
  /// Create an instance of the translation bundle for Zulu.
  ///
  /// For details on the meaning of the arguments, see [GlobalMaterialLocalizations].
  const MaterialLocalizationZu({
    String localeName = 'zu',
    @required intl.DateFormat fullYearFormat,
    @required intl.DateFormat mediumDateFormat,
    @required intl.DateFormat longDateFormat,
    @required intl.DateFormat yearMonthFormat,
    @required intl.NumberFormat decimalFormat,
    @required intl.NumberFormat twoDigitZeroPaddedFormat,
  }) : super(
    localeName: localeName,
    fullYearFormat: fullYearFormat,
    mediumDateFormat: mediumDateFormat,
    longDateFormat: longDateFormat,
    yearMonthFormat: yearMonthFormat,
    decimalFormat: decimalFormat,
    twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat,
  );

  @override
  String get aboutListTileTitleRaw => 'Mayelana no-\$applicationName';

  @override
  String get alertDialogLabel => 'Isexwayiso';

  @override
  String get anteMeridiemAbbreviation => 'AM';

  @override
  String get backButtonTooltip => 'Emuva';

  @override
  String get cancelButtonLabel => 'KHANSELA';

  @override
  String get closeButtonLabel => 'VALA';

  @override
  String get closeButtonTooltip => 'Vala';

  @override
  String get collapsedIconTapHint => 'Nweba';

  @override
  String get continueButtonLabel => 'QHUBEKA';

  @override
  String get copyButtonLabel => 'KOPISHA';

  @override
  String get cutButtonLabel => 'SIKA';

  @override
  String get deleteButtonTooltip => 'Susa';

  @override
  String get dialogLabel => 'Ingxoxo';

  @override
  String get drawerLabel => 'Imenyu yokuzulazula';

  @override
  String get expandedIconTapHint => 'Goqa';

  @override
  String get hideAccountsLabel => 'Fihla ama-akhawunti';

  @override
  String get licensesPageTitle => 'Amalayisense';

  @override
  String get modalBarrierDismissLabel => 'Cashisa';

  @override
  String get moreButtonTooltip => 'TBD';

  @override
  String get nextMonthTooltip => 'Inyanga ezayo';

  @override
  String get nextPageTooltip => 'Ikhasi elilandelayo';

  @override
  String get okButtonLabel => 'KULUNGILE';

  @override
  String get openAppDrawerTooltip => 'Vula imenyu yokuzulazula';

  @override
  String get pageRowsInfoTitleRaw => '\$firstRow–\$lastRow kokungu-\$rowCount';

  @override
  String get pageRowsInfoTitleApproximateRaw => '\$firstRow–\$lastRow cishe kokungu-\$rowCount';

  @override
  String get pasteButtonLabel => 'NAMATHISELA';

  @override
  String get popupMenuLabel => 'Imenyu ye-popup';

  @override
  String get postMeridiemAbbreviation => 'PM';

  @override
  String get previousMonthTooltip => 'Inyanga edlule';

  @override
  String get previousPageTooltip => 'Ikhasi elidlule';

  @override
  String get refreshIndicatorSemanticLabel => 'Vuselela';

  @override
  String get remainingTextFieldCharacterCountFew => null;

  @override
  String get remainingTextFieldCharacterCountMany => null;

  @override
  String get remainingTextFieldCharacterCountOne => '1 uhlamvu olusele';

  @override
  String get remainingTextFieldCharacterCountOther => '\$remainingCount izinhlamvu ezisele';

  @override
  String get remainingTextFieldCharacterCountTwo => null;

  @override
  String get remainingTextFieldCharacterCountZero => null;

  @override
  String get reorderItemDown => 'Iya phansi';

  @override
  String get reorderItemLeft => 'Hambisa kwesokunxele';

  @override
  String get reorderItemRight => 'Yisa kwesokudla';

  @override
  String get reorderItemToEnd => 'Yisa ekugcineni';

  @override
  String get reorderItemToStart => 'Yisa ekuqaleni';

  @override
  String get reorderItemUp => 'Iya phezulu';

  @override
  String get rowsPerPageTitle => 'Imigqa ekhasini ngalinye:';

  @override
  ScriptCategory get scriptCategory => ScriptCategory.englishLike;

  @override
  String get searchFieldLabel => 'Sesha';

  @override
  String get selectAllButtonLabel => 'KHETHA KONKE';

  @override
  String get selectedRowCountTitleFew => null;

  @override
  String get selectedRowCountTitleMany => null;

  @override
  String get selectedRowCountTitleOne => '1 into ekhethiwe';

  @override
  String get selectedRowCountTitleOther => '\$selectedRowCount izinto ezikhethiwe';

  @override
  String get selectedRowCountTitleTwo => null;

  @override
  String get selectedRowCountTitleZero => null;

  @override
  String get showAccountsLabel => 'Bonisa ama-akhawunti';

  @override
  String get showMenuTooltip => 'Bonisa imenyu';

  @override
  String get signedInLabel => 'Ungene ngemvume';

  @override
  String get tabLabelRaw => 'Ithebhu \$tabIndex kwangu-\$tabCount';

  @override
  TimeOfDayFormat get timeOfDayFormatRaw => TimeOfDayFormat.H_colon_mm;

  @override
  String get timePickerHourModeAnnouncement => 'Khetha amahora';

  @override
  String get timePickerMinuteModeAnnouncement => 'Khetha amaminithi';

  @override
  String get viewLicensesButtonLabel => 'Buka amalayisense';
}

/// The set of supported languages, as language code strings.
///
/// The [GlobalMaterialLocalizations.delegate] can generate localizations for
/// any [Locale] with a language code from this set, regardless of the region.
/// Some regions have specific support (e.g. `de` covers all forms of German,
/// but there is support for `de-CH` specifically to override some of the
/// translations for Switzerland).
///
/// See also:
///
///  * [getMaterialTranslation], whose documentation describes these values.
final Set<String> kMaterialSupportedLanguages = HashSet<String>.from(const <String>[
  'af', // Afrikaans
  'am', // Amharic
  'ar', // Arabic
  'as', // Assamese
  'az', // Azerbaijani
  'be', // Belarusian
  'bg', // Bulgarian
  'bn', // Bengali Bangla
  'bs', // Bosnian
  'ca', // Catalan Valencian
  'cs', // Czech
  'da', // Danish
  'de', // German
  'el', // Modern Greek
  'en', // English
  'es', // Spanish Castilian
  'et', // Estonian
  'eu', // Basque
  'fa', // Persian
  'fi', // Finnish
  'fil', // Filipino Pilipino
  'fr', // French
  'gl', // Galician
  'gsw', // Swiss German Alemannic Alsatian
  'gu', // Gujarati
  'he', // Hebrew
  'hi', // Hindi
  'hr', // Croatian
  'hu', // Hungarian
  'hy', // Armenian
  'id', // Indonesian
  'is', // Icelandic
  'it', // Italian
  'ja', // Japanese
  'ka', // Georgian
  'kk', // Kazakh
  'km', // Khmer Central Khmer
  'kn', // Kannada
  'ko', // Korean
  'ky', // Kirghiz Kyrgyz
  'lo', // Lao
  'lt', // Lithuanian
  'lv', // Latvian
  'mk', // Macedonian
  'ml', // Malayalam
  'mn', // Mongolian
  'mr', // Marathi
  'ms', // Malay
  'my', // Burmese
  'nb', // Norwegian Bokmål
  'ne', // Nepali
  'nl', // Dutch Flemish
  'or', // Oriya
  'pa', // Panjabi Punjabi
  'pl', // Polish
  'ps', // Pushto Pashto
  'pt', // Portuguese
  'ro', // Romanian Moldavian Moldovan
  'ru', // Russian
  'si', // Sinhala Sinhalese
  'sk', // Slovak
  'sl', // Slovenian
  'sq', // Albanian
  'sr', // Serbian
  'sv', // Swedish
  'sw', // Swahili
  'ta', // Tamil
  'te', // Telugu
  'th', // Thai
  'tl', // Tagalog
  'tr', // Turkish
  'uk', // Ukrainian
  'ur', // Urdu
  'uz', // Uzbek
  'vi', // Vietnamese
  'zh', // Chinese
  'zu', // Zulu
]);

/// Creates a [GlobalMaterialLocalizations] instance for the given `locale`.
///
/// All of the function's arguments except `locale` will be passed to the [
/// GlobalMaterialLocalizations] constructor. (The `localeName` argument of that
/// constructor is specified by the actual subclass constructor by this
/// function.)
///
/// The following locales are supported by this package:
///
/// {@template flutter.localizations.material.languages}
///  * `af` - Afrikaans
///  * `am` - Amharic
///  * `ar` - Arabic
///  * `as` - Assamese
///  * `az` - Azerbaijani
///  * `be` - Belarusian
///  * `bg` - Bulgarian
///  * `bn` - Bengali Bangla
///  * `bs` - Bosnian
///  * `ca` - Catalan Valencian
///  * `cs` - Czech
///  * `da` - Danish
///  * `de` - German (plus one country variation)
///  * `el` - Modern Greek
///  * `en` - English (plus 8 country variations)
///  * `es` - Spanish Castilian (plus 20 country variations)
///  * `et` - Estonian
///  * `eu` - Basque
///  * `fa` - Persian
///  * `fi` - Finnish
///  * `fil` - Filipino Pilipino
///  * `fr` - French (plus one country variation)
///  * `gl` - Galician
///  * `gsw` - Swiss German Alemannic Alsatian
///  * `gu` - Gujarati
///  * `he` - Hebrew
///  * `hi` - Hindi
///  * `hr` - Croatian
///  * `hu` - Hungarian
///  * `hy` - Armenian
///  * `id` - Indonesian
///  * `is` - Icelandic
///  * `it` - Italian
///  * `ja` - Japanese
///  * `ka` - Georgian
///  * `kk` - Kazakh
///  * `km` - Khmer Central Khmer
///  * `kn` - Kannada
///  * `ko` - Korean
///  * `ky` - Kirghiz Kyrgyz
///  * `lo` - Lao
///  * `lt` - Lithuanian
///  * `lv` - Latvian
///  * `mk` - Macedonian
///  * `ml` - Malayalam
///  * `mn` - Mongolian
///  * `mr` - Marathi
///  * `ms` - Malay
///  * `my` - Burmese
///  * `nb` - Norwegian Bokmål
///  * `ne` - Nepali
///  * `nl` - Dutch Flemish
///  * `or` - Oriya
///  * `pa` - Panjabi Punjabi
///  * `pl` - Polish
///  * `ps` - Pushto Pashto
///  * `pt` - Portuguese (plus one country variation)
///  * `ro` - Romanian Moldavian Moldovan
///  * `ru` - Russian
///  * `si` - Sinhala Sinhalese
///  * `sk` - Slovak
///  * `sl` - Slovenian
///  * `sq` - Albanian
///  * `sr` - Serbian (plus 2 scripts)
///  * `sv` - Swedish
///  * `sw` - Swahili
///  * `ta` - Tamil
///  * `te` - Telugu
///  * `th` - Thai
///  * `tl` - Tagalog
///  * `tr` - Turkish
///  * `uk` - Ukrainian
///  * `ur` - Urdu
///  * `uz` - Uzbek
///  * `vi` - Vietnamese
///  * `zh` - Chinese (plus 2 country variations and 2 scripts)
///  * `zu` - Zulu
/// {@endtemplate}
///
/// Generally speaking, this method is only intended to be used by
/// [GlobalMaterialLocalizations.delegate].
GlobalMaterialLocalizations getMaterialTranslation(
  Locale locale,
  intl.DateFormat fullYearFormat,
  intl.DateFormat mediumDateFormat,
  intl.DateFormat longDateFormat,
  intl.DateFormat yearMonthFormat,
  intl.NumberFormat decimalFormat,
  intl.NumberFormat twoDigitZeroPaddedFormat,
) {
  switch (locale.languageCode) {
    case 'af':
      return MaterialLocalizationAf(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'am':
      return MaterialLocalizationAm(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ar':
      return MaterialLocalizationAr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'as':
      return MaterialLocalizationAs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'az':
      return MaterialLocalizationAz(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'be':
      return MaterialLocalizationBe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'bg':
      return MaterialLocalizationBg(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'bn':
      return MaterialLocalizationBn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'bs':
      return MaterialLocalizationBs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ca':
      return MaterialLocalizationCa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'cs':
      return MaterialLocalizationCs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'da':
      return MaterialLocalizationDa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'de': {
      switch (locale.countryCode) {
        case 'CH':
          return MaterialLocalizationDeCh(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
      }
      return MaterialLocalizationDe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'el':
      return MaterialLocalizationEl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'en': {
      switch (locale.countryCode) {
        case 'AU':
          return MaterialLocalizationEnAu(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'CA':
          return MaterialLocalizationEnCa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'GB':
          return MaterialLocalizationEnGb(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'IE':
          return MaterialLocalizationEnIe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'IN':
          return MaterialLocalizationEnIn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'NZ':
          return MaterialLocalizationEnNz(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'SG':
          return MaterialLocalizationEnSg(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'ZA':
          return MaterialLocalizationEnZa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
      }
      return MaterialLocalizationEn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'es': {
      switch (locale.countryCode) {
        case '419':
          return MaterialLocalizationEs419(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'AR':
          return MaterialLocalizationEsAr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'BO':
          return MaterialLocalizationEsBo(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'CL':
          return MaterialLocalizationEsCl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'CO':
          return MaterialLocalizationEsCo(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'CR':
          return MaterialLocalizationEsCr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'DO':
          return MaterialLocalizationEsDo(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'EC':
          return MaterialLocalizationEsEc(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'GT':
          return MaterialLocalizationEsGt(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'HN':
          return MaterialLocalizationEsHn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'MX':
          return MaterialLocalizationEsMx(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'NI':
          return MaterialLocalizationEsNi(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'PA':
          return MaterialLocalizationEsPa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'PE':
          return MaterialLocalizationEsPe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'PR':
          return MaterialLocalizationEsPr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'PY':
          return MaterialLocalizationEsPy(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'SV':
          return MaterialLocalizationEsSv(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'US':
          return MaterialLocalizationEsUs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'UY':
          return MaterialLocalizationEsUy(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'VE':
          return MaterialLocalizationEsVe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
      }
      return MaterialLocalizationEs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'et':
      return MaterialLocalizationEt(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'eu':
      return MaterialLocalizationEu(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'fa':
      return MaterialLocalizationFa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'fi':
      return MaterialLocalizationFi(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'fil':
      return MaterialLocalizationFil(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'fr': {
      switch (locale.countryCode) {
        case 'CA':
          return MaterialLocalizationFrCa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
      }
      return MaterialLocalizationFr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'gl':
      return MaterialLocalizationGl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'gsw':
      return MaterialLocalizationGsw(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'gu':
      return MaterialLocalizationGu(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'he':
      return MaterialLocalizationHe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'hi':
      return MaterialLocalizationHi(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'hr':
      return MaterialLocalizationHr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'hu':
      return MaterialLocalizationHu(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'hy':
      return MaterialLocalizationHy(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'id':
      return MaterialLocalizationId(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'is':
      return MaterialLocalizationIs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'it':
      return MaterialLocalizationIt(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ja':
      return MaterialLocalizationJa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ka':
      return MaterialLocalizationKa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'kk':
      return MaterialLocalizationKk(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'km':
      return MaterialLocalizationKm(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'kn':
      return MaterialLocalizationKn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ko':
      return MaterialLocalizationKo(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ky':
      return MaterialLocalizationKy(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'lo':
      return MaterialLocalizationLo(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'lt':
      return MaterialLocalizationLt(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'lv':
      return MaterialLocalizationLv(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'mk':
      return MaterialLocalizationMk(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ml':
      return MaterialLocalizationMl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'mn':
      return MaterialLocalizationMn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'mr':
      return MaterialLocalizationMr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ms':
      return MaterialLocalizationMs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'my':
      return MaterialLocalizationMy(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'nb':
      return MaterialLocalizationNb(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ne':
      return MaterialLocalizationNe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'nl':
      return MaterialLocalizationNl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'or':
      return MaterialLocalizationOr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'pa':
      return MaterialLocalizationPa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'pl':
      return MaterialLocalizationPl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ps':
      return MaterialLocalizationPs(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'pt': {
      switch (locale.countryCode) {
        case 'PT':
          return MaterialLocalizationPtPt(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
      }
      return MaterialLocalizationPt(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'ro':
      return MaterialLocalizationRo(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ru':
      return MaterialLocalizationRu(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'si':
      return MaterialLocalizationSi(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'sk':
      return MaterialLocalizationSk(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'sl':
      return MaterialLocalizationSl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'sq':
      return MaterialLocalizationSq(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'sr': {
      switch (locale.scriptCode) {
        case 'Cyrl': {
          return MaterialLocalizationSrCyrl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        }
        case 'Latn': {
          return MaterialLocalizationSrLatn(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        }
      }
      return MaterialLocalizationSr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'sv':
      return MaterialLocalizationSv(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'sw':
      return MaterialLocalizationSw(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ta':
      return MaterialLocalizationTa(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'te':
      return MaterialLocalizationTe(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'th':
      return MaterialLocalizationTh(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'tl':
      return MaterialLocalizationTl(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'tr':
      return MaterialLocalizationTr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'uk':
      return MaterialLocalizationUk(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'ur':
      return MaterialLocalizationUr(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'uz':
      return MaterialLocalizationUz(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'vi':
      return MaterialLocalizationVi(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    case 'zh': {
      switch (locale.scriptCode) {
        case 'Hans': {
          return MaterialLocalizationZhHans(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        }
        case 'Hant': {
          switch (locale.countryCode) {
            case 'HK':
              return MaterialLocalizationZhHantHk(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
            case 'TW':
              return MaterialLocalizationZhHantTw(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
          }
          return MaterialLocalizationZhHant(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        }
      }
      switch (locale.countryCode) {
        case 'HK':
          return MaterialLocalizationZhHantHk(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
        case 'TW':
          return MaterialLocalizationZhHantTw(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
      }
      return MaterialLocalizationZh(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
    }
    case 'zu':
      return MaterialLocalizationZu(fullYearFormat: fullYearFormat, mediumDateFormat: mediumDateFormat, longDateFormat: longDateFormat, yearMonthFormat: yearMonthFormat, decimalFormat: decimalFormat, twoDigitZeroPaddedFormat: twoDigitZeroPaddedFormat);
  }
  assert(false, 'getMaterialTranslation() called for unsupported locale "$locale"');
  return null;
}
