// 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 Czech (`cs`).
class GalleryLocalizationsCs extends GalleryLocalizations {
  GalleryLocalizationsCs([String locale = 'cs']) : super(locale);

  @override
  String githubRepo(Object repoName) {
    return 'Repozitář GitHub ${repoName}';
  }

  @override
  String aboutDialogDescription(Object repoLink) {
    return 'Chcete-li zobrazit zdrojový kód této aplikace, přejděte na ${repoLink}.';
  }

  @override
  String get signIn => 'PŘIHLÁSIT SE';

  @override
  String get bannerDemoText =>
      'Ve druhém zařízení bylo aktualizováno heslo. Přihlaste se znovu.';

  @override
  String get bannerDemoResetText => 'Resetovat banner';

  @override
  String get bannerDemoMultipleText => 'Více akcí';

  @override
  String get bannerDemoLeadingText => 'Ikona na začátku';

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

  @override
  String get backToGallery => 'Zpět do galerie';

  @override
  String get cardsDemoTappable => 'Klepnutelné';

  @override
  String get cardsDemoSelectable => 'Vybratelné (dlouhé stisknutí)';

  @override
  String get cardsDemoExplore => 'Prozkoumat';

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

  @override
  String cardsDemoShareSemantics(Object destinationName) {
    return 'Sdílet ${destinationName}';
  }

  @override
  String get cardsDemoTravelDestinationTitle1 =>
      '10 nejčastěji navštěvovaných měst v Tamilnádu';

  @override
  String get cardsDemoTravelDestinationDescription1 => 'Číslo 10';

  @override
  String get cardsDemoTravelDestinationCity1 => 'Taňčávúr';

  @override
  String get cardsDemoTravelDestinationLocation1 => 'Taňčávúr, Tamilnádu';

  @override
  String get cardsDemoTravelDestinationTitle2 => 'Řemeslníci z jižní Indie';

  @override
  String get cardsDemoTravelDestinationDescription2 => 'Předení hedvábí';

  @override
  String get cardsDemoTravelDestinationCity2 => 'Chettinad';

  @override
  String get cardsDemoTravelDestinationLocation2 => 'Sivaganga, Tamilnádu';

  @override
  String get cardsDemoTravelDestinationTitle3 => 'Chrám Brihadišvára';

  @override
  String get cardsDemoTravelDestinationDescription3 => 'Chrámy';

  @override
  String get homeHeaderGallery => 'Galerie';

  @override
  String get homeHeaderCategories => 'Kategorie';

  @override
  String get shrineDescription => 'Elegantní maloobchodní aplikace';

  @override
  String get fortnightlyDescription =>
      'Zpravodajská aplikace zaměřená na kvalitní obsah';

  @override
  String get rallyDescription => 'Aplikace pro osobní finance';

  @override
  String get rallyAccountDataChecking => 'Běžný';

  @override
  String get rallyAccountDataHomeSavings => 'Úspory na domácnost';

  @override
  String get rallyAccountDataCarSavings => 'Úspory na auto';

  @override
  String get rallyAccountDataVacation => 'Dovolená';

  @override
  String get rallyAccountDetailDataAnnualPercentageYield =>
      'Roční procentuální výtěžek';

  @override
  String get rallyAccountDetailDataInterestRate => 'Úroková sazba';

  @override
  String get rallyAccountDetailDataInterestYtd =>
      'Úrok od začátku roku do dnes';

  @override
  String get rallyAccountDetailDataInterestPaidLastYear =>
      'Úrok zaplacený minulý rok';

  @override
  String get rallyAccountDetailDataNextStatement => 'Další výpis';

  @override
  String get rallyAccountDetailDataAccountOwner => 'Vlastník účtu';

  @override
  String get rallyBillDetailTotalAmount => 'Celková částka';

  @override
  String get rallyBillDetailAmountPaid => 'Zaplacená částka';

  @override
  String get rallyBillDetailAmountDue => 'Dlužná částka';

  @override
  String get rallyBudgetCategoryCoffeeShops => 'Kavárny';

  @override
  String get rallyBudgetCategoryGroceries => 'Potraviny';

  @override
  String get rallyBudgetCategoryRestaurants => 'Restaurace';

  @override
  String get rallyBudgetCategoryClothing => 'Oblečení';

  @override
  String get rallyBudgetDetailTotalCap => 'Celkový limit';

  @override
  String get rallyBudgetDetailAmountUsed => 'Využitá částka';

  @override
  String get rallyBudgetDetailAmountLeft => 'Zbývající částka';

  @override
  String get rallySettingsManageAccounts => 'Spravovat účty';

  @override
  String get rallySettingsTaxDocuments => 'Daňové doklady';

  @override
  String get rallySettingsPasscodeAndTouchId => 'Heslo a Touch ID';

  @override
  String get rallySettingsNotifications => 'Oznámení';

  @override
  String get rallySettingsPersonalInformation => 'Osobní údaje';

  @override
  String get rallySettingsPaperlessSettings =>
      'Nastavení bezpapírového přístupu';

  @override
  String get rallySettingsFindAtms => 'Najít bankomaty';

  @override
  String get rallySettingsHelp => 'Nápověda';

  @override
  String get rallySettingsSignOut => 'Odhlásit se';

  @override
  String get rallyAccountTotal => 'Celkem';

  @override
  String get rallyBillsDue => 'Splatnost';

  @override
  String get rallyBudgetLeft => 'Zbývá';

  @override
  String get rallyAccounts => 'Účty';

  @override
  String get rallyBills => 'Faktury';

  @override
  String get rallyBudgets => 'Rozpočty';

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

  @override
  String get rallySeeAll => 'ZOBRAZIT VŠE';

  @override
  String get rallyFinanceLeft => 'ZBÝVÁ';

  @override
  String get rallyTitleOverview => 'PŘEHLED';

  @override
  String get rallyTitleAccounts => 'ÚČTY';

  @override
  String get rallyTitleBills => 'FAKTURY';

  @override
  String get rallyTitleBudgets => 'ROZPOČTY';

  @override
  String get rallyTitleSettings => 'NASTAVENÍ';

  @override
  String get rallyLoginLoginToRally => 'Přihlášení do aplikace Rally';

  @override
  String get rallyLoginNoAccount => 'Nemáte účet?';

  @override
  String get rallyLoginSignUp => 'ZAREGISTROVAT SE';

  @override
  String get rallyLoginUsername => 'Uživatelské jméno';

  @override
  String get rallyLoginPassword => 'Heslo';

  @override
  String get rallyLoginLabelLogin => 'Přihlásit se';

  @override
  String get rallyLoginRememberMe => 'Zapamatovat si mě';

  @override
  String get rallyLoginButtonLogin => 'PŘIHLÁSIT SE';

  @override
  String rallyAlertsMessageHeadsUpShopping(Object percent) {
    return 'Pozor, už jste využili ${percent} rozpočtu na nákupy na tento měsíc.';
  }

  @override
  String rallyAlertsMessageSpentOnRestaurants(Object amount) {
    return 'Tento týden jste utratili ${amount} za restaurace';
  }

  @override
  String rallyAlertsMessageATMFees(Object amount) {
    return 'Tento měsíc jste utratili ${amount} za poplatky za bankomat';
  }

  @override
  String rallyAlertsMessageCheckingAccount(Object percent) {
    return 'Dobrá práce! Na běžném účtu máte o ${percent} vyšší zůstatek než minulý měsíc.';
  }

  @override
  String rallyAlertsMessageUnassignedTransactions(int count) {
    return intl.Intl.pluralLogic(
      count,
      locale: localeName,
      one:
          'Zvyšte potenciální odečet z daní! Přiřaďte k 1 nezařazené transakci kategorie.',
      few:
          'Zvyšte potenciální odečet z daní! Přiřaďte ke ${count} nezařazeným transakcím kategorie.',
      many:
          'Zvyšte potenciální odečet z daní! Přiřaďte k ${count} nezařazené transakce kategorie.',
      other:
          'Zvyšte potenciální odečet z daní! Přiřaďte k ${count} nezařazeným transakcím kategorie.',
    );
  }

