// ignore: unused_import
import 'package:intl/intl.dart' as intl;
import 'gallery_localizations.dart';

// ignore_for_file: unnecessary_brace_in_string_interps

/// The translations for Swahili (`sw`).
class GalleryLocalizationsSw extends GalleryLocalizations {
  GalleryLocalizationsSw([String locale = 'sw']) : super(locale);

  @override
  String githubRepo(Object repoName) {
    return '${repoName} Hazina ya GitHub';
  }

  @override
  String aboutDialogDescription(Object repoLink) {
    return 'Ili uangalie msimbo wa programu hii, tafadhali tembelea ${repoLink}.';
  }

  @override
  String get signIn => 'INGIA KATIKA AKAUNTI';

  @override
  String get bannerDemoText =>
      'Nenosiri lako limesasishwa kwenye kifaa chako kingine. Tafadhali ingia tena katika akaunti.';

  @override
  String get bannerDemoResetText => 'Badilisha bango';

  @override
  String get bannerDemoMultipleText => 'Vitendo vingi';

  @override
  String get bannerDemoLeadingText => 'Aikoni ya Msingi';

  @override
  String get dismiss => 'ONDOA';

  @override
  String get backToGallery => 'Rudi kwenye Gallery';

  @override
  String get cardsDemoTappable => 'Inayoweza kuguswa';

  @override
  String get cardsDemoSelectable =>
      'Inayoweza kuchaguliwa (bonyeza kwa muda mrefu)';

  @override
  String get cardsDemoExplore => 'Gundua';

  @override
  String cardsDemoExploreSemantics(Object destinationName) {
    return 'Gundua ${destinationName}';
  }

  @override
  String cardsDemoShareSemantics(Object destinationName) {
    return 'Shiriki ${destinationName}';
  }

  @override
  String get cardsDemoTravelDestinationTitle1 =>
      'Miji 10 Maarufu ya Kutembelea jimboni Tamil Nadu';

  @override
  String get cardsDemoTravelDestinationDescription1 => 'Nambari ya 10';

  @override
  String get cardsDemoTravelDestinationCity1 => 'Thanjavur';

  @override
  String get cardsDemoTravelDestinationLocation1 => 'Thanjavur, Tamil Nadu';

  @override
  String get cardsDemoTravelDestinationTitle2 => 'Fundi wa India ya Kaskazini';

  @override
  String get cardsDemoTravelDestinationDescription2 =>
      'Watengenezaji wa Hariri';

  @override
  String get cardsDemoTravelDestinationCity2 => 'Chettinad';

  @override
  String get cardsDemoTravelDestinationLocation2 => 'Sivaganga, Tamil Nadu';

  @override
  String get cardsDemoTravelDestinationTitle3 => 'Hekalu la Brihadisvara';

  @override
  String get cardsDemoTravelDestinationDescription3 => 'Hekalu';

  @override
  String get homeHeaderGallery => 'Matunzio';

  @override
  String get homeHeaderCategories => 'Aina';

  @override
  String get shrineDescription => 'Programu ya kisasa ya uuzaji wa rejareja';

  @override
  String get fortnightlyDescription =>
      'Programu ya habari inayoangazia maudhui';

  @override
  String get rallyDescription => 'Programu ya fedha ya binafsi';

  @override
  String get rallyAccountDataChecking => 'Inakagua';

  @override
  String get rallyAccountDataHomeSavings => 'Akiba ya Nyumbani';

  @override
  String get rallyAccountDataCarSavings => 'Akiba ya Gari';

  @override
  String get rallyAccountDataVacation => 'Likizo';

  @override
  String get rallyAccountDetailDataAnnualPercentageYield =>
      'Asilimia ya Mapato kila Mwaka';

  @override
  String get rallyAccountDetailDataInterestRate => 'Kiwango cha Riba';

  @override
  String get rallyAccountDetailDataInterestYtd => 'Riba ya Mwaka hadi leo';

  @override
  String get rallyAccountDetailDataInterestPaidLastYear =>
      'Riba Iliyolipwa Mwaka Uliopita';

  @override
  String get rallyAccountDetailDataNextStatement => 'Taarifa Inayofuata';

  @override
  String get rallyAccountDetailDataAccountOwner => 'Mmiliki wa Akaunti';

  @override
  String get rallyBillDetailTotalAmount => 'Jumla ya Pesa';

  @override
  String get rallyBillDetailAmountPaid => 'Kiasi Ulicholipa';

  @override
  String get rallyBillDetailAmountDue => 'Kiasi Kinachofaa Kulipwa';

  @override
  String get rallyBudgetCategoryCoffeeShops => 'Maduka ya Kahawa';

  @override
  String get rallyBudgetCategoryGroceries => 'Maduka ya vyakula';

  @override
  String get rallyBudgetCategoryRestaurants => 'Mikahawa';

  @override
  String get rallyBudgetCategoryClothing => 'Mavazi';

  @override
  String get rallyBudgetDetailTotalCap => 'Jumla ya Kiasi cha Bajeti';

  @override
  String get rallyBudgetDetailAmountUsed => 'Kiasi Ulichotumia';

  @override
  String get rallyBudgetDetailAmountLeft => 'Kiasi Kilichosalia';

  @override
  String get rallySettingsManageAccounts => 'Dhibiti Akaunti';

  @override
  String get rallySettingsTaxDocuments => 'Hati za Kodi';

  @override
  String get rallySettingsPasscodeAndTouchId => 'Nambari ya siri na Touch ID';

  @override
  String get rallySettingsNotifications => 'Arifa';

  @override
  String get rallySettingsPersonalInformation => 'Taarifa Binafsi';

  @override
  String get rallySettingsPaperlessSettings =>
      'Mipangilio ya Kutotumia Karatasi';

  @override
  String get rallySettingsFindAtms => 'Tafuta ATM';

  @override
  String get rallySettingsHelp => 'Usaidizi';

  @override
  String get rallySettingsSignOut => 'Ondoka';

  @override
  String get rallyAccountTotal => 'Jumla';

  @override
  String get rallyBillsDue => 'Zinahitajika mnamo';

  @override
  String get rallyBudgetLeft => 'Kushoto';

  @override
  String get rallyAccounts => 'Akaunti';

  @override
  String get rallyBills => 'Bili';

  @override
  String get rallyBudgets => 'Bajeti';

  @override
  String get rallyAlerts => 'Arifa';

  @override
  String get rallySeeAll => 'ANGALIA YOTE';

  @override
  String get rallyFinanceLeft => 'KUSHOTO';

  @override
  String get rallyTitleOverview => 'MUHTASARI';

  @override
  String get rallyTitleAccounts => 'AKAUNTI';

  @override
  String get rallyTitleBills => 'BILI';

  @override
  String get rallyTitleBudgets => 'BAJETI';

  @override
  String get rallyTitleSettings => 'MIPANGILIO';

  @override
  String get rallyLoginLoginToRally => 'Ingia katika programu ya Rally';

  @override
  String get rallyLoginNoAccount => 'Huna akaunti?';

  @override
  String get rallyLoginSignUp => 'JISAJILI';

  @override
  String get rallyLoginUsername => 'Jina la mtumiaji';

  @override
  String get rallyLoginPassword => 'Nenosiri';

  @override
  String get rallyLoginLabelLogin => 'Ingia katika akaunti';

  @override
  String get rallyLoginRememberMe => 'Nikumbuke';

  @override
  String get rallyLoginButtonLogin => 'INGIA KATIKA AKAUNTI';

  @override
  String rallyAlertsMessageHeadsUpShopping(Object percent) {
    return 'Arifa: umetumia ${percent} ya bajeti yako ya Ununuzi kwa mwezi huu.';
  }

  @override
  String rallyAlertsMessageSpentOnRestaurants(Object amount) {
    return 'Umetumia ${amount} kwenye Mikahawa wiki hii.';
  }

  @override
  String rallyAlertsMessageATMFees(Object amount) {
    return 'Umetumia ${amount} katika ada za ATM mwezi huu';
  }

  @override
  String rallyAlertsMessageCheckingAccount(Object percent) {
    return 'Kazi nzuri! Kiwango cha akaunti yako ya hundi kimezidi cha mwezi uliopita kwa ${percent}.';
  }

  @override
  String rallyAlertsMessageUnassignedTransactions(int count) {
    return intl.Intl.pluralLogic(
      count,
      locale: localeName,
      one:
          'Ongeza kiwango cha kodi unayoweza kupunguziwa! Weka aina kwenye muamala 1 ambao hauna aina.',
      other:
          'Ongeza kiwango cha kodi unayoweza kupunguziwa! Weka aina kwenye miamala ${count} ambayo haina aina.',
    );
  }

  @override
  String get rallySeeAllAccounts => 'Angalia akaunti zote';

  @override
  String get rallySeeAllBills => 'Angalia bili zote';

  @override
  String get rallySeeAllBudgets => 'Angalia bajeti zote';

  @override
  String rallyAccountAmount(
      Object accountName, Object accountNumber, Object amount) {
    return 'Akaunti ya ${accountName} ${accountNumber} iliyo na ${amount}.';
  }

  @override
  String rallyBillAmount(Object billName, Object date, Object amount) {
    return 'Bili ya ${amount} ya ${billName} inapaswa kulipwa ${date}.';
  }

  @override
  String rallyBudgetAmount(Object budgetName, Object amountUsed,
      Object amountTotal, Object amountLeft) {
    return 'Bajeti ya ${budgetName} yenye ${amountUsed} ambazo zimetumika kati ya ${amountTotal}, zimesalia ${amountLeft}';
  }