  @override
  String get rallySeeAllAccounts => 'Zobrazit všechny účty';

  @override
  String get rallySeeAllBills => 'Zobrazit všechny faktury';

  @override
  String get rallySeeAllBudgets => 'Zobrazit všechny rozpočty';

  @override
  String rallyAccountAmount(
      Object accountName, Object accountNumber, Object amount) {
    return 'Účet ${accountName} č. ${accountNumber} s částkou ${amount}.';
  }

  @override
  String rallyBillAmount(Object billName, Object date, Object amount) {
    return 'Faktura ${billName} ve výši ${amount} je splatná do ${date}.';
  }

  @override
  String rallyBudgetAmount(Object budgetName, Object amountUsed,
      Object amountTotal, Object amountLeft) {
    return 'Rozpočet ${budgetName}: využito ${amountUsed} z ${amountTotal}, zbývá ${amountLeft}';
  }

  @override
  String get craneDescription => 'Personalizovaná cestovní aplikace';

  @override
  String get homeCategoryReference => 'STYLY A DALŠÍ';

  @override
  String get demoInvalidURL => 'Adresu URL nelze zobrazit:';

  @override
  String get demoOptionsTooltip => 'Možnosti';

  @override
  String get demoInfoTooltip => 'Informace';

  @override
  String get demoCodeTooltip => 'Ukázkový kód';

  @override
  String get demoDocumentationTooltip => 'Dokumentace API';

  @override
  String get demoFullscreenTooltip => 'Celá obrazovka';

  @override
  String get demoCodeViewerCopyAll => 'KOPÍROVAT VŠE';

  @override
  String get demoCodeViewerCopiedToClipboardMessage =>
      'Zkopírováno do schránky.';

  @override
  String demoCodeViewerFailedToCopyToClipboardMessage(Object error) {
    return 'Kopírování do schránky se nezdařilo: ${error}';
  }

  @override
  String get demoOptionsFeatureTitle => 'Zobrazit možnosti';

  @override
  String get demoOptionsFeatureDescription =>
      'Klepnutím sem zobrazíte dostupné možnosti pro tuto ukázku.';

  @override
  String get settingsTitle => 'Nastavení';

  @override
  String get settingsButtonLabel => 'Nastavení';

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

  @override
  String get settingsSystemDefault => 'Systém';

  @override
  String get settingsTextScaling => 'Zvětšení/zmenšení textu';

  @override
  String get settingsTextScalingSmall => 'Malé';

  @override
  String get settingsTextScalingNormal => 'Normální';

  @override
  String get settingsTextScalingLarge => 'Velké';

  @override
  String get settingsTextScalingHuge => 'Velmi velké';

  @override
  String get settingsTextDirection => 'Směr textu';

  @override
  String get settingsTextDirectionLocaleBased => 'Podle jazyka';

  @override
  String get settingsTextDirectionLTR => 'Zleva doprava';

  @override
  String get settingsTextDirectionRTL => 'Zprava doleva';

  @override
  String get settingsLocale => 'Národní prostředí';

  @override
  String get settingsPlatformMechanics => 'Mechanika platformy';

  @override
  String get settingsTheme => 'Motiv';

  @override
  String get settingsDarkTheme => 'Tmavý';

  @override
  String get settingsLightTheme => 'Světlý';

  @override
  String get settingsSlowMotion => 'Zpomalení';

  @override
  String get settingsAbout => 'Informace o aplikaci Flutter Gallery';

  @override
  String get settingsFeedback => 'Odeslat zpětnou vazbu';

  @override
  String get settingsAttribution => 'Design: TOASTER, Londýn';

  @override
  String get demoBottomAppBarTitle => 'Dolní panel aplikace';

  @override
  String get demoBottomAppBarSubtitle =>
      'Zobrazuje navigační prvky a akce dole';

  @override
  String get demoBottomAppBarDescription =>
      'Dolní panely aplikací poskytují přístup k dolnímu vysouvacímu panelu navigace a až čtyřem akcím včetně plovoucího tlačítka akce.';

  @override
  String get bottomAppBarNotch => 'S výřezem';

  @override
  String get bottomAppBarPosition => 'Pozice plovoucího tlačítka akce';

  @override
  String get bottomAppBarPositionDockedEnd => 'Dokované, na konci';

  @override
  String get bottomAppBarPositionDockedCenter => 'Dokované, uprostřed';

  @override
  String get bottomAppBarPositionFloatingEnd => 'Plovoucí, na konci';

  @override
  String get bottomAppBarPositionFloatingCenter => 'Plovoucí, uprostřed';

  @override
  String get demoBannerTitle => 'Banner';

  @override
  String get demoBannerSubtitle => 'Zobrazení banneru se seznamem';

  @override
  String get demoBannerDescription =>
      'Banner zobrazuje důležité, stručné informace a umožňuje uživatelům provádět akce (nebo banner zavřít). K zavření je zapotřebí akce uživatele.';

  @override
  String get demoBottomNavigationTitle => 'Spodní navigace';

  @override
  String get demoBottomNavigationSubtitle =>
      'Spodní navigace s prolínajícím zobrazením';

  @override
  String get demoBottomNavigationPersistentLabels => 'Trvale zobrazené štítky';

  @override
  String get demoBottomNavigationSelectedLabel => 'Vybraný štítek';

  @override
  String get demoBottomNavigationDescription =>
      'Spodní navigační panely zobrazují ve spodní části obrazovky tři až pět cílů. Každý cíl zastupuje ikona a volitelný textový štítek. Po klepnutí na spodní navigační ikonu je uživatel přenesen na nejvyšší úroveň cíle navigace, který je k dané ikoně přidružen.';

  @override
  String get demoButtonTitle => 'Tlačítka';

  @override
  String get demoButtonSubtitle => 'Ploché, zvýšené, obrysové a další';

  @override
  String get demoFlatButtonTitle => 'Ploché tlačítko';

  @override
  String get demoFlatButtonDescription =>
      'Ploché tlačítko při stisknutí zobrazí inkoustovou kaňku, ale nezvedne se. Plochá tlačítka používejte na lištách, v dialogových oknech a v textu s odsazením';

  @override
  String get demoRaisedButtonTitle => 'Zvýšené tlačítko';

  @override
  String get demoRaisedButtonDescription =>
      'Zvýšená tlačítka vnášejí rozměr do převážně plochých rozvržení. Upozorňují na funkce v místech, která jsou hodně navštěvovaná nebo rozsáhlá.';

  @override
  String get demoOutlineButtonTitle => 'Obrysové tlačítko';

  @override
  String get demoOutlineButtonDescription =>
      'Obrysová tlačítka se při stisknutí zdvihnou a zneprůhlední. Obvykle se vyskytují v páru se zvýšenými tlačítky za účelem označení alternativní, sekundární akce.';

  @override
  String get demoToggleButtonTitle => 'Přepínače';

  @override
  String get demoToggleButtonDescription =>
      'Přepínače lze použít k seskupení souvisejících možností. Chcete-li zvýraznit skupiny souvisejících přepínačů, umístěte skupinu do stejného kontejneru';

  @override
  String get demoFloatingButtonTitle => 'Plovoucí tlačítko akce';

  @override
  String get demoFloatingButtonDescription =>
      'Plovoucí tlačítko akce je kruhové tlačítko akce, které se vznáší nad obsahem za účelem upozornění na hlavní akci v aplikaci.';

  @override
  String get demoCardTitle => 'Karty';

  @override
  String get demoCardSubtitle => 'Základní karty se zaoblenými rohy';

  @override
  String get demoChipTitle => 'Prvky';

  @override
  String get demoCardDescription =>
      'Karta je list ve vzhledu Material, který slouží k uvedení souvisejících informací, jako je album, zeměpisná poloha, pokrm, kontaktní údaje apod.';

  @override
  String get demoChipSubtitle =>
      'Kompaktní prvky představující vstup, atribut nebo akci';

  @override
  String get demoActionChipTitle => 'Prvek akce';

  @override
  String get demoActionChipDescription =>
      'Prvky akce jsou sada možností, které spustí akci související s primárním obsahem. Měly by se objevovat dynamicky a kontextově v uživatelském rozhraní.';

  @override
  String get demoChoiceChipTitle => 'Prvek volby';

  @override
  String get demoChoiceChipDescription =>
      'Prvky volby představují jednu volbu ze sady. Obsahují související popisný text nebo kategorie.';

  @override
  String get demoFilterChipTitle => 'Prvek filtru';

  @override
  String get demoFilterChipDescription =>
      'Prvky filtru filtrují obsah pomocí značek nebo popisných slov.';

  @override
  String get demoInputChipTitle => 'Prvek vstupu';

  @override
  String get demoInputChipDescription =>
      'Prvky vstupu představují komplexní informaci v kompaktní podobě, např. entitu (osobu, místo či věc) nebo text konverzace.';

  @override
  String get demoDataTableTitle => 'Tabulky údajů';

  @override
  String get demoDataTableSubtitle => 'Řádky a sloupce s informacemi';

  @override
  String get demoDataTableDescription =>
      'Tabulky údajů zobrazují informace ve formátu mřížky tvořené řádky a sloupci. Informace jsou v nich uspořádány tak, aby byly snadno dohledatelné a uživatelé mohli hledat určité vzorce nebo statistiky.';

  @override
  String get dataTableHeader => 'Výživa';

  @override
  String get dataTableColumnDessert => 'Dezert (1 porce)';

  @override
  String get dataTableColumnCalories => 'Kalorie';

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

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

  @override
  String get dataTableColumnProtein => 'Bílkoviny (g)';

  @override
  String get dataTableColumnSodium => 'Sodík (mg)';

  @override
  String get dataTableColumnCalcium => 'Vápník (%)';

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

  @override
  String get dataTableRowFrozenYogurt => 'Mražený jogurt';

  @override
  String get dataTableRowIceCreamSandwich => 'Zmrzlinový sendvič';

  @override
  String get dataTableRowEclair => 'Banánek';

  @override
  String get dataTableRowCupcake => 'Dortík';

  @override
  String get dataTableRowGingerbread => 'Perník';

  @override
  String get dataTableRowJellyBean => 'Želatinová fazolka';

  @override
  String get dataTableRowLollipop => 'Lízátko';

  @override
  String get dataTableRowHoneycomb => 'Medová plástev';

  @override
  String get dataTableRowDonut => 'Kobliha';

  @override
  String get dataTableRowApplePie => 'Jablečný koláč';

  @override
  String dataTableRowWithSugar(Object value) {
    return '${value} s cukrem';
  }

  @override
  String dataTableRowWithHoney(Object value) {
    return '${value} s medem';
  }

  @override
  String get demoDialogTitle => 'Dialogová okna';

  @override
  String get demoDialogSubtitle =>
      'Jednoduché, s upozorněním a na celou obrazovku';

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

  @override
  String get demoAlertDialogDescription =>
      'Dialogové okno s upozorněním uživatele informuje o situacích, které vyžadují pozornost. Dialogové okno s upozorněním má volitelný název a volitelný seznam akcí.';

  @override
  String get demoAlertTitleDialogTitle => 'Upozornění s názvem';

  @override
  String get demoSimpleDialogTitle => 'Jednoduché';

  @override
  String get demoSimpleDialogDescription =>
      'Jednoduché dialogové okno nabízí uživateli na výběr mezi několika možnostmi. Jednoduché dialogové okno má volitelný název, který je zobrazen nad možnostmi.';

  @override
  String get demoGridListsTitle => 'Mřížkové seznamy';

  @override
  String get demoGridListsSubtitle => 'Rozvržení řádků a sloupců';

  @override
  String get demoGridListsDescription =>
      'Mřížkové seznamy se hodí především pro prezentaci homogenních dat, jako jsou obrázky. Jednotlivé položky mřížkového seznamu se označují jako dlaždice.';

  @override
  String get demoGridListsImageOnlyTitle => 'Pouze obrázky';

  @override
  String get demoGridListsHeaderTitle => 'Se záhlavím';

  @override
  String get demoGridListsFooterTitle => 'Se zápatím';

  @override
  String get demoSlidersTitle => 'Posuvníky';

  @override
  String get demoSlidersSubtitle => 'Widgety pro výběr hodnoty přejetím prstem';

  @override
  String get demoSlidersDescription =>
      'Posuvníky představují rozsah hodnot podél panelu, ze kterých může uživatel zvolit jednu hodnotu. Jsou ideální pro úpravu nastavení jako hlasitost nebo jas nebo pro aplikování filtrů na obrázky.';

  @override
  String get demoRangeSlidersTitle => 'Posuvníky s rozsahem';

  @override
  String get demoRangeSlidersDescription =>
      'Posuvníky představují rozsah hodnot podél panelu. Mohou mít na obou koncích panelu ikony, které představují rozsah hodnot. Jsou ideální pro úpravu nastavení jako hlasitost nebo jas nebo pro aplikování filtrů na obrázky.';

  @override
  String get demoCustomSlidersTitle => 'Vlastní posuvníky';

  @override
  String get demoCustomSlidersDescription =>
      'Posuvníky představují rozsah hodnot podél panelu, ze kterých může uživatel zvolit jednu hodnotu nebo rozsah hodnot. Posuvníkům lze přidělit motiv a lze je přizpůsobit.';

  @override
  String get demoSlidersContinuousWithEditableNumericalValue =>
      'Spojitý s upravitelnou číselnou hodnotou';

  @override
  String get demoSlidersDiscrete => 'Diskrétní';

  @override
  String get demoSlidersDiscreteSliderWithCustomTheme =>
      'Diskrétní posuvník s vlastním motivem';

  @override
  String get demoSlidersContinuousRangeSliderWithCustomTheme =>
      'Posuvník se spojitým rozsahem s vlastním motivem';

  @override
  String get demoSlidersContinuous => 'Spojitý';

  @override
  String get demoSlidersEditableNumericalValue => 'Upravitelná číselná hodnota';

  @override
  String get demoMenuTitle => 'Nabídka';

  @override
  String get demoContextMenuTitle => 'Kontextová nabídka';

  @override
  String get demoSectionedMenuTitle => 'Členěná nabídka';

  @override
  String get demoSimpleMenuTitle => 'Jednoduchá nabídka';

  @override
  String get demoChecklistMenuTitle => 'Nabídka se zaškrtávacími položkami';

  @override
  String get demoMenuSubtitle => 'Tlačítka nabídek a jednoduché nabídky';

  @override
  String get demoMenuDescription =>
      'Nabídka obsahuje seznam voleb na dočasné ploše. Zobrazí se, když uživatel interaguje s tlačítkem, příkazem nebo jiným ovládacím prvkem.';

  @override
  String get demoMenuItemValueOne => '1. položka nabídky';

  @override
  String get demoMenuItemValueTwo => '2. položka nabídky';

  @override
  String get demoMenuItemValueThree => '3. položka nabídky';

  @override
  String get demoMenuOne => 'Jedna';

  @override
  String get demoMenuTwo => 'Dva';

  @override
  String get demoMenuThree => 'Tři';

  @override
  String get demoMenuFour => 'Čtyři';