  @override
  String get craneDescription => 'Programu ya usafiri iliyogeuzwa kukufaa';

  @override
  String get homeCategoryReference => 'MIUNDO NA MENGINE';

  @override
  String get demoInvalidURL => 'Imeshindwa kuonyesha URL:';

  @override
  String get demoOptionsTooltip => 'Chaguo';

  @override
  String get demoInfoTooltip => 'Maelezo';

  @override
  String get demoCodeTooltip => 'Msimbo wa Onyesho';

  @override
  String get demoDocumentationTooltip => 'Uwekaji hati wa API';

  @override
  String get demoFullscreenTooltip => 'Skrini Nzima';

  @override
  String get demoCodeViewerCopyAll => 'NAKILI YOTE';

  @override
  String get demoCodeViewerCopiedToClipboardMessage =>
      'Imewekwa kwenye ubao wa kunakili.';

  @override
  String demoCodeViewerFailedToCopyToClipboardMessage(Object error) {
    return 'Imeshindwa kuyaweka kwenye ubao wa kunakili: ${error}';
  }

  @override
  String get demoOptionsFeatureTitle => 'Angalia chaguo';

  @override
  String get demoOptionsFeatureDescription =>
      'Gusa hapa ili uangalie chaguo zinazopatikana kwa onyesho hili.';

  @override
  String get settingsTitle => 'Mipangilio';

  @override
  String get settingsButtonLabel => 'Mipangilio';

  @override
  String get settingsButtonCloseLabel => 'Funga mipangilio';

  @override
  String get settingsSystemDefault => 'Mfumo';

  @override
  String get settingsTextScaling => 'Ubadilishaji ukubwa wa maandishi';

  @override
  String get settingsTextScalingSmall => 'Ndogo';

  @override
  String get settingsTextScalingNormal => 'Ya Kawaida';

  @override
  String get settingsTextScalingLarge => 'Kubwa';

  @override
  String get settingsTextScalingHuge => 'Kubwa';

  @override
  String get settingsTextDirection => 'Mwelekeo wa maandishi';

  @override
  String get settingsTextDirectionLocaleBased => 'Kulingana na lugha';

  @override
  String get settingsTextDirectionLTR => 'Kushoto kuelekea kulia';

  @override
  String get settingsTextDirectionRTL => 'Kulia kuelekea kushoto';

  @override
  String get settingsLocale => 'Lugha';

  @override
  String get settingsPlatformMechanics => 'Umakanika wa mfumo';

  @override
  String get settingsTheme => 'Mandhari';

  @override
  String get settingsDarkTheme => 'Meusi';

  @override
  String get settingsLightTheme => 'Meupe';

  @override
  String get settingsSlowMotion => 'Mwendopole';

  @override
  String get settingsAbout => 'Kuhusu Matunzio ya Flutter';

  @override
  String get settingsFeedback => 'Tuma maoni';

  @override
  String get settingsAttribution => 'Imebuniwa na TOASTER mjini London';

  @override
  String get demoBottomAppBarTitle => 'Upau wa chini wa programu';

  @override
  String get demoBottomAppBarSubtitle =>
      'Huonyesha usogezaji na vitendo katika sehemu ya chini';

  @override
  String get demoBottomAppBarDescription =>
      'Pau za chini za programu hutoa uwezo wa kufikia droo ya chini ya kusogeza na hadi vitendo vinne, ikiwa ni pamoja na kitufe cha kutenda kinachoelea.';

  @override
  String get bottomAppBarNotch => 'Pengo';

  @override
  String get bottomAppBarPosition => 'Nafasi ya Kitufe cha Kutenda Kinachoelea';

  @override
  String get bottomAppBarPositionDockedEnd => 'Kilichoambatishwa - Mwisho';

  @override
  String get bottomAppBarPositionDockedCenter => 'Kilichoambatishwa - Katikati';

  @override
  String get bottomAppBarPositionFloatingEnd => 'Kinachoelea - Mwisho';

  @override
  String get bottomAppBarPositionFloatingCenter => 'Kinachoelea - Katikati';

  @override
  String get demoBannerTitle => 'Bango';

  @override
  String get demoBannerSubtitle => 'Kuonyesha bango katika orodha';

  @override
  String get demoBannerDescription =>
      'Bango huonyesha ujumbe muhimu na dhahiri na kuwapa watumiaji hatua za kutekeleza (au kuondoa bango). Mtumiaji anahitajika kuchukua hatua ili kuiondoa.';

  @override
  String get demoBottomNavigationTitle => 'Usogezaji katika sehemu ya chini';

  @override
  String get demoBottomNavigationSubtitle =>
      'Usogezaji katika sehemu ya chini na mwonekano unaofifia kwa kupishana';

  @override
  String get demoBottomNavigationPersistentLabels => 'Lebo endelevu';

  @override
  String get demoBottomNavigationSelectedLabel => 'Lebo iliyochaguliwa';

  @override
  String get demoBottomNavigationDescription =>
      'Sehemu za chini za viungo muhimu huonyesha vituo vitatu hadi vitano katika sehemu ya chini ya skrini. Kila kituo kinawakilishwa na aikoni na lebo ya maandishi isiyo ya lazima. Aikoni ya usogezaji ya chini inapoguswa, mtumiaji hupelekwa kwenye kituo cha usogezaji cha kiwango cha juu kinachohusiana na aikoni hiyo.';

  @override
  String get demoButtonTitle => 'Vitufe';

  @override
  String get demoButtonSubtitle =>
      'Bapa, iliyoinuliwa, mpaka wa mstari na zaidi';

  @override
  String get demoFlatButtonTitle => 'Kitufe Bapa';

  @override
  String get demoFlatButtonDescription =>
      'Kitufe bapa huonyesha madoadoa ya wino wakati wa kubonyeza lakini hakiinuki. Tumia vitufe bapa kwenye upau wa vidhibiti, katika vidirisha na kulingana na maandishi yenye nafasi';

  @override
  String get demoRaisedButtonTitle => 'Kitufe Kilichoinuliwa';

  @override
  String get demoRaisedButtonDescription =>
      'Vitufe vilivyoinuliwa huongeza kivimbe kwenye miundo iliyo bapa kwa sehemu kubwa. Vinasisitiza utendaji kwenye nafasi pana au yenye shughuli nyingi.';

  @override
  String get demoOutlineButtonTitle => 'Kitufe chenye Mpaka wa Mstari';

  @override
  String get demoOutlineButtonDescription =>
      'Vitufe vya mipaka ya mistari huwa havipenyezi nuru na huinuka vinapobonyezwa. Mara nyingi vinaoanishwa na vitufe vilivyoinuliwa ili kuashiria kitendo mbadala, cha pili.';

  @override
  String get demoToggleButtonTitle => 'Vitufe vya Kugeuza';

  @override
  String get demoToggleButtonDescription =>
      'Vitufe vya kugeuza vinaweza kutumiwa kuweka chaguo zinazohusiana katika vikundi. Ili kusisitiza vikundi vya vitufe vya kugeuza vinavyohusiana, kikundi kinafaa kushiriki metadata ya kawaida';

  @override
  String get demoFloatingButtonTitle => 'Kitufe cha Kutenda Kinachoelea';

  @override
  String get demoFloatingButtonDescription =>
      'Kitufe cha kutenda kinachoelea ni kitufe cha aikoni ya mduara kinachoelea juu ya maudhui ili kukuza kitendo cha msingi katika programu.';

  @override
  String get demoCardTitle => 'Kadi';

  @override
  String get demoCardSubtitle => 'Kadi za msingi zenye pembe za mviringo';

  @override
  String get demoChipTitle => 'Chipu';

  @override
  String get demoCardDescription =>
      'Kadi ni laha ya Nyenzo inayotumika kuwasilisha maelezo fulani yanayohusiana, kwa mfano maelezo ya anwani, albamu, eneo, mlo n.k.';

  @override
  String get demoChipSubtitle =>
      'Vipengee vilivyoshikamana vinavyowakilisha ingizo, sifa au kitendo';

  @override
  String get demoActionChipTitle => 'Chipu ya Kutenda';

  @override
  String get demoActionChipDescription =>
      'Chipu za kutenda ni seti ya chaguo zinazosababisha kitendo kinachohusiana na maudhui ya msingi. Chipu za kutenda zinafaa kuonekana kwa urahisi na kwa utaratibu katika kiolesura.';

  @override
  String get demoChoiceChipTitle => 'Chipu ya Kuchagua';

  @override
  String get demoChoiceChipDescription =>
      'Chipu za kuchagua zinawakilisha chaguo moja kwenye seti. Chipu za kuchagua zina aina au maandishi ya ufafanuzi yanayohusiana.';

  @override
  String get demoFilterChipTitle => 'Chipu ya Kichujio';

  @override
  String get demoFilterChipDescription =>
      'Chipu za kuchuja hutumia lebo au maneno ya ufafanuzi kama mbinu ya kuchuja maudhui.';

  @override
  String get demoInputChipTitle => 'Chipu ya Kuingiza';

  @override
  String get demoInputChipDescription =>
      'Chipu za kuingiza huwakilisha taarifa ya kina, kama vile huluki (mtu, mahali au kitu) au maandishi ya mazungumzo katika muundo wa kushikamana.';

  @override
  String get demoDataTableTitle => 'Majedwali ya Data';

  @override
  String get demoDataTableSubtitle => 'Safu mlalo na wima za maelezo';

  @override
  String get demoDataTableDescription =>
      'Majedwali ya data huonyesha maelezo katika muundo wa gridi ya safu mlalo na safu wima. Hupanga maelezo kwa njia ambayo ni rahisi kukagua, ili watumiaji waweze kutafuta mitindo na maarifa.';

  @override
  String get dataTableHeader => 'Lishe';

  @override
  String get dataTableColumnDessert => 'Kitindamlo (sahani 1)';

  @override
  String get dataTableColumnCalories => 'Kalori';

  @override
  String get dataTableColumnFat => 'Mafuta (g)';

  @override
  String get dataTableColumnCarbs => 'Kabohaidreti (g)';

  @override
  String get dataTableColumnProtein => 'Protini (g)';

  @override
  String get dataTableColumnSodium => 'Sodiamu (miligramu)';

  @override
  String get dataTableColumnCalcium => 'Kalisi (%)';

  @override
  String get dataTableColumnIron => 'Chuma (%)';

  @override
  String get dataTableRowFrozenYogurt => 'Frozen yogurt';

  @override
  String get dataTableRowIceCreamSandwich => 'Ice cream sandwich';

  @override
  String get dataTableRowEclair => 'Eclair';

  @override
  String get dataTableRowCupcake => 'Cupcake';

  @override
  String get dataTableRowGingerbread => 'Gingerbread';

  @override
  String get dataTableRowJellyBean => 'Jelly bean';

  @override
  String get dataTableRowLollipop => 'Lollipop';

  @override
  String get dataTableRowHoneycomb => 'Honeycomb';

  @override
  String get dataTableRowDonut => 'Donut';

  @override
  String get dataTableRowApplePie => 'Apple pie';

  @override
  String dataTableRowWithSugar(Object value) {
    return '${value} yenye sukari';
  }

  @override
  String dataTableRowWithHoney(Object value) {
    return '${value} yenye asali';
  }

  @override
  String get demoDialogTitle => 'Vidirisha';

  @override
  String get demoDialogSubtitle => 'Rahisi, arifa na skrini nzima';

  @override
  String get demoAlertDialogTitle => 'Arifa';

  @override
  String get demoAlertDialogDescription =>
      'Kidirisha cha arifa humjulisha mtumiaji kuhusu hali zinazohitaji uthibitisho. Kidirisha cha arifa kina kichwa kisicho cha lazima na orodha isiyo ya lazima ya vitendo.';

  @override
  String get demoAlertTitleDialogTitle => 'Arifa Yenye Jina';

  @override
  String get demoSimpleDialogTitle => 'Rahisi';

  @override
  String get demoSimpleDialogDescription =>
      'Kidirisha rahisi humpa mtumiaji chaguo kati ya chaguo nyingi. Kidirisha rahisi kina kichwa kisicho cha lazima kinachoonyeshwa juu ya chaguo.';

  @override
  String get demoGridListsTitle => 'Orodha za Gridi';

  @override
  String get demoGridListsSubtitle => 'Muundo wa safu mlalo na safu wima';

  @override
  String get demoGridListsDescription =>
      'Orodha za Gridi zinafaa zaidi kwa kuwasilisha data ya aina moja, picha kwa kawaida. Kila kipengee katika orodha ya gridi huitwa kigae.';

  @override
  String get demoGridListsImageOnlyTitle => 'Picha pekee';

  @override
  String get demoGridListsHeaderTitle => 'Yenye vijajuu';

  @override
  String get demoGridListsFooterTitle => 'Yenye vijachini';

  @override
  String get demoSlidersTitle => 'Vitelezi';

  @override
  String get demoSlidersSubtitle =>
      'Wijeti za kuchagua thamani kwa kutelezesha kidole';

  @override
  String get demoSlidersDescription =>
      'Vitelezi huonyesha thamani mbalimbali kwenye upau, ambapo watumiaji wanaweza kuchagua thamani moja. Hutumika kurekebisha mipangilio kama vile kiwango cha sauti, mwangaza au kutumia vichujio vya picha.';

  @override
  String get demoRangeSlidersTitle => 'Vitelezi vya Fungu la Visanduku';

  @override
  String get demoRangeSlidersDescription =>
      'Vitelezi huonyesha thamani mbalimbali kwenye upau. Vinaweza kuwa na aikoni kwenye pande zote za upau zinazoonyesha thamani mbalimbali. Hutumika kurekebisha mipangilio kama vile kiwango cha sauti, mwangaza au kutumia vichujio vya picha.';

  @override
  String get demoCustomSlidersTitle => 'Vitelezi Maalum';

  @override
  String get demoCustomSlidersDescription =>
      'Vitelezi huonyesha thamani mbalimbali kwenye upau, ambapo watumiaji wanaweza kuchagua thamani moja au thamani mbalimbali. Unaweza kuwekea vitelezi mapendeleo na dhamira.';

  @override
  String get demoSlidersContinuousWithEditableNumericalValue =>
      'Endelevu yenye Thamani ya Nambari Inayoweza Kubadilishwa';

  @override
  String get demoSlidersDiscrete => 'Zenye kikomo';

  @override
  String get demoSlidersDiscreteSliderWithCustomTheme =>
      'Kitelezi chenye Kikomo kilicho na Mandhari Maalum';

  @override
  String get demoSlidersContinuousRangeSliderWithCustomTheme =>
      'Kitelezi cha Fungu Endelevu la Visanduku chenye Mandhari Maalum';

  @override
  String get demoSlidersContinuous => 'Endelevu';

  @override
  String get demoSlidersEditableNumericalValue =>
      'Thamani ya nambari inayoweza kubadilishwa';

  @override
  String get demoMenuTitle => 'Menyu';

  @override
  String get demoContextMenuTitle => 'Menyu';

  @override
  String get demoSectionedMenuTitle => 'Menyu yenye vijisehemu';

  @override
  String get demoSimpleMenuTitle => 'Menyu sahili';

  @override
  String get demoChecklistMenuTitle => 'Menyu ya orodha hakikishi';

  @override
  String get demoMenuSubtitle => 'Vitufe vya menyu na menyu sahili';

  @override
  String get demoMenuDescription =>
      'Menyu huonyesha orodha ya chaguo kwenye sehemu ya muda mfupi. Huonekana watumiaji wanapotumia kitufe, kitendo au kidhibiti kingine.';

  @override
  String get demoMenuItemValueOne => 'Kipengee cha kwanza cha menyu';

  @override
  String get demoMenuItemValueTwo => 'Kipengee cha pili cha menyu';

  @override
  String get demoMenuItemValueThree => 'Kipengee cha tatu cha menyu';

  @override
  String get demoMenuOne => 'Moja';

  @override
  String get demoMenuTwo => 'Mbili';

  @override
  String get demoMenuThree => 'Tatu';

  @override
  String get demoMenuFour => 'Nne';

  @override
  String get demoMenuAnItemWithAContextMenuButton => 'Kipengee chenye menyu';

  @override
  String get demoMenuContextMenuItemOne => 'Kipengee cha kwanza cha menyu';

  @override
  String get demoMenuADisabledMenuItem => 'Kipengee cha menyu kilichozimwa';

  @override
  String get demoMenuContextMenuItemThree => 'Kipengee cha tatu cha menyu';

  @override
  String get demoMenuAnItemWithASectionedMenu =>
      'Kipengee chenye menyu ya vijisehemu';

  @override
  String get demoMenuPreview => 'Kagua kwanza';

  @override
  String get demoMenuShare => 'Shiriki';

  @override
  String get demoMenuGetLink => 'Pata kiungo';

  @override
  String get demoMenuRemove => 'Ondoa';

  @override
  String demoMenuSelected(Object value) {
    return 'Imechaguliwa: ${value}';
  }

  @override
  String demoMenuChecked(Object value) {
    return 'Imeteuliwa: ${value}';
  }

  @override
  String get demoMenuAnItemWithASimpleMenu => 'Kipengee chenye menyu sahili';

  @override
  String get demoMenuAnItemWithAChecklistMenu =>
      'Kipengee chenye menyu ya orodha hakikishi';

  @override
  String get demoFullscreenDialogTitle => 'Skrini nzima';

  @override
  String get demoFullscreenDialogDescription =>
      'Sifa ya fullscreenDialog hubainisha iwapo ukurasa ujao ni wa kidirisha cha kawaida cha skrini nzima';

  @override
  String get demoCupertinoActivityIndicatorTitle => 'Kiashirio cha shughuli';

  @override
  String get demoCupertinoActivityIndicatorSubtitle =>
      'Viashirio vya shughuli vya muundo wa iOS';

  @override
  String get demoCupertinoActivityIndicatorDescription =>
      'Kiashirio cha shughuli cha muundo wa iOS chenye mzunguko wa saa.';

  @override
  String get demoCupertinoButtonsTitle => 'Vitufe';

  @override
  String get demoCupertinoButtonsSubtitle => 'Vitufe vya muundo wa iOS';

  @override
  String get demoCupertinoButtonsDescription =>
      'Kitufe cha muundo wa iOS. Huchukua maandishi na/au aikoni ambayo hufifia nje na ndani inapoguswa. Huenda kwa hiari ikawa na mandharinyuma.';

  @override
  String get demoCupertinoAlertsTitle => 'Arifa';

  @override
  String get demoCupertinoAlertsSubtitle =>
      'Vidirisha vya arifa vya muundo wa iOS.';

  @override
  String get demoCupertinoAlertTitle => 'Arifa';

  @override
  String get demoCupertinoAlertDescription =>
      'Kidirisha cha arifa humjulisha mtumiaji kuhusu hali zinazohitaji uthibitisho. Kidirisha cha arifa kina kichwa kisicho cha lazima, maudhui yasiyo ya lazima na orodha isiyo ya lazima ya vitendo. Kichwa huonyeshwa juu ya maudhui na vitendo huonyeshwa chini ya maudhui.';