  @override
  String get demoMenuAnItemWithAContextMenuButton =>
      'Položka s kontextovou nabídkou';

  @override
  String get demoMenuContextMenuItemOne => '1. položka kontextové nabídky';

  @override
  String get demoMenuADisabledMenuItem => 'Neaktivní položka nabídky';

  @override
  String get demoMenuContextMenuItemThree => '3. položka kontextové nabídky';

  @override
  String get demoMenuAnItemWithASectionedMenu => 'Položka s členěnou nabídkou';

  @override
  String get demoMenuPreview => 'Náhled';

  @override
  String get demoMenuShare => 'Sdílet';

  @override
  String get demoMenuGetLink => 'Získat odkaz';

  @override
  String get demoMenuRemove => 'Odstranit';

  @override
  String demoMenuSelected(Object value) {
    return 'Vybráno: ${value}';
  }

  @override
  String demoMenuChecked(Object value) {
    return 'Zaškrtnuto: ${value}';
  }

  @override
  String get demoMenuAnItemWithASimpleMenu => 'Položka s jednoduchou nabídkou';

  @override
  String get demoMenuAnItemWithAChecklistMenu =>
      'Položka s nabídkou se zaškrtávacími položkami';

  @override
  String get demoFullscreenDialogTitle => 'Celá obrazovka';

  @override
  String get demoFullscreenDialogDescription =>
      'Hodnota fullscreenDialog určuje, zda následující stránka bude mít podobu modálního dialogového okna na celou obrazovku';

  @override
  String get demoCupertinoActivityIndicatorTitle => 'Indikátor aktivity';

  @override
  String get demoCupertinoActivityIndicatorSubtitle =>
      'Indikátory aktivity ve stylu iOS';

  @override
  String get demoCupertinoActivityIndicatorDescription =>
      'Indikátor aktivity ve stylu iOS, který rotuje ve směru hodinových ručiček.';

  @override
  String get demoCupertinoButtonsTitle => 'Tlačítka';

  @override
  String get demoCupertinoButtonsSubtitle => 'Tlačítka ve stylu iOS';

  @override
  String get demoCupertinoButtonsDescription =>
      'Tlačítko ve stylu systému iOS. Jedná se o text nebo ikonu, která při dotyku postupně zmizí nebo se objeví. Volitelně může mít i pozadí.';

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

  @override
  String get demoCupertinoAlertsSubtitle =>
      'Dialogová okna s upozorněním ve stylu iOS';

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

  @override
  String get demoCupertinoAlertDescription =>
      'Dialogové okno s upozorněním uživatele informuje o situacích, které vyžadují pozornost. Dialogové okno s upozorněním má volitelný název, volitelný obsah a volitelný seznam akcí. Název je zobrazen nad obsahem a akce jsou zobrazeny pod obsahem.';

  @override
  String get demoCupertinoAlertWithTitleTitle => 'Upozornění s názvem';

  @override
  String get demoCupertinoAlertButtonsTitle => 'Upozornění s tlačítky';

  @override
  String get demoCupertinoAlertButtonsOnlyTitle =>
      'Pouze tlačítka s upozorněním';

  @override
  String get demoCupertinoActionSheetTitle => 'List akcí';

  @override
  String get demoCupertinoActionSheetDescription =>
      'List akcí je zvláštní typ upozornění, které uživateli předkládá sadu dvou či více možností souvisejících se stávající situací. List akcí může obsahovat název, další zprávu a seznam akcí.';

  @override
  String get demoCupertinoNavigationBarTitle => 'Navigační panel';

  @override
  String get demoCupertinoNavigationBarSubtitle =>
      'Navigační panel ve stylu iOS';

  @override
  String get demoCupertinoNavigationBarDescription =>
      'Navigační panel ve stylu iOS. Navigační panel je nástroj, který má uprostřed název stránky (i kdyby už neměl žádné další prvky).';

  @override
  String get demoCupertinoPickerTitle => 'Výběry';

  @override
  String get demoCupertinoPickerSubtitle => 'Výběry data a času ve stylu iOS';

  @override
  String get demoCupertinoPickerDescription =>
      'Widget výběru ve stylu iOS, pomocí kterého lze vybírat datum, čas, nebo datum i čas.';

  @override
  String get demoCupertinoPickerTimer => 'Časovač';

  @override
  String get demoCupertinoPickerDate => 'Datum';

  @override
  String get demoCupertinoPickerTime => 'Čas';

  @override
  String get demoCupertinoPickerDateTime => 'Datum a čas';

  @override
  String get demoCupertinoPullToRefreshTitle =>
      'Potažením dolů aktualizujete obsah';

  @override
  String get demoCupertinoPullToRefreshSubtitle =>
      'Ovládací prvek ve stylu iOS, v němž potažením dolů aktualizujete obsah';

  @override
  String get demoCupertinoPullToRefreshDescription =>
      'Widget ve stylu iOS, jehož obsah aktualizujete potažením dolů.';

  @override
  String get demoCupertinoSegmentedControlTitle => 'Segmentová kontrola';

  @override
  String get demoCupertinoSegmentedControlSubtitle =>
      'Segmentová kontrola ve stylu iOS';

  @override
  String get demoCupertinoSegmentedControlDescription =>
      'Slouží k výběru mezi možnostmi, které se vzájemně vylučují. Výběrem jedné možnosti segmentové kontroly zrušíte výběr ostatních možností.';

  @override
  String get demoCupertinoSliderTitle => 'Posuvník';

  @override
  String get demoCupertinoSliderSubtitle => 'Posuvník ve stylu iOS';

  @override
  String get demoCupertinoSliderDescription =>
      'Pomocí posuvníku lze vybírat ze spojité nebo diskrétní množiny hodnot.';

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

  @override
  String demoCupertinoSliderDiscrete(Object value) {
    return 'Diskrétní: ${value}';
  }

  @override
  String get demoCupertinoSwitchSubtitle => 'Přepínač ve stylu iOS';

  @override
  String get demoCupertinoSwitchDescription =>
      'Přepínač slouží k zapnutí nebo vypnutí jednoho nastavení.';

  @override
  String get demoCupertinoTabBarTitle => 'Lišta karet';

  @override
  String get demoCupertinoTabBarSubtitle => 'Dolní lišta karet ve stylu iOS';

  @override
  String get demoCupertinoTabBarDescription =>
      'Dolní navigační lišta karet ve stylu iOS. Zobrazuje několik karet, přičemž jedna (ve výchozím nastavení první) karta je aktivní.';

  @override
  String get cupertinoTabBarHomeTab => 'Domovská karta';

  @override
  String get cupertinoTabBarChatTab => 'Chat';

  @override
  String get cupertinoTabBarProfileTab => 'Profil';

  @override
  String get demoCupertinoTextFieldTitle => 'Textová pole';

  @override
  String get demoCupertinoTextFieldSubtitle => 'Textová pole ve stylu iOS';

  @override
  String get demoCupertinoTextFieldDescription =>
      'Textová pole, do kterých mohou uživatelé zadat text pomocí hardwarové nebo softwarové klávesnice.';

  @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 => 'Barvy';

  @override
  String get demoColorsSubtitle => 'Všechny předdefinované barvy';

  @override
  String get demoColorsDescription =>
      'Konstanty barvy a vzorníku barev, které představují barevnou škálu vzhledu Material Design.';

  @override
  String get demoTypographyTitle => 'Typografie';

  @override
  String get demoTypographySubtitle => 'Všechny předdefinované styly textu';

  @override
  String get demoTypographyDescription =>
      'Definice různých typografických stylů, které se vyskytují ve vzhledu Material Design.';

  @override
  String get demo2dTransformationsTitle => '2D transformace';

  @override
  String get demo2dTransformationsSubtitle => 'Posunutí, přiblížení, otočení';