  @override
  String get demoCupertinoAlertWithTitleTitle => 'Arifa Yenye Kichwa';

  @override
  String get demoCupertinoAlertButtonsTitle => 'Arifa Zenye Vitufe';

  @override
  String get demoCupertinoAlertButtonsOnlyTitle => 'Vitufe vya Arifa Pekee';

  @override
  String get demoCupertinoActionSheetTitle => 'Laha la Kutenda';

  @override
  String get demoCupertinoActionSheetDescription =>
      'Laha ya kutenda ni muundo mahususi wa arifa unaompa mtumiaji seti ya chaguo mbili au zaidi zinazohusiana na muktadha wa sasa. Laha ya kutenda inaweza kuwa na kichwa, ujumbe wa ziada na orodha ya vitendo.';

  @override
  String get demoCupertinoNavigationBarTitle => 'Sehemu ya viungo muhimu';

  @override
  String get demoCupertinoNavigationBarSubtitle =>
      'Sehemu ya viungo muhimu ya muundo wa iOs';

  @override
  String get demoCupertinoNavigationBarDescription =>
      'Sehemu ya viungo muhimu ya muundo wa iOS. Sehemu ya viungo muhimu ni upau wa vidhibiti ambao kwa kiasi kidogo una kichwa cha ukurasa, katikati ya upau wa vidhibiti.';

  @override
  String get demoCupertinoPickerTitle => 'Viteua';

  @override
  String get demoCupertinoPickerSubtitle =>
      'Viteua vya tarehe na wakati vya muundo wa iOS';

  @override
  String get demoCupertinoPickerDescription =>
      'Wijeti ya kiteua ya muundo wa iOS inayoweza kutumika ili kuchagua tarehe, wakati au tarehe pamoja na wakati.';

  @override
  String get demoCupertinoPickerTimer => 'Kipima muda';

  @override
  String get demoCupertinoPickerDate => 'Tarehe';

  @override
  String get demoCupertinoPickerTime => 'Wakati';

  @override
  String get demoCupertinoPickerDateTime => 'Tarehe na Wakati';

  @override
  String get demoCupertinoPullToRefreshTitle => 'Vuta ili uonyeshe upya';

  @override
  String get demoCupertinoPullToRefreshSubtitle =>
      'Kidhibiti cha \"vuta ili uonyeshe upya\" cha muundo wa iOS';

  @override
  String get demoCupertinoPullToRefreshDescription =>
      'Wijeti inayotekeleza kidhibiti cha maudhui cha \"vuta ili uonyeshe upya\" cha muundo wa iOS.';

  @override
  String get demoCupertinoSegmentedControlTitle => 'Udhibiti wa vikundi';

  @override
  String get demoCupertinoSegmentedControlSubtitle =>
      'Udhibiti wa vikundi vya muundo wa iOS';

  @override
  String get demoCupertinoSegmentedControlDescription =>
      'Hutumika kuchagua kati ya chaguo kadhaa za kipekee. Chaguo moja katika udhibiti wa vikundi ikichaguliwa, chaguo zingine katika udhibiti wa vikundi hazitachaguliwa.';

  @override
  String get demoCupertinoSliderTitle => 'Kitelezi';

  @override
  String get demoCupertinoSliderSubtitle => 'Kitelezi cha muundo wa iOS';

  @override
  String get demoCupertinoSliderDescription =>
      'Kitelezi kinaweza kutumiwa ili kuchagua kati ya seti za thamani endelevu au zenye kikomo.';

  @override
  String demoCupertinoSliderContinuous(Object value) {
    return 'Endelevu: ${value}';
  }

  @override
  String demoCupertinoSliderDiscrete(Object value) {
    return 'Zenye kikomo: ${value}';
  }

  @override
  String get demoCupertinoSwitchSubtitle => 'Swichi ya muundo wa iOS';

  @override
  String get demoCupertinoSwitchDescription =>
      'Swichi inatumika kugeuza hali ya kuwasha/kuzima ya chaguo moja la mipangilio.';

  @override
  String get demoCupertinoTabBarTitle => 'Upao wa kichupo';

  @override
  String get demoCupertinoTabBarSubtitle =>
      'Upau wa kichupo wa upande wa chini wa muundo wa iOS';

  @override
  String get demoCupertinoTabBarDescription =>
      'Upau wa kichupo cha kusogeza wa upande wa chini wa muundo wa iOS. Huonyesha vichupo vingi huku kichupo kimoja kikitumika, kichupo cha kwanza kwa chaguomsingi.';

  @override
  String get cupertinoTabBarHomeTab => 'Skrini ya kwanza';

  @override
  String get cupertinoTabBarChatTab => 'Piga gumzo';

  @override
  String get cupertinoTabBarProfileTab => 'Wasifu';

  @override
  String get demoCupertinoTextFieldTitle => 'Sehemu za maandishi';

  @override
  String get demoCupertinoTextFieldSubtitle =>
      'Sehemu za maandishi za muundo wa iOS';

  @override
  String get demoCupertinoTextFieldDescription =>
      'Sehemu ya maandishi humruhusu mtumiaji kuweka maandishi, kwa kutumia kibodi ya maunzi au kutumia kibodi iliyo kwenye skrini.';

  @override
  String get demoCupertinoTextFieldPIN => 'PIN';

  @override
  String get demoMotionTitle => 'Motion';

  @override
  String get demoMotionSubtitle => 'All of the predefined transition patterns';

  @override
  String get demoContainerTransformTitle => 'Container Transform';

  @override
  String get demoContainerTransformDescription =>
      'The container transform pattern is designed for transitions between UI elements that include a container. This pattern creates a visible connection between two UI elements';

  @override
  String get demoContainerTransformModalBottomSheetTitle => 'Fade mode';

  @override
  String get demoContainerTransformTypeFade => 'FADE';

  @override
  String get demoContainerTransformTypeFadeThrough => 'FADE THROUGH';

  @override
  String get demoMotionPlaceholderTitle => 'Title';

  @override
  String get demoMotionPlaceholderSubtitle => 'Secondary text';

  @override
  String get demoMotionSmallPlaceholderSubtitle => 'Secondary';

  @override
  String get demoMotionDetailsPageTitle => 'Details Page';

  @override
  String get demoMotionListTileTitle => 'List item';

  @override
  String get demoSharedAxisDescription =>
      'The shared axis pattern is used for transitions between the UI elements that have a spatial or navigational relationship. This pattern uses a shared transformation on the x, y, or z axis to reinforce the relationship between elements.';

  @override
  String get demoSharedXAxisTitle => 'Shared x-axis';

  @override
  String get demoSharedXAxisBackButtonText => 'BACK';

  @override
  String get demoSharedXAxisNextButtonText => 'NEXT';

  @override
  String get demoSharedXAxisCoursePageTitle => 'Streamline your courses';

  @override
  String get demoSharedXAxisCoursePageSubtitle =>
      'Bundled categories appear as groups in your feed. You can always change this later.';

  @override
  String get demoSharedXAxisArtsAndCraftsCourseTitle => 'Arts & Crafts';

  @override
  String get demoSharedXAxisBusinessCourseTitle => 'Business';

  @override
  String get demoSharedXAxisIllustrationCourseTitle => 'Illustration';

  @override
  String get demoSharedXAxisDesignCourseTitle => 'Design';

  @override
  String get demoSharedXAxisCulinaryCourseTitle => 'Culinary';

  @override
  String get demoSharedXAxisBundledCourseSubtitle => 'Bundled';

  @override
  String get demoSharedXAxisIndividualCourseSubtitle => 'Shown Individually';

  @override
  String get demoSharedXAxisSignInWelcomeText => 'Hi David Park';

  @override
  String get demoSharedXAxisSignInSubtitleText => 'Sign in with your account';

  @override
  String get demoSharedXAxisSignInTextFieldLabel => 'Email or phone number';

  @override
  String get demoSharedXAxisForgotEmailButtonText => 'FORGOT EMAIL?';

  @override
  String get demoSharedXAxisCreateAccountButtonText => 'CREATE ACCOUNT';

  @override
  String get demoSharedYAxisTitle => 'Shared y-axis';

  @override
  String get demoSharedYAxisAlbumCount => '268 albums';

  @override
  String get demoSharedYAxisAlphabeticalSortTitle => 'A-Z';

  @override
  String get demoSharedYAxisRecentSortTitle => 'Recently played';

  @override
  String get demoSharedYAxisAlbumTileTitle => 'Album';

  @override
  String get demoSharedYAxisAlbumTileSubtitle => 'Artist';

  @override
  String get demoSharedYAxisAlbumTileDurationUnit => 'min';

  @override
  String get demoSharedZAxisTitle => 'Shared z-axis';

  @override
  String get demoSharedZAxisSettingsPageTitle => 'Settings';

  @override
  String get demoSharedZAxisBurgerRecipeTitle => 'Burger';

  @override
  String get demoSharedZAxisBurgerRecipeDescription => 'Burger recipe';

  @override
  String get demoSharedZAxisSandwichRecipeTitle => 'Sandwich';

  @override
  String get demoSharedZAxisSandwichRecipeDescription => 'Sandwich recipe';

  @override
  String get demoSharedZAxisDessertRecipeTitle => 'Dessert';

  @override
  String get demoSharedZAxisDessertRecipeDescription => 'Dessert recipe';

  @override
  String get demoSharedZAxisShrimpPlateRecipeTitle => 'Shrimp';

  @override
  String get demoSharedZAxisShrimpPlateRecipeDescription =>
      'Shrimp plate recipe';