  @override
  String get demo2dTransformationsDescription =>
      'Klepnutím upravujte pole a pomocí gest se pohybujte po scéně. Přetažením posunete, stažením prstů přiblížíte, dvěma prsty otočíte. Pomocí tlačítka resetování obnovíte původní orientaci.';

  @override
  String get demo2dTransformationsResetTooltip => 'Resetovat transformace';

  @override
  String get demo2dTransformationsEditTooltip => 'Upravit pole';

  @override
  String get buttonText => 'TLAČÍTKO';

  @override
  String get demoBottomSheetTitle => 'Spodní tabulka';

  @override
  String get demoBottomSheetSubtitle => 'Trvalé a modální spodní tabulky';

  @override
  String get demoBottomSheetPersistentTitle => 'Trvalá spodní tabulka';

  @override
  String get demoBottomSheetPersistentDescription =>
      'Stálá spodní tabulka zobrazuje informace, které doplňují primární obsah aplikace. Stálá spodní tabulka zůstává viditelná i při interakci uživatele s ostatními částmi aplikace.';

  @override
  String get demoBottomSheetModalTitle => 'Modální spodní tabulka';

  @override
  String get demoBottomSheetModalDescription =>
      'Modální spodní tabulka je alternativou k nabídce nebo dialogovému oknu a zabraňuje uživateli v interakci se zbytkem aplikace.';

  @override
  String get demoBottomSheetAddLabel => 'Přidat';

  @override
  String get demoBottomSheetButtonText => 'ZOBRAZIT SPODNÍ TABULKU';

  @override
  String get demoBottomSheetHeader => 'Záhlaví';

  @override
  String demoBottomSheetItem(Object value) {
    return 'Položka ${value}';
  }

  @override
  String get demoListsTitle => 'Seznamy';

  @override
  String get demoListsSubtitle => 'Rozložení posouvacích seznamů';

  @override
  String get demoListsDescription =>
      'Jeden řádek s pevnou výškou, který obvykle obsahuje text a ikonu na začátku nebo na konci.';

  @override
  String get demoOneLineListsTitle => 'Jeden řádek';

  @override
  String get demoTwoLineListsTitle => 'Dva řádky';

  @override
  String get demoListsSecondary => 'Sekundární text';

  @override
  String get demoProgressIndicatorTitle => 'Ukazatele průběhu';

  @override
  String get demoProgressIndicatorSubtitle => 'Lineární, kruhový, neurčitý';

  @override
  String get demoCircularProgressIndicatorTitle => 'Kruhový ukazatel průběhu';

  @override
  String get demoCircularProgressIndicatorDescription =>
      'Kruhový ukazatel průběhu Material Design, který otáčením signalizuje, že aplikace je zaneprázdněná.';

  @override
  String get demoLinearProgressIndicatorTitle => 'Lineární ukazatel průběhu';

  @override
  String get demoLinearProgressIndicatorDescription =>
      'Lineární ukazatel průběhu Material Design.';

  @override
  String get demoPickersTitle => 'Výběry';

  @override
  String get demoPickersSubtitle => 'Výběr data a času';

  @override
  String get demoDatePickerTitle => 'Výběr data';

  @override
  String get demoDatePickerDescription =>
      'Zobrazuje dialog s výběrem data ve vzhledu Material Design.';

  @override
  String get demoTimePickerTitle => 'Výběr času';

  @override
  String get demoTimePickerDescription =>
      'Zobrazuje dialog s výběrem času ve vzhledu Material Design.';

  @override
  String get demoPickersShowPicker => 'ZOBRAZIT VÝBĚR';

  @override
  String get demoTabsTitle => 'Karty';

  @override
  String get demoTabsScrollingTitle => 'Posuvné';

  @override
  String get demoTabsNonScrollingTitle => 'Neposuvné';

  @override
  String get demoTabsSubtitle =>
      'Karty se zobrazením, která lze nezávisle na sobě posouvat';

  @override
  String get demoTabsDescription =>
      'Karty třídí obsah z různých obrazovek, datových sad a dalších interakcí.';

  @override
  String get demoSnackbarsTitle => 'Dočasná oznámení';

  @override
  String get demoSnackbarsSubtitle =>
      'Dočasná oznámení zobrazují zprávy v dolní části obrazovky';

  @override
  String get demoSnackbarsDescription =>
      'Dočasná oznámení informují uživatele o procesu, který aplikace provedla nebo provede. Zobrazují se dočasně v dolní části obrazovky. Neměla by rušit uživatelský dojem a k jejich zavření není potřeba interakce uživatele.';

  @override
  String get demoSnackbarsButtonLabel => 'ZOBRAZIT DOČASNÉ OZNÁMENÍ';

  @override
  String get demoSnackbarsText => 'Toto je dočasné oznámení.';

  @override
  String get demoSnackbarsActionButtonLabel => 'AKCE';

  @override
  String get demoSnackbarsAction => 'Stiskli jste akci dočasného oznámení';

  @override
  String get demoSelectionControlsTitle => 'Ovládací prvky výběru';

  @override
  String get demoSelectionControlsSubtitle =>
      'Zaškrtávací tlačítka, tlačítkové přepínače a přepínače';

  @override
  String get demoSelectionControlsCheckboxTitle => 'Zaškrtávací políčko';

  @override
  String get demoSelectionControlsCheckboxDescription =>
      'Zaškrtávací políčka umožňují uživatelům vybrat několik možností z celé sady. Běžná hodnota zaškrtávacího políčka je True nebo False, ale zaškrtávací políčko se třemi stavy může mít také hodnotu Null.';

  @override
  String get demoSelectionControlsRadioTitle => 'Tlačítkový přepínač';

  @override
  String get demoSelectionControlsRadioDescription =>
      'Tlačítkové přepínače umožňují uživatelům vybrat jednu možnost z celé sady. Tlačítkové přepínače použijte pro výběr, pokud se domníváte, že uživatel potřebuje vidět všechny dostupné možnosti vedle sebe.';

  @override
  String get demoSelectionControlsSwitchTitle => 'Přepínač';

  @override
  String get demoSelectionControlsSwitchDescription =>
      'Přepínače mění stav jedné možnosti nastavení. Možnost, kterou přepínač ovládá, i stav, ve kterém se nachází, musejí být zřejmé z příslušného textového štítku.';

  @override
  String get demoBottomTextFieldsTitle => 'Textová pole';

  @override
  String get demoTextFieldTitle => 'Textová pole';

  @override
  String get demoTextFieldSubtitle =>
      'Jeden řádek s upravitelným textem a čísly';

  @override
  String get demoTextFieldDescription =>
      'Textová pole uživatelům umožňují zadat do uživatelského rozhraní text. Obvykle se vyskytují ve formulářích a dialogových oknech.';

  @override
  String get demoTextFieldShowPasswordLabel => 'Zobrazit heslo';

  @override
  String get demoTextFieldHidePasswordLabel => 'Skrýt heslo';

  @override
  String get demoTextFieldFormErrors =>
      'Před odesláním formuláře opravte červeně zvýrazněné chyby.';

  @override
  String get demoTextFieldNameRequired => 'Jméno je povinné.';

  @override
  String get demoTextFieldOnlyAlphabeticalChars =>
      'Zadejte jen písmena abecedy.';

  @override
  String get demoTextFieldEnterUSPhoneNumber =>
      '(###) ###-#### – Zadejte telefonní číslo do USA.';

  @override
  String get demoTextFieldEnterPassword => 'Zadejte heslo.';

  @override
  String get demoTextFieldPasswordsDoNotMatch => 'Hesla se neshodují';

  @override
  String get demoTextFieldWhatDoPeopleCallYou => 'Jak vám lidé říkají?';

  @override
  String get demoTextFieldNameField => 'Jméno*';