  @override
  String get demoSharedZAxisCrabPlateRecipeTitle => 'Crab';

  @override
  String get demoSharedZAxisCrabPlateRecipeDescription => 'Crab plate recipe';

  @override
  String get demoSharedZAxisBeefSandwichRecipeTitle => 'Beef Sandwich';

  @override
  String get demoSharedZAxisBeefSandwichRecipeDescription =>
      'Beef Sandwich recipe';

  @override
  String get demoSharedZAxisSavedRecipesListTitle => 'Saved Recipes';

  @override
  String get demoSharedZAxisProfileSettingLabel => 'Profile';

  @override
  String get demoSharedZAxisNotificationSettingLabel => 'Notifications';

  @override
  String get demoSharedZAxisPrivacySettingLabel => 'Privacy';

  @override
  String get demoSharedZAxisHelpSettingLabel => 'Help';

  @override
  String get demoFadeThroughTitle => 'Fade through';

  @override
  String get demoFadeThroughDescription =>
      'The fade through pattern is used for transitions between UI elements that do not have a strong relationship to each other.';

  @override
  String get demoFadeThroughAlbumsDestination => 'Albums';

  @override
  String get demoFadeThroughPhotosDestination => 'Photos';

  @override
  String get demoFadeThroughSearchDestination => 'Search';

  @override
  String get demoFadeThroughTextPlaceholder => '123 photos';

  @override
  String get demoFadeScaleTitle => 'Fade';

  @override
  String get demoFadeScaleDescription =>
      'The fade pattern is used for UI elements that enter or exit within the bounds of the screen, such as a dialog that fades in the center of the screen.';

  @override
  String get demoFadeScaleShowAlertDialogButton => 'SHOW MODAL';

  @override
  String get demoFadeScaleShowFabButton => 'SHOW FAB';

  @override
  String get demoFadeScaleHideFabButton => 'HIDE FAB';

  @override
  String get demoFadeScaleAlertDialogHeader => 'Alert Dialog';

  @override
  String get demoFadeScaleAlertDialogCancelButton => 'CANCEL';

  @override
  String get demoFadeScaleAlertDialogDiscardButton => 'DISCARD';

  @override
  String get demoColorsTitle => 'Rangi';

  @override
  String get demoColorsSubtitle => 'Rangi zote zilizobainishwa mapema';

  @override
  String get demoColorsDescription =>
      'Rangi na seti ya rangi isiyobadilika ambayo inawakilisha safu ya rangi ya Usanifu Bora.';

  @override
  String get demoTypographyTitle => 'Taipografia';

  @override
  String get demoTypographySubtitle =>
      'Miundo yote ya maandishi iliyobainishwa';

  @override
  String get demoTypographyDescription =>
      'Ufafanuzi wa miundo mbalimbali ya taipografia inayopatikana katika Usanifu Bora.';

  @override
  String get demo2dTransformationsTitle => 'Ubadilishaji wa 2D';

  @override
  String get demo2dTransformationsSubtitle => 'Geuza upande, kuza, zungusha';

  @override
  String get demo2dTransformationsDescription =>
      'Gusa ili ubadilishe vigae na utumie ishara kusogea hapa na pale kwenye tukio. Buruta ili ugeuze upande, bana ili ukuze, zungusha ukitumia vidole viwili. Bonyeza kitufe cha kuweka upya ili urejeshe kwenye mkao wa kuanza.';

  @override
  String get demo2dTransformationsResetTooltip => 'Weka upya ubadilishaji';

  @override
  String get demo2dTransformationsEditTooltip => 'Badilisha kigae';

  @override
  String get buttonText => 'KITUFE';

  @override
  String get demoBottomSheetTitle => 'Laha ya chini';

  @override
  String get demoBottomSheetSubtitle => 'Laha za kawaida na endelevu za chini';

  @override
  String get demoBottomSheetPersistentTitle => 'Laha endelevu ya chini';

  @override
  String get demoBottomSheetPersistentDescription =>
      'Laha endelevu ya chini huonyesha maelezo yanayojaliza maudhui ya msingi ya programu. Laha endelevu ya chini huendelea kuonekana hata wakati mtumiaji anatumia sehemu zingine za programu.';

  @override
  String get demoBottomSheetModalTitle => 'Laha ya kawaida ya chini';

  @override
  String get demoBottomSheetModalDescription =>
      'Laha ya kawaida ya chini ni mbadala wa menyu au kidirisha na humzuia mtumiaji kutumia sehemu inayosalia ya programu.';

  @override
  String get demoBottomSheetAddLabel => 'Ongeza';

  @override
  String get demoBottomSheetButtonText => 'ONYESHA LAHA YA CHINI';

  @override
  String get demoBottomSheetHeader => 'Kijajuu';

  @override
  String demoBottomSheetItem(Object value) {
    return 'Bidhaa ya ${value}';
  }

  @override
  String get demoListsTitle => 'Orodha';

  @override
  String get demoListsSubtitle => 'Miundo ya orodha za kusogeza';

  @override
  String get demoListsDescription =>
      'Safu wima moja ya urefu usiobadilika ambayo kwa kawaida ina baadhi ya maandishi na pia aikoni ya mwanzoni au mwishoni.';

  @override
  String get demoOneLineListsTitle => 'Mstari Mmoja';

  @override
  String get demoTwoLineListsTitle => 'Mistari Miwili';

  @override
  String get demoListsSecondary => 'Maandishi katika mstari wa pili';

  @override
  String get demoProgressIndicatorTitle => 'Viashirio vya shughuli';

  @override
  String get demoProgressIndicatorSubtitle =>
      'Cha mstari, cha mviringo, kisichopimika';

  @override
  String get demoCircularProgressIndicatorTitle =>
      'Kiashirio cha Shughuli cha Mduara';

  @override
  String get demoCircularProgressIndicatorDescription =>
      'Kiashirio cha Usanifu Bora cha shughuli cha mduara, kinachozunguka kuonyesha kuwa programu inatumika.';

  @override
  String get demoLinearProgressIndicatorTitle =>
      'Kiashirio cha Shughuli cha Mstari';

  @override
  String get demoLinearProgressIndicatorDescription =>
      'Kiashirio cha Usanifu Bora cha shughuli cha mstari, pia huitwa upau wa shughuli.';

  @override
  String get demoPickersTitle => 'Viteua';

  @override
  String get demoPickersSubtitle => 'Kuchagua tarehe na wakati';

  @override
  String get demoDatePickerTitle => 'Kiteua Tarehe';

  @override
  String get demoDatePickerDescription =>
      'Huonyesha kidirisha chenye kiteua tarehe cha Usanifu Bora.';

  @override
  String get demoTimePickerTitle => 'Kiteua Wakati';

  @override
  String get demoTimePickerDescription =>
      'Huonyesha kidirisha chenye kiteua wakati cha Usanifu Bora.';

  @override
  String get demoPickersShowPicker => 'ONYESHA KITEUA';

  @override
  String get demoTabsTitle => 'Vichupo';

  @override
  String get demoTabsScrollingTitle => 'Inayosogeza';

  @override
  String get demoTabsNonScrollingTitle => 'Isiyosogeza';

  @override
  String get demoTabsSubtitle =>
      'Vichupo vyenye mionekano huru inayoweza kusogezwa';

  @override
  String get demoTabsDescription =>
      'Vichupo hupanga maudhui kwenye skrini tofauti, seti za data na shughuli zingine.';

  @override
  String get demoSnackbarsTitle => 'Vidirisha vya arifa';

  @override
  String get demoSnackbarsSubtitle =>
      'Vidirisha vya arifa huonyesha ujumbe katika sehemu ya chini ya skrini';

  @override
  String get demoSnackbarsDescription =>
      'Vidirisha vya arifa huwajulisha watumiaji kuhusu mchakato ambao programu imetekeleza au itatekeleza. Huonekana kwa muda mfupi, kuelekea sehemu ya chini ya skrini. Havifai kusumbua hali ya utumiaji, na havihitaji mtumiaji achukue hatua yoyote ili viondoke.';

  @override
  String get demoSnackbarsButtonLabel => 'ONYESHA KIDIRISHA CHA ARIFA';

  @override
  String get demoSnackbarsText => 'Hiki ni kidirisha cha arifa.';

  @override
  String get demoSnackbarsActionButtonLabel => 'KITENDO';

  @override
  String get demoSnackbarsAction =>
      'Umebonyeza kitendo cha kidirisha cha arifa.';

  @override
  String get demoSelectionControlsTitle => 'Vidhibiti vya kuteua';

  @override
  String get demoSelectionControlsSubtitle =>
      'Visanduku vya kuteua, vitufe vya mviringo na swichi';

  @override
  String get demoSelectionControlsCheckboxTitle => 'Kisanduku cha kuteua';

  @override
  String get demoSelectionControlsCheckboxDescription =>
      'Visanduku vya kuteua humruhusu mtumiaji kuteua chaguo nyingi kwenye seti. Thamani ya kawaida ya kisanduku cha kuteua ni ndivyo au saivyo na thamani ya hali tatu ya kisanduku cha kuteua pia inaweza kuwa batili.';

  @override
  String get demoSelectionControlsRadioTitle => 'Redio';

  @override
  String get demoSelectionControlsRadioDescription =>
      'Vitufe vya mviringo humruhusu mtumiaji kuteua chaguo moja kwenye seti. Tumia vitufe vya mviringo kwa uteuzi wa kipekee ikiwa unafikiri kuwa mtumiaji anahitaji kuona chaguo zote upande kwa upande.';

  @override
  String get demoSelectionControlsSwitchTitle => 'Swichi';