  @override
  String get demoTextFieldWhereCanWeReachYou => 'Kde vás můžeme zastihnout?';

  @override
  String get demoTextFieldPhoneNumber => 'Telefonní číslo*';

  @override
  String get demoTextFieldYourEmailAddress => 'Vaše e-mailová adresa';

  @override
  String get demoTextFieldEmail => 'E-mail';

  @override
  String get demoTextFieldTellUsAboutYourself =>
      'Řekněte nám něco o sobě (např. napište, co děláte nebo jaké máte koníčky)';

  @override
  String get demoTextFieldKeepItShort => 'Buďte struční, je to jen ukázka.';

  @override
  String get demoTextFieldLifeStory => 'Životní příběh';

  @override
  String get demoTextFieldSalary => 'Plat';

  @override
  String get demoTextFieldUSD => 'USD';

  @override
  String get demoTextFieldNoMoreThan => 'Maximálně osm znaků.';

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

  @override
  String get demoTextFieldRetypePassword => 'Zadejte heslo znovu*';

  @override
  String get demoTextFieldSubmit => 'ODESLAT';

  @override
  String demoTextFieldNameHasPhoneNumber(Object name, Object phoneNumber) {
    return '${name} má telefonní číslo ${phoneNumber}';
  }

  @override
  String get demoTextFieldRequiredField =>
      'Hvězdička (*) označuje povinné pole';

  @override
  String get demoTooltipTitle => 'Popisky';

  @override
  String get demoTooltipSubtitle =>
      'Krátká zpráva, která se zobrazí při dlouhém stisknutí nebo umístění kurzoru';

  @override
  String get demoTooltipDescription =>
      'Popisky jsou textové štítky, které vysvětlují funkci tlačítka nebo jiného prvku uživatelského rozhraní. Informativní text popisku se zobrazí, když uživatel umístí na prvek kurzor, vybere ho nebo ho dlouze stiskne.';

  @override
  String get demoTooltipInstructions =>
      'Dlouhým stisknutím nebo umístěním kurzoru zobrazíte popisek.';

  @override
  String get bottomNavigationCommentsTab => 'Komentáře';

  @override
  String get bottomNavigationCalendarTab => 'Kalendář';

  @override
  String get bottomNavigationAccountTab => 'Účet';

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

  @override
  String get bottomNavigationCameraTab => 'Fotoaparát';

  @override
  String bottomNavigationContentPlaceholder(Object title) {
    return 'Zástupný symbol karty ${title}';
  }

  @override
  String get buttonTextCreate => 'Vytvořit';

  @override
  String dialogSelectedOption(Object value) {
    return 'Vybrali jste: „${value}“';
  }

  @override
  String get chipTurnOnLights => 'Zapnout osvětlení';

  @override
  String get chipSmall => 'Malý';

  @override
  String get chipMedium => 'Střední';

  @override
  String get chipLarge => 'Velký';

  @override
  String get chipElevator => 'Výtah';

  @override
  String get chipWasher => 'Pračka';

  @override
  String get chipFireplace => 'Krb';

  @override
  String get chipBiking => 'Cyklistika';

  @override
  String get dialogDiscardTitle => 'Zahodit koncept?';

  @override
  String get dialogLocationTitle =>
      'Chcete používat službu určování polohy Google?';

  @override
  String get dialogLocationDescription =>
      'Povolte, aby Google mohl aplikacím pomáhat s určováním polohy. To znamená, že budete do Googlu odesílat anonymní údaje o poloze, i když nebudou spuštěny žádné aplikace.';

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

  @override
  String get dialogDiscard => 'ZAHODIT';

  @override
  String get dialogDisagree => 'NESOUHLASÍM';

  @override
  String get dialogAgree => 'SOUHLASÍM';

  @override
  String get dialogSetBackup => 'Nastavit záložní účet';

  @override
  String get dialogAddAccount => 'Přidat účet';

  @override
  String get dialogShow => 'ZOBRAZIT DIALOGOVÉ OKNO';

  @override
  String get dialogFullscreenTitle => 'Dialogové okno na celou obrazovku';

  @override
  String get dialogFullscreenSave => 'ULOŽIT';

  @override
  String get dialogFullscreenDescription =>
      'Ukázka dialogového okna na celou obrazovku';

  @override
  String get cupertinoButton => 'Tlačítko';

  @override
  String get cupertinoButtonWithBackground => 'S pozadím';

  @override
  String get cupertinoAlertCancel => 'Zrušit';

  @override
  String get cupertinoAlertDiscard => 'Zahodit';

  @override
  String get cupertinoAlertLocationTitle =>
      'Povolit Mapám přístup k poloze, když budete aplikaci používat?';

  @override
  String get cupertinoAlertLocationDescription =>
      'Vaše aktuální poloha se bude zobrazovat na mapě a bude sloužit k zobrazení tras, výsledků vyhledávání v okolí a odhadovaných časů cesty.';

  @override
  String get cupertinoAlertAllow => 'Povolit';

  @override
  String get cupertinoAlertDontAllow => 'Nepovolovat';

  @override
  String get cupertinoAlertFavoriteDessert => 'Vyberte oblíbený zákusek';

  @override
  String get cupertinoAlertDessertDescription =>
      'Ze seznamu níže vyberte svůj oblíbený zákusek. Na základě výběru vám přizpůsobíme navrhovaný seznam stravovacích zařízení ve vašem okolí.';

  @override
  String get cupertinoAlertCheesecake => 'Cheesecake';

  @override
  String get cupertinoAlertTiramisu => 'Tiramisu';

  @override
  String get cupertinoAlertApplePie => 'Jablečný koláč';

  @override
  String get cupertinoAlertChocolateBrownie => 'Čokoládové brownie';

  @override
  String get cupertinoShowAlert => 'Zobrazit upozornění';

  @override
  String get colorsRed => 'ČERVENÁ';

  @override
  String get colorsPink => 'RŮŽOVÁ';

  @override
  String get colorsPurple => 'NACHOVÁ';

  @override
  String get colorsDeepPurple => 'TMAVĚ NACHOVÁ';

  @override
  String get colorsIndigo => 'INDIGOVÁ';

  @override
  String get colorsBlue => 'MODRÁ';

  @override
  String get colorsLightBlue => 'SVĚTLE MODRÁ';

  @override
  String get colorsCyan => 'AZUROVÁ';

  @override
  String get colorsTeal => 'ŠEDOZELENÁ';

  @override
  String get colorsGreen => 'ZELENÁ';

  @override
  String get colorsLightGreen => 'SVĚTLE ZELENÁ';

  @override
  String get colorsLime => 'LIMETKOVÁ';

  @override
  String get colorsYellow => 'ŽLUTÁ';

  @override
  String get colorsAmber => 'JANTAROVÁ';

  @override
  String get colorsOrange => 'ORANŽOVÁ';

  @override
  String get colorsDeepOrange => 'TMAVĚ ORANŽOVÁ';

  @override
  String get colorsBrown => 'HNĚDÁ';

  @override
  String get colorsGrey => 'ŠEDÁ';

  @override
  String get colorsBlueGrey => 'ŠEDOMODRÁ';

  @override
  String get placeChennai => 'Čennaj';

  @override
  String get placeTanjore => 'Taňčávúr';

  @override
  String get placeChettinad => 'Chettinad';

  @override
  String get placePondicherry => 'Puduččéri';

  @override
  String get placeFlowerMarket => 'Květinový trh';

  @override
  String get placeBronzeWorks => 'Slévárna bronzu';

  @override
  String get placeMarket => 'Trh';

  @override
  String get placeThanjavurTemple => 'Chrám v Taňčávúru';

  @override
  String get placeSaltFarm => 'Solná farma';

  @override
  String get placeScooters => 'Skútry';

  @override
  String get placeSilkMaker => 'Výrobce hedvábí';