  @override
  String get demoSelectionControlsSwitchDescription =>
      'Swichi za kuwasha/kuzima hugeuza hali ya chaguo moja la mipangilio. Chaguo ambalo swichi inadhibiti na pia hali ambayo chaguo hilo limo inafaa kubainishwa wazi kwenye lebo inayolingana na maandishi.';

  @override
  String get demoBottomTextFieldsTitle => 'Sehemu za maandishi';

  @override
  String get demoTextFieldTitle => 'Sehemu za maandishi';

  @override
  String get demoTextFieldSubtitle =>
      'Mstari mmoja wa maandishi na nambari zinazoweza kubadilishwa';

  @override
  String get demoTextFieldDescription =>
      'Sehemu za maandishi huwaruhusu watumiaji kuweka maandishi kwenye kiolesura. Kwa kawaida huwa zinaonekana katika fomu na vidirisha.';

  @override
  String get demoTextFieldShowPasswordLabel => 'Onyesha nenosiri';

  @override
  String get demoTextFieldHidePasswordLabel => 'Ficha nenosiri';

  @override
  String get demoTextFieldFormErrors =>
      'Tafadhali tatua hitilafu zilizo katika rangi nyekundu kabla ya kuwasilisha.';

  @override
  String get demoTextFieldNameRequired => 'Ni sharti ujaze jina.';

  @override
  String get demoTextFieldOnlyAlphabeticalChars =>
      'Tafadhali weka herufi za kialfabeti pekee.';

  @override
  String get demoTextFieldEnterUSPhoneNumber =>
      '(###) ###-#### - Weka nambari ya simu ya Marekani.';

  @override
  String get demoTextFieldEnterPassword => 'Tafadhali weka nenosiri.';

  @override
  String get demoTextFieldPasswordsDoNotMatch => 'Manenosiri hayalingani';

  @override
  String get demoTextFieldWhatDoPeopleCallYou => 'Je, watu hukuitaje?';

  @override
  String get demoTextFieldNameField => 'Jina*';

  @override
  String get demoTextFieldWhereCanWeReachYou =>
      'Je, tunawezaje kuwasiliana nawe?';

  @override
  String get demoTextFieldPhoneNumber => 'Nambari ya simu*';

  @override
  String get demoTextFieldYourEmailAddress => 'Anwani yako ya barua pepe';

  @override
  String get demoTextFieldEmail => 'Barua pepe';

  @override
  String get demoTextFieldTellUsAboutYourself =>
      'Tueleze kukuhusu (k.m., andika kazi unayofanya au mambo unayopenda kupitishia muda)';

  @override
  String get demoTextFieldKeepItShort =>
      'Tumia herufi chache, hili ni onyesho tu.';

  @override
  String get demoTextFieldLifeStory => 'Hadithi ya wasifu';

  @override
  String get demoTextFieldSalary => 'Mshahara';

  @override
  String get demoTextFieldUSD => 'USD';

  @override
  String get demoTextFieldNoMoreThan => 'Zisizozidi herufi 8.';

  @override
  String get demoTextFieldPassword => 'Nenosiri*';

  @override
  String get demoTextFieldRetypePassword => 'Andika tena nenosiri*';

  @override
  String get demoTextFieldSubmit => 'TUMA';

  @override
  String demoTextFieldNameHasPhoneNumber(Object name, Object phoneNumber) {
    return 'Nambari ya simu ya ${name} ni ${phoneNumber}';
  }

  @override
  String get demoTextFieldRequiredField =>
      '* inaonyesha sehemu ambayo sharti ijazwe';

  @override
  String get demoTooltipTitle => 'Vidirisha vya vidokezo';

  @override
  String get demoTooltipSubtitle =>
      'Ujumbe mfupi unaoonyeshwa ukibonyeza kwa muda mrefu au kuelea juu';

  @override
  String get demoTooltipDescription =>
      'Vidirisha vya vidokezo hutoa lebo za matini zinazosaidia kueleza umuhimu wa kitufe au kitendo kingine cha kiolesura. Vidirisha vya vidokezo huonyesha matini ya maelezo watumiaji wanapoelea, lenga au kubonyeza kipengee kwa muda mrefu.';

  @override
  String get demoTooltipInstructions =>
      'Bonyeza kwa muda mrefu au uelee ili uonyeshe kidirisha cha vidokezo.';

  @override
  String get bottomNavigationCommentsTab => 'Maoni';

  @override
  String get bottomNavigationCalendarTab => 'Kalenda';

  @override
  String get bottomNavigationAccountTab => 'Akaunti';

  @override
  String get bottomNavigationAlarmTab => 'Kengele';

  @override
  String get bottomNavigationCameraTab => 'Kamera';

  @override
  String bottomNavigationContentPlaceholder(Object title) {
    return 'Kishikilia nafasi cha kichupo cha ${title}';
  }

  @override
  String get buttonTextCreate => 'Fungua';

  @override
  String dialogSelectedOption(Object value) {
    return 'Umechagua: \"${value}\"';
  }

  @override
  String get chipTurnOnLights => 'Washa taa';

  @override
  String get chipSmall => 'Ndogo';

  @override
  String get chipMedium => 'Wastani';

  @override
  String get chipLarge => 'Kubwa';

  @override
  String get chipElevator => 'Lifti';

  @override
  String get chipWasher => 'Mashine ya kufua nguo';

  @override
  String get chipFireplace => 'Mekoni';

  @override
  String get chipBiking => 'Kuendesha baiskeli';

  @override
  String get dialogDiscardTitle => 'Ungependa kufuta rasimu?';

  @override
  String get dialogLocationTitle =>
      'Ungependa kutumia huduma ya mahali ya Google?';

  @override
  String get dialogLocationDescription =>
      'Ruhusu Google isaidie programu kutambua mahali. Hii inamaanisha kutuma data isiyokutambulisha kwa Google, hata wakati hakuna programu zinazotumika.';

  @override
  String get dialogCancel => 'GHAIRI';

  @override
  String get dialogDiscard => 'ONDOA';

  @override
  String get dialogDisagree => 'KATAA';

  @override
  String get dialogAgree => 'KUBALI';

  @override
  String get dialogSetBackup => 'Weka akaunti ya kuhifadhi nakala';

  @override
  String get dialogAddAccount => 'Ongeza akaunti';

  @override
  String get dialogShow => 'ONYESHA KIDIRISHA';

  @override
  String get dialogFullscreenTitle => 'Kidirisha cha Skrini Nzima';

  @override
  String get dialogFullscreenSave => 'HIFADHI';

  @override
  String get dialogFullscreenDescription =>
      'Onyesho la kidirisha cha skrini nzima';

  @override
  String get cupertinoButton => 'Kitufe';

  @override
  String get cupertinoButtonWithBackground => 'Na Mandharinyuma';

  @override
  String get cupertinoAlertCancel => 'Ghairi';

  @override
  String get cupertinoAlertDiscard => 'Ondoa';

  @override
  String get cupertinoAlertLocationTitle =>
      'Ungependa kuruhusu \"Ramani\" zifikie maelezo ya mahali ulipo unapotumia programu?';

  @override
  String get cupertinoAlertLocationDescription =>
      'Mahali ulipo sasa pataonyeshwa kwenye ramani na kutumiwa kwa maelekezo, matokeo ya utafutaji wa karibu na muda uliokadiriwa wa kusafiri.';

  @override
  String get cupertinoAlertAllow => 'Ruhusu';

  @override
  String get cupertinoAlertDontAllow => 'Usiruhusu';

  @override
  String get cupertinoAlertFavoriteDessert => 'Chagua Kitindamlo Unachopenda';

  @override
  String get cupertinoAlertDessertDescription =>
      'Tafadhali chagua aina unayoipenda ya kitindamlo kwenye orodha iliyo hapa chini. Uteuzi wako utatumiwa kuweka mapendeleo kwenye orodha iliyopendekezwa ya mikahawa katika eneo lako.';

  @override
  String get cupertinoAlertCheesecake => 'Keki ya jibini';

  @override
  String get cupertinoAlertTiramisu => 'Tiramisu';

  @override
  String get cupertinoAlertApplePie => 'Mkate wa Tufaha';

  @override
  String get cupertinoAlertChocolateBrownie => 'Keki ya Chokoleti';

  @override
  String get cupertinoShowAlert => 'Onyesha Arifa';

  @override
  String get colorsRed => 'NYEKUNDU';

  @override
  String get colorsPink => 'WARIDI';

  @override
  String get colorsPurple => 'ZAMBARAU';

  @override
  String get colorsDeepPurple => 'ZAMBARAU ILIYOKOLEA';

  @override
  String get colorsIndigo => 'NILI';

  @override
  String get colorsBlue => 'SAMAWATI';

  @override
  String get colorsLightBlue => 'SAMAWATI ISIYOKOLEA';

  @override
  String get colorsCyan => 'SAMAWATI-KIJANI';

  @override
  String get colorsTeal => 'SAMAWATI YA KIJANI';

  @override
  String get colorsGreen => 'KIJANI';

  @override
  String get colorsLightGreen => 'KIJANI KISICHOKOLEA';

  @override
  String get colorsLime => 'RANGI YA NDIMU';

  @override
  String get colorsYellow => 'MANJANO';

  @override
  String get colorsAmber => 'KAHARABU';

  @override
  String get colorsOrange => 'RANGI YA MACHUNGWA';

  @override
  String get colorsDeepOrange => 'RANGI YA MACHUNGWA ILIYOKOLEA';

  @override
  String get colorsBrown => 'HUDHURUNGI';

  @override
  String get colorsGrey => 'KIJIVU';

  @override
  String get colorsBlueGrey => 'SAMAWATI YA KIJIVU';

  @override
  String get placeChennai => 'Chennai';

  @override
  String get placeTanjore => 'Tanjore';

  @override
  String get placeChettinad => 'Chettinad';

  @override
  String get placePondicherry => 'Pondicherry';

  @override
  String get placeFlowerMarket => 'Soko la Maua';

  @override
  String get placeBronzeWorks => 'Kazi ya Shaba';

  @override
  String get placeMarket => 'Soko';

  @override
  String get placeThanjavurTemple => 'Hekalu la Thanjavur';

  @override
  String get placeSaltFarm => 'Shamba la Chumvi';

  @override
  String get placeScooters => 'Pikipiki';

  @override
  String get placeSilkMaker => 'Mtengenezaji wa Hariri';

  @override
  String get placeLunchPrep => 'Matayarisho ya Chamcha';

  @override
  String get placeBeach => 'Ufuo';

  @override
  String get placeFisherman => 'Mvuvi';

  @override
  String get starterAppTitle => 'Programu ya kuanza';

  @override
  String get starterAppDescription =>
      'Muundo wa kuanzisha unaobadilika kulingana na kifaa';

  @override
  String get starterAppGenericButton => 'KITUFE';

  @override
  String get starterAppTooltipAdd => 'Ongeza';

  @override
  String get starterAppTooltipFavorite => 'Kipendwa';

  @override
  String get starterAppTooltipShare => 'Shiriki';

  @override
  String get starterAppTooltipSearch => 'Tafuta';

  @override
  String get starterAppGenericTitle => 'Kichwa';

  @override
  String get starterAppGenericSubtitle => 'Kichwa kidogo';

  @override
  String get starterAppGenericHeadline => 'Kichwa';

  @override
  String get starterAppGenericBody => 'Mwili';

  @override
  String starterAppDrawerItem(Object value) {
    return 'Bidhaa ya ${value}';
  }

  @override
  String get shrineMenuCaption => 'MENYU';

  @override
  String get shrineCategoryNameAll => 'ZOTE';

  @override
  String get shrineCategoryNameAccessories => 'VIFUASI';

  @override
  String get shrineCategoryNameClothing => 'MAVAZI';

  @override
  String get shrineCategoryNameHome => 'NYUMBANI';

  @override
  String get shrineLogoutButtonCaption => 'ONDOKA';

  @override
  String get shrineLoginUsernameLabel => 'Jina la mtumiaji';

  @override
  String get shrineLoginPasswordLabel => 'Nenosiri';

  @override
  String get shrineCancelButtonCaption => 'GHAIRI';

  @override
  String get shrineNextButtonCaption => 'ENDELEA';

  @override
  String get shrineCartPageCaption => 'KIKAPU';

  @override
  String shrineProductQuantity(Object quantity) {
    return 'Kiasi: ${quantity}';
  }

  @override
  String shrineProductPrice(Object price) {
    return 'x ${price}';
  }