  @override
  String get placeLunchPrep => 'Příprava jídla';

  @override
  String get placeBeach => 'Pláž';

  @override
  String get placeFisherman => 'Rybář';

  @override
  String get starterAppTitle => 'Úvodní aplikace';

  @override
  String get starterAppDescription => 'Responzivní rozvržení úvodní aplikace';

  @override
  String get starterAppGenericButton => 'TLAČÍTKO';

  @override
  String get starterAppTooltipAdd => 'Přidat';

  @override
  String get starterAppTooltipFavorite => 'Oblíbené';

  @override
  String get starterAppTooltipShare => 'Sdílet';

  @override
  String get starterAppTooltipSearch => 'Hledat';

  @override
  String get starterAppGenericTitle => 'Název';

  @override
  String get starterAppGenericSubtitle => 'Podtitul';

  @override
  String get starterAppGenericHeadline => 'Nadpis';

  @override
  String get starterAppGenericBody => 'Text';

  @override
  String starterAppDrawerItem(Object value) {
    return 'Položka ${value}';
  }

  @override
  String get shrineMenuCaption => 'NABÍDKA';

  @override
  String get shrineCategoryNameAll => 'VŠE';

  @override
  String get shrineCategoryNameAccessories => 'DOPLŇKY';

  @override
  String get shrineCategoryNameClothing => 'OBLEČENÍ';

  @override
  String get shrineCategoryNameHome => 'DOMÁCNOST';

  @override
  String get shrineLogoutButtonCaption => 'ODHLÁSIT SE';

  @override
  String get shrineLoginUsernameLabel => 'Uživatelské jméno';

  @override
  String get shrineLoginPasswordLabel => 'Heslo';

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

  @override
  String get shrineNextButtonCaption => 'DALŠÍ';

  @override
  String get shrineCartPageCaption => 'KOŠÍK';

  @override
  String shrineProductQuantity(Object quantity) {
    return 'Počet: ${quantity}';
  }

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

  @override
  String shrineCartItemCount(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'ŽÁDNÉ POLOŽKY',
      one: '1 POLOŽKA',
      few: '${quantity} POLOŽKY',
      many: '${quantity} POLOŽKY',
      other: '${quantity} POLOŽEK',
    );
  }

  @override
  String get shrineCartClearButtonCaption => 'VYSYPAT KOŠÍK';

  @override
  String get shrineCartTotalCaption => 'CELKEM';

  @override
  String get shrineCartSubtotalCaption => 'Mezisoučet:';

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

  @override
  String get shrineCartTaxCaption => 'Daň:';

  @override
  String get shrineProductVagabondSack => 'Batoh Vagabond';

  @override
  String get shrineProductStellaSunglasses => 'Slunečná brýle Stella';

  @override
  String get shrineProductWhitneyBelt => 'Pásek Whitney';

  @override
  String get shrineProductGardenStrand => 'Pás zahrady';

  @override
  String get shrineProductStrutEarrings => 'Parádní náušnice';

  @override
  String get shrineProductVarsitySocks => 'Ponožky s pruhem';

  @override
  String get shrineProductWeaveKeyring => 'Pletená klíčenka';

  @override
  String get shrineProductGatsbyHat => 'Bekovka';

  @override
  String get shrineProductShrugBag => 'Taška na rameno';

  @override
  String get shrineProductGiltDeskTrio => 'Trojice pozlacených stolků';

  @override
  String get shrineProductCopperWireRack => 'Regál z měděného drátu';

  @override
  String get shrineProductSootheCeramicSet => 'Uklidňující keramická sada';

  @override
  String get shrineProductHurrahsTeaSet => 'Čajová sada Hurrahs';

  @override
  String get shrineProductBlueStoneMug => 'Břidlicový hrnek';

  @override
  String get shrineProductRainwaterTray => 'Kanálek na dešťovou vodu';

  @override
  String get shrineProductChambrayNapkins => 'Kapesníky Chambray';

  @override
  String get shrineProductSucculentPlanters => 'Květináče se sukulenty';

  @override
  String get shrineProductQuartetTable => 'Stůl pro čtyři';

  @override
  String get shrineProductKitchenQuattro => 'Kuchyňská čtyřka';

  @override
  String get shrineProductClaySweater => 'Svetr barvy jílu';

  @override
  String get shrineProductSeaTunic => 'Tunika barvy moře';

  @override
  String get shrineProductPlasterTunic => 'Tělová tunika';

  @override
  String get shrineProductWhitePinstripeShirt =>
      'Košile s úzkým bílým proužkem';

  @override
  String get shrineProductChambrayShirt => 'Košile Chambray';

  @override
  String get shrineProductSeabreezeSweater => 'Svetr jako mořský vánek';

  @override
  String get shrineProductGentryJacket => 'Sako Gentry';

  @override
  String get shrineProductNavyTrousers => 'Kalhoty barvy námořnické modři';

  @override
  String get shrineProductWalterHenleyWhite =>
      'Triko s knoflíkovou légou Walter (bílé)';

  @override
  String get shrineProductSurfAndPerfShirt => 'Funkční triko na surfování';

  @override
  String get shrineProductGingerScarf => 'Zázvorová šála';

  @override
  String get shrineProductRamonaCrossover => 'Crossover Ramona';

  @override
  String get shrineProductClassicWhiteCollar => 'Klasický bílý límeček';

  @override
  String get shrineProductCeriseScallopTee =>
      'Třešňové triko se zaobleným lemem';

  @override
  String get shrineProductShoulderRollsTee => 'Tričko s odhalenými rameny';

  @override
  String get shrineProductGreySlouchTank => 'Volné šedé tílko';

  @override
  String get shrineProductSunshirtDress => 'Košilové šaty proti slunci';

  @override
  String get shrineProductFineLinesTee => 'Tričko s jemným proužkem';

  @override
  String get shrineTooltipSearch => 'Hledat';

  @override
  String get shrineTooltipSettings => 'Nastavení';

  @override
  String get shrineTooltipOpenMenu => 'Otevřít nabídku';

  @override
  String get shrineTooltipCloseMenu => 'Zavřít nabídku';

  @override
  String get shrineTooltipCloseCart => 'Zavřít košík';

  @override
  String shrineScreenReaderCart(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'Nákupní košík, prázdný',
      one: 'Nákupní košík, 1 položka',
      few: 'Nákupní košík, ${quantity} položky',
      many: 'Nákupní košík, ${quantity} položky',
      other: 'Nákupní košík, ${quantity} položek',
    );
  }

  @override
  String get shrineScreenReaderProductAddToCart => 'Přidat do košíku';

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

  @override
  String get shrineTooltipRemoveItem => 'Odstranit položku';

  @override
  String get craneFormDiners => 'Bary s občerstvením';

  @override
  String get craneFormDate => 'Vyberte datum';

  @override
  String get craneFormTime => 'Vyberte čas';

  @override
  String get craneFormLocation => 'Vyberte místo';

  @override
  String get craneFormTravelers => 'Cestovatelé';

  @override
  String get craneFormOrigin => 'Vyberte počátek cesty';

  @override
  String get craneFormDestination => 'Zvolte cíl';

  @override
  String get craneFormDates => 'Zvolte data';

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

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

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

  @override
  String get craneFly => 'LÉTÁNÍ';

  @override
  String get craneSleep => 'SPÁNEK';

  @override
  String get craneEat => 'JÍDLO';

  @override
  String get craneFlySubhead => 'Objevte lety podle destinace';

  @override
  String get craneSleepSubhead => 'Objevte ubytování podle destinace';

  @override
  String get craneEatSubhead => 'Objevte restaurace podle destinace';

  @override
  String craneFlyStops(int numberOfStops) {
    return intl.Intl.pluralLogic(
      numberOfStops,
      locale: localeName,
      zero: 'Bez mezipřistání',
      one: '1 mezipřistání',
      few: '${numberOfStops} mezipřistání',
      many: '${numberOfStops} mezipřistání',
      other: '${numberOfStops} mezipřistání',
    );
  }

  @override
  String craneSleepProperties(int totalProperties) {
    return intl.Intl.pluralLogic(
      totalProperties,
      locale: localeName,
      zero: 'Žádné dostupné služby',
      one: '1 dostupná služba',
      few: '${totalProperties} dostupné služby',
      many: '${totalProperties} dostupné služby',
      other: '${totalProperties} dostupných služeb',
    );
  }

  @override
  String craneEatRestaurants(int totalRestaurants) {
    return intl.Intl.pluralLogic(
      totalRestaurants,
      locale: localeName,
      zero: 'Žádné restaurace',
      one: '1 restaurace',
      few: '${totalRestaurants} restaurace',
      many: '${totalRestaurants} restaurace',
      other: '${totalRestaurants} restaurací',
    );
  }

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

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

  @override
  String get craneFly2 => 'Údolí Khumbu, Nepál';

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

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

  @override
  String get craneFly5 => 'Vitznau, Švýcarsko';

  @override
  String get craneFly6 => 'Ciudad de México, Mexiko';

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

  @override
  String get craneFly8 => 'Singapur';

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

  @override
  String get craneFly10 => 'Káhira, Egypt';

  @override
  String get craneFly11 => 'Lisabon, Portugalsko';

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

  @override
  String get craneFly13 => 'Bali, Indonésie';

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

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

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

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

  @override
  String get craneSleep4 => 'Vitznau, Švýcarsko';

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

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

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

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

  @override
  String get craneSleep9 => 'Lisabon, Portugalsko';

  @override
  String get craneSleep10 => 'Káhira, Egypt';

  @override
  String get craneSleep11 => 'Tchaj-pej, Tchaj-wan';

  @override
  String get craneEat0 => 'Neapol, Itálie';

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

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

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

  @override
  String get craneEat4 => 'Paříž, Francie';

  @override
  String get craneEat5 => 'Soul, Jižní Korea';

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

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

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

  @override
  String get craneEat9 => 'Madrid, Španělsko';

  @override
  String get craneEat10 => 'Lisabon, Portugalsko';

  @override
  String get craneFly0SemanticLabel =>
      'Chata v zasněžené krajině se stálezelenými stromy';

  @override
  String get craneFly1SemanticLabel => 'Stan na poli';

  @override
  String get craneFly2SemanticLabel =>
      'Modlitební praporky se zasněženou horou v pozadí';

  @override
  String get craneFly3SemanticLabel => 'Pevnost Machu Picchu';

  @override
  String get craneFly4SemanticLabel => 'Bungalovy nad vodou';

  @override
  String get craneFly5SemanticLabel => 'Hotel u jezera na úpatí hor';

  @override
  String get craneFly6SemanticLabel => 'Letecký snímek Paláce výtvarných umění';

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

  @override
  String get craneFly8SemanticLabel => 'Supertree Grove';

  @override
  String get craneFly9SemanticLabel => 'Muž opírající se o staré modré auto';

  @override
  String get craneFly10SemanticLabel =>
      'Minarety mešity al-Azhar při západu slunce';

  @override
  String get craneFly11SemanticLabel => 'Cihlový maják u moře';

  @override
  String get craneFly12SemanticLabel => 'Bazén s palmami';

  @override
  String get craneFly13SemanticLabel => 'Bazén u moře s palmami';

  @override
  String get craneSleep0SemanticLabel => 'Bungalovy nad vodou';

  @override
  String get craneSleep1SemanticLabel =>
      'Chata v zasněžené krajině se stálezelenými stromy';

  @override
  String get craneSleep2SemanticLabel => 'Pevnost Machu Picchu';

  @override
  String get craneSleep3SemanticLabel => 'Muž opírající se o staré modré auto';

  @override
  String get craneSleep4SemanticLabel => 'Hotel u jezera na úpatí hor';

  @override
  String get craneSleep5SemanticLabel => 'Stan na poli';

  @override
  String get craneSleep6SemanticLabel => 'Bazén s palmami';

  @override
  String get craneSleep7SemanticLabel =>
      'Pestrobarevné domy na náměstí Ribeira';

  @override
  String get craneSleep8SemanticLabel => 'Mayské ruiny na útesu nad pláží';

  @override
  String get craneSleep9SemanticLabel => 'Cihlový maják u moře';

  @override
  String get craneSleep10SemanticLabel =>
      'Minarety mešity al-Azhar při západu slunce';

  @override
  String get craneSleep11SemanticLabel => 'Mrakodrap Tchaj-pej 101';

  @override
  String get craneEat0SemanticLabel => 'Pizza v peci na dřevo';

  @override
  String get craneEat1SemanticLabel => 'Prázdný bar s vysokými stoličkami';

  @override
  String get craneEat2SemanticLabel => 'Hamburger';

  @override
  String get craneEat3SemanticLabel => 'Korejské taco';

  @override
  String get craneEat4SemanticLabel => 'Čokoládový dezert';

  @override
  String get craneEat5SemanticLabel => 'Posezení ve stylové restauraci';

  @override
  String get craneEat6SemanticLabel => 'Pokrm z krevet';

  @override
  String get craneEat7SemanticLabel => 'Vchod do pekárny';

  @override
  String get craneEat8SemanticLabel => 'Talíř s humrem';

  @override
  String get craneEat9SemanticLabel => 'Kavárenský pult s cukrovím';

  @override
  String get craneEat10SemanticLabel => 'Žena držící velký sendvič pastrami';

  @override
  String get fortnightlyMenuFrontPage => 'Titulní stránka';

  @override
  String get fortnightlyMenuWorld => 'Svět';

  @override
  String get fortnightlyMenuUS => 'USA';

  @override
  String get fortnightlyMenuPolitics => 'Politika';

  @override
  String get fortnightlyMenuBusiness => 'Byznys';

  @override
  String get fortnightlyMenuTech => 'Technologie';

  @override
  String get fortnightlyMenuScience => 'Věda';

  @override
  String get fortnightlyMenuSports => 'Sport';

  @override
  String get fortnightlyMenuTravel => 'Cestování';

  @override
  String get fortnightlyMenuCulture => 'Kultura';

  @override
  String get fortnightlyTrendingTechDesign => 'Technologický_návrh';

  @override
  String get fortnightlyTrendingReform => 'Reforma';

  @override
  String get fortnightlyTrendingHealthcareRevolution =>
      'Revoluce_ve_zdravotnictví';

  @override
  String get fortnightlyTrendingGreenArmy => 'Zelená_armáda';

  @override
  String get fortnightlyTrendingStocks => 'Akcie';

  @override
  String get fortnightlyLatestUpdates => 'Novinky';

  @override
  String get fortnightlyHeadlineHealthcare =>
      'Nenápadná, zato však zásadní revoluce ve zdravotní péči';

  @override
  String get fortnightlyHeadlineWar => 'Rozdělené životy Američanů za války';

  @override
  String get fortnightlyHeadlineGasoline => 'Budoucnost benzínu';

  @override
  String get fortnightlyHeadlineArmy => 'Reforma Zelené armády zevnitř';

  @override
  String get fortnightlyHeadlineStocks =>
      'Akcie stagnují a mnozí se uchylují k hotovosti';

  @override
  String get fortnightlyHeadlineFabrics =>
      'Designéři využívají technologie k vytváření látek budoucnosti';

  @override
  String get fortnightlyHeadlineFeminists =>
      'Feministky brojí proti předpojatosti';

  @override
  String get fortnightlyHeadlineBees =>
      'Nízké stavy včelstev pro opylování zemědělských plodin';
}