  @override
  String shrineCartItemCount(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'HAKUNA BIDHAA',
      one: 'BIDHAA 1',
      other: 'BIDHAA ${quantity}',
    );
  }

  @override
  String get shrineCartClearButtonCaption => 'ONDOA KILA KITU KWENYE KIKAPU';

  @override
  String get shrineCartTotalCaption => 'JUMLA';

  @override
  String get shrineCartSubtotalCaption => 'Jumla ndogo:';

  @override
  String get shrineCartShippingCaption => 'Usafirishaji:';

  @override
  String get shrineCartTaxCaption => 'Ushuru:';

  @override
  String get shrineProductVagabondSack => 'Mfuko wa mgongoni';

  @override
  String get shrineProductStellaSunglasses => 'Miwani ya Stella';

  @override
  String get shrineProductWhitneyBelt => 'Mshipi wa Whitney';

  @override
  String get shrineProductGardenStrand => 'Garden strand';

  @override
  String get shrineProductStrutEarrings => 'Herini';

  @override
  String get shrineProductVarsitySocks => 'Soksi za Varsity';

  @override
  String get shrineProductWeaveKeyring => 'Pete ya ufunguo ya Weave';

  @override
  String get shrineProductGatsbyHat => 'Kofia ya Gatsby';

  @override
  String get shrineProductShrugBag => 'Mkoba';

  @override
  String get shrineProductGiltDeskTrio => 'Vifaa vya dawatini';

  @override
  String get shrineProductCopperWireRack => 'Copper wire rack';

  @override
  String get shrineProductSootheCeramicSet => 'Vyombo vya kauri vya Soothe';

  @override
  String get shrineProductHurrahsTeaSet => 'Vyombo vya chai';

  @override
  String get shrineProductBlueStoneMug => 'Magi ya Blue stone';

  @override
  String get shrineProductRainwaterTray => 'Trei ya maji';

  @override
  String get shrineProductChambrayNapkins => 'Kitambaa cha Chambray';

  @override
  String get shrineProductSucculentPlanters => 'Mimea';

  @override
  String get shrineProductQuartetTable => 'Meza';

  @override
  String get shrineProductKitchenQuattro => 'Kitchen quattro';

  @override
  String get shrineProductClaySweater => 'Sweta ya Clay';

  @override
  String get shrineProductSeaTunic => 'Sweta ya kijivu';

  @override
  String get shrineProductPlasterTunic => 'Gwanda la Plaster';

  @override
  String get shrineProductWhitePinstripeShirt => 'Shati nyeupe yenye milia';

  @override
  String get shrineProductChambrayShirt => 'Shati ya Chambray';

  @override
  String get shrineProductSeabreezeSweater => 'Sweta ya Seabreeze';

  @override
  String get shrineProductGentryJacket => 'Jaketi ya ngozi';

  @override
  String get shrineProductNavyTrousers => 'Suruali ya buluu';

  @override
  String get shrineProductWalterHenleyWhite => 'Fulana ya vifungo (nyeupe)';

  @override
  String get shrineProductSurfAndPerfShirt => 'Shati ya Surf and perf';

  @override
  String get shrineProductGingerScarf => 'Skafu ya Ginger';

  @override
  String get shrineProductRamonaCrossover =>
      'Blauzi iliyofunguka kidogo kifuani';

  @override
  String get shrineProductClassicWhiteCollar => 'Blauzi nyeupe ya kawaida';

  @override
  String get shrineProductCeriseScallopTee => 'Fulana ya Cerise';

  @override
  String get shrineProductShoulderRollsTee => 'Fulana ya mikono';

  @override
  String get shrineProductGreySlouchTank => 'Fulana yenye mikono mifupi';

  @override
  String get shrineProductSunshirtDress => 'Nguo';

  @override
  String get shrineProductFineLinesTee => 'Fulana yenye milia';

  @override
  String get shrineTooltipSearch => 'Tafuta';

  @override
  String get shrineTooltipSettings => 'Mipangilio';

  @override
  String get shrineTooltipOpenMenu => 'Fungua menyu';

  @override
  String get shrineTooltipCloseMenu => 'Funga menyu';

  @override
  String get shrineTooltipCloseCart => 'Funga kikapu';

  @override
  String shrineScreenReaderCart(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'Kikapu, hakuna bidhaa',
      one: 'Kikapu, bidhaa 1',
      other: 'Kikapu, bidhaa ${quantity}',
    );
  }

  @override
  String get shrineScreenReaderProductAddToCart => 'Ongeza kwenye kikapu';

  @override
  String shrineScreenReaderRemoveProductButton(Object product) {
    return 'Ondoa ${product}';
  }

  @override
  String get shrineTooltipRemoveItem => 'Ondoa bidhaa';

  @override
  String get craneFormDiners => 'Migahawa';

  @override
  String get craneFormDate => 'Chagua Tarehe';

  @override
  String get craneFormTime => 'Chagua Wakati';

  @override
  String get craneFormLocation => 'Chagua Eneo';

  @override
  String get craneFormTravelers => 'Wasafiri';

  @override
  String get craneFormOrigin => 'Chagua Asili';

  @override
  String get craneFormDestination => 'Chagua Unakoenda';

  @override
  String get craneFormDates => 'Chagua Tarehe';

  @override
  String craneHours(int hours) {
    return intl.Intl.pluralLogic(
      hours,
      locale: localeName,
      one: 'Saa 1',
      other: 'Saa ${hours}',
    );
  }

  @override
  String craneMinutes(int minutes) {
    return intl.Intl.pluralLogic(
      minutes,
      locale: localeName,
      one: 'Dak 1',
      other: 'Dak ${minutes}',
    );
  }

  @override
  String craneFlightDuration(Object hoursShortForm, Object minutesShortForm) {
    return '${hoursShortForm} ${minutesShortForm}';
  }

  @override
  String get craneFly => 'RUKA';

  @override
  String get craneSleep => 'HALI TULI';

  @override
  String get craneEat => 'KULA';

  @override
  String get craneFlySubhead => 'Gundua Ndege kwa Kutumia Vituo';

  @override
  String get craneSleepSubhead => 'Gundua Mali kwa Kutumia Vituo';

  @override
  String get craneEatSubhead => 'Gundua Mikahawa kwa Kutumia Vituo';

  @override
  String craneFlyStops(int numberOfStops) {
    return intl.Intl.pluralLogic(
      numberOfStops,
      locale: localeName,
      zero: 'Moja kwa moja',
      one: 'Kituo 1',
      other: 'Vituo ${numberOfStops}',
    );
  }

  @override
  String craneSleepProperties(int totalProperties) {
    return intl.Intl.pluralLogic(
      totalProperties,
      locale: localeName,
      zero: 'Hakuna Mali Inayopatikana',
      one: 'Mali 1 Inayopatikana',
      other: 'Mali ${totalProperties} Zinazopatikana',
    );
  }

  @override
  String craneEatRestaurants(int totalRestaurants) {
    return intl.Intl.pluralLogic(
      totalRestaurants,
      locale: localeName,
      zero: 'Hakuna Mikahawa',
      one: 'Mkahawa 1',
      other: 'Mikahawa ${totalRestaurants}',
    );
  }

  @override
  String get craneFly0 => 'Aspen, Marekani';

  @override
  String get craneFly1 => 'Big Sur, Marekani';

  @override
  String get craneFly2 => 'Bonde la Khumbu, NepalI';

  @override
  String get craneFly3 => 'Machu Picchu, Peruu';

  @override
  String get craneFly4 => 'Malé, Maldives';

  @override
  String get craneFly5 => 'Vitznau, Uswisi';

  @override
  String get craneFly6 => 'Jiji la Meksiko, Meksiko';

  @override
  String get craneFly7 => 'Mount Rushmore, Marekani';

  @override
  String get craneFly8 => 'Singapoo';

  @override
  String get craneFly9 => 'Havana, Kuba';

  @override
  String get craneFly10 => 'Kairo, Misri';

  @override
  String get craneFly11 => 'Lisbon, Ureno';

  @override
  String get craneFly12 => 'Napa, Marekani';

  @override
  String get craneFly13 => 'Bali, Indonesia';

  @override
  String get craneSleep0 => 'Malé, Maldives';

  @override
  String get craneSleep1 => 'Aspen, Marekani';

  @override
  String get craneSleep2 => 'Machu Picchu, Peruu';

  @override
  String get craneSleep3 => 'Havana, Kuba';

  @override
  String get craneSleep4 => 'Vitznau, Uswisi';

  @override
  String get craneSleep5 => 'Big Sur, Marekani';

  @override
  String get craneSleep6 => 'Napa, Marekani';

  @override
  String get craneSleep7 => 'Porto, Ureno';

  @override
  String get craneSleep8 => 'Tulum, Meksiko';

  @override
  String get craneSleep9 => 'Lisbon, Ureno';

  @override
  String get craneSleep10 => 'Kairo, Misri';

  @override
  String get craneSleep11 => 'Taipei, Taiwani';

  @override
  String get craneEat0 => 'Naples, Italia';

  @override
  String get craneEat1 => 'Dallas, Marekani';

  @override
  String get craneEat2 => 'Córdoba, Ajentina';

  @override
  String get craneEat3 => 'Portland, Marekani';

  @override
  String get craneEat4 => 'Paris, Ufaransa';

  @override
  String get craneEat5 => 'Seoul, Korea Kusini';

  @override
  String get craneEat6 => 'Seattle, Marekani';

  @override
  String get craneEat7 => 'Nashville, Marekani';

  @override
  String get craneEat8 => 'Atlanta, Marekani';

  @override
  String get craneEat9 => 'Madrid, Uhispania';

  @override
  String get craneEat10 => 'Lisbon, Ureno';

  @override
  String get craneFly0SemanticLabel =>
      'Nyumba ndogo ya kupumzika katika mandhari ya theluji yenye miti ya kijani kibichi';

  @override
  String get craneFly1SemanticLabel => 'Hema katika uwanja';

  @override
  String get craneFly2SemanticLabel =>
      'Bendera za maombi mbele ya mlima uliofunikwa kwa theluji';

  @override
  String get craneFly3SemanticLabel => 'Ngome ya Machu Picchu';

  @override
  String get craneFly4SemanticLabel =>
      'Nyumba zisizo na ghorofa zilizojengwa juu ya maji';

  @override
  String get craneFly5SemanticLabel =>
      'Hoteli kando ya ziwa na mbele ya milima';

  @override
  String get craneFly6SemanticLabel =>
      'Mwonekeno wa juu wa Palacio de Bellas Artes';

  @override
  String get craneFly7SemanticLabel => 'Mlima Rushmore';

  @override
  String get craneFly8SemanticLabel => 'Kijisitu cha Supertree';

  @override
  String get craneFly9SemanticLabel =>
      'Mwanaume aliyeegemea gari la kale la samawati';

  @override
  String get craneFly10SemanticLabel =>
      'Minara ya Msikiti wa Al-Azhar wakati wa machweo';

  @override
  String get craneFly11SemanticLabel => 'Mnara wa taa wa matofali baharini';

  @override
  String get craneFly12SemanticLabel => 'Bwawa lenye michikichi';

  @override
  String get craneFly13SemanticLabel =>
      'Bwawa lenye michikichi kando ya bahari';

  @override
  String get craneSleep0SemanticLabel =>
      'Nyumba zisizo na ghorofa zilizojengwa juu ya maji';

  @override
  String get craneSleep1SemanticLabel =>
      'Nyumba ndogo ya kupumzika katika mandhari ya theluji yenye miti ya kijani kibichi';

  @override
  String get craneSleep2SemanticLabel => 'Ngome ya Machu Picchu';

  @override
  String get craneSleep3SemanticLabel =>
      'Mwanaume aliyeegemea gari la kale la samawati';

  @override
  String get craneSleep4SemanticLabel =>
      'Hoteli kando ya ziwa na mbele ya milima';

  @override
  String get craneSleep5SemanticLabel => 'Hema katika uwanja';

  @override
  String get craneSleep6SemanticLabel => 'Bwawa lenye michikichi';

  @override
  String get craneSleep7SemanticLabel =>
      'Nyumba maridadi katika Mraba wa Riberia';

  @override
  String get craneSleep8SemanticLabel =>
      'Magofu ya Maya kwenye jabali juu ya ufuo';

  @override
  String get craneSleep9SemanticLabel => 'Mnara wa taa wa matofali baharini';

  @override
  String get craneSleep10SemanticLabel =>
      'Minara ya Msikiti wa Al-Azhar wakati wa machweo';

  @override
  String get craneSleep11SemanticLabel => 'Maghorofa ya Taipei 101';

  @override
  String get craneEat0SemanticLabel => 'Piza ndani ya tanuri la kuni';

  @override
  String get craneEat1SemanticLabel =>
      'Baa tupu yenye stuli za muundo wa behewa';

  @override
  String get craneEat2SemanticLabel => 'Baga';

  @override
  String get craneEat3SemanticLabel => 'Taco ya Kikorea';

  @override
  String get craneEat4SemanticLabel => 'Kitindamlo cha chokoleti';

  @override
  String get craneEat5SemanticLabel => 'Eneo la kukaa la mkahawa wa kisanii';

  @override
  String get craneEat6SemanticLabel => 'Chakula cha uduvi';

  @override
  String get craneEat7SemanticLabel => 'Mlango wa kuingia katika tanuri mikate';

  @override
  String get craneEat8SemanticLabel => 'Sahani ya kamba wa maji baridi';

  @override
  String get craneEat9SemanticLabel => 'Kaunta ya mkahawa yenye vitobosha';

  @override
  String get craneEat10SemanticLabel =>
      'Mwanamke aliyeshika sandiwichi kubwa ya pastrami';

  @override
  String get fortnightlyMenuFrontPage => 'Ukurasa wa Mbele';

  @override
  String get fortnightlyMenuWorld => 'Dunia';

  @override
  String get fortnightlyMenuUS => 'Marekani';

  @override
  String get fortnightlyMenuPolitics => 'Siasa';

  @override
  String get fortnightlyMenuBusiness => 'Biashara';

  @override
  String get fortnightlyMenuTech => 'Teknolojia';

  @override
  String get fortnightlyMenuScience => 'Sayansi';

  @override
  String get fortnightlyMenuSports => 'Spoti';

  @override
  String get fortnightlyMenuTravel => 'Usafiri';

  @override
  String get fortnightlyMenuCulture => 'Utamaduni';

  @override
  String get fortnightlyTrendingTechDesign => 'Usanifu wa Teknolojia';

  @override
  String get fortnightlyTrendingReform => 'Mageuzi';

  @override
  String get fortnightlyTrendingHealthcareRevolution =>
      'Mapinduzi ya Huduma za Afya';

  @override
  String get fortnightlyTrendingGreenArmy => 'Jeshi la Kijani';

  @override
  String get fortnightlyTrendingStocks => 'Hisa';

  @override
  String get fortnightlyLatestUpdates => 'Taarifa za Hivi Karibuni';

  @override
  String get fortnightlyHeadlineHealthcare =>
      'Mapinduzi Kimya, Ila Yenye Nguvu ya Huduma za Afya';

  @override
  String get fortnightlyHeadlineWar =>
      'Maisha ya Utengano ya Marekani Wakati wa Vita';

  @override
  String get fortnightlyHeadlineGasoline => 'Mustakabali wa Mafuta';

  @override
  String get fortnightlyHeadlineArmy =>
      'Mageuzi ya Jeshi la Kijani Kukota Ndani';

  @override
  String get fortnightlyHeadlineStocks =>
      'Hisa Zinapodoroa, Wengi Huwekeza Kwenye Sarafu';

  @override
  String get fortnightlyHeadlineFabrics =>
      'Wanamitindo Wanatumia Teknolojia Kutengeneza Vitambaa vya Kisasa';

  @override
  String get fortnightlyHeadlineFeminists =>
      'Watetezi wa Nadharia ya Haki na Usawa wa Wanawake Wanavyopambana na Ubaguzi';

  @override
  String get fortnightlyHeadlineBees => 'Upungufu wa Nyuki wa Shambani';
}
