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

  @override
  String githubRepo(Object repoName) {
    return 'Odkladací priestor GitHub ${repoName}';
  }

  @override
  String aboutDialogDescription(Object repoLink) {
    return 'Ak si chcete zobraziť zdrojový kód tejto aplikácie, prejdite na ${repoLink}.';
  }

  @override
  String get signIn => 'PRIHLÁSIŤ SA';

  @override
  String get bannerDemoText =>
      'Vaše heslo bolo aktualizované v druhom zariadení. Prihláste sa znova.';

  @override
  String get bannerDemoResetText => 'Resetovať banner';

  @override
  String get bannerDemoMultipleText => 'Viacero akcií';

  @override
  String get bannerDemoLeadingText => 'Začiatočná ikona';

  @override
  String get dismiss => 'ZAVRIEŤ';

  @override
  String get backToGallery => 'Späť do služby Gallery';

  @override
  String get cardsDemoTappable => 'Môžete klepnúť';

  @override
  String get cardsDemoSelectable => 'Môžete vybrať (dlhým stlačením)';

  @override
  String get cardsDemoExplore => 'Preskúmať';

  @override
  String cardsDemoExploreSemantics(Object destinationName) {
    return 'Preskúmať ${destinationName}';
  }

  @override
  String cardsDemoShareSemantics(Object destinationName) {
    return 'Zdieľať ${destinationName}';
  }

  @override
  String get cardsDemoTravelDestinationTitle1 =>
      '10 naj miest v štáte Tamil Nadu, ktoré by ste mali navštíviť';

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

  @override
  String get cardsDemoTravelDestinationCity1 => 'Thanjavur';

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

  @override
  String get cardsDemoTravelDestinationTitle2 => 'Umelci južnej Indie';

  @override
  String get cardsDemoTravelDestinationDescription2 => 'Pradenie hodvábu';

  @override
  String get cardsDemoTravelDestinationCity2 => 'Chettinad';

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

  @override
  String get cardsDemoTravelDestinationTitle3 => 'Chrám Brihadisvara Temple';

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

  @override
  String get homeHeaderGallery => 'Galéria';

  @override
  String get homeHeaderCategories => 'Kategórie';

  @override
  String get shrineDescription => 'Módna predajná aplikácia';

  @override
  String get fortnightlyDescription =>
      'Spravodajská aplikácia zameraná na obsah';

  @override
  String get rallyDescription => 'Osobná finančná aplikácia';

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

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

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

  @override
  String get rallyAccountDataVacation => 'Dovolenka';

  @override
  String get rallyAccountDetailDataAnnualPercentageYield =>
      'Ročný percentuálny výnos';

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

  @override
  String get rallyAccountDetailDataInterestYtd =>
      'Úrok od začiatku roka dodnes';

  @override
  String get rallyAccountDetailDataInterestPaidLastYear =>
      'Úroky zaplatené minulý rok';

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

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

  @override
  String get rallyBillDetailTotalAmount => 'Celková suma';

  @override
  String get rallyBillDetailAmountPaid => 'Zaplatená suma';

  @override
  String get rallyBillDetailAmountDue => 'Dlžná suma';

  @override
  String get rallyBudgetCategoryCoffeeShops => 'Kaviarne';

  @override
  String get rallyBudgetCategoryGroceries => 'Potraviny';

  @override
  String get rallyBudgetCategoryRestaurants => 'Reštaurácie';

  @override
  String get rallyBudgetCategoryClothing => 'Oblečenie';

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

  @override
  String get rallyBudgetDetailAmountUsed => 'Minutá suma';

  @override
  String get rallyBudgetDetailAmountLeft => 'Zostatok';

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

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

  @override
  String get rallySettingsPasscodeAndTouchId => 'Vstupný kód a Touch ID';

  @override
  String get rallySettingsNotifications => 'Upozornenia';

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

  @override
  String get rallySettingsPaperlessSettings => 'Nastavenia bez papiera';

  @override
  String get rallySettingsFindAtms => 'Nájsť bankomaty';

  @override
  String get rallySettingsHelp => 'Pomocník';

  @override
  String get rallySettingsSignOut => 'Odhlásiť sa';

  @override
  String get rallyAccountTotal => 'Celkove';

  @override
  String get rallyBillsDue => 'Termín';

  @override
  String get rallyBudgetLeft => 'Zostatok:';

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

  @override
  String get rallyBills => 'Faktúry';

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

  @override
  String get rallyAlerts => 'Upozornenia';

  @override
  String get rallySeeAll => 'ZOBRAZIŤ VŠETKO';

  @override
  String get rallyFinanceLeft => 'ZOSTATOK:';

  @override
  String get rallyTitleOverview => 'PREHĽAD';

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

  @override
  String get rallyTitleBills => 'FAKTÚRY';

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

  @override
  String get rallyTitleSettings => 'NASTAVENIA';

  @override
  String get rallyLoginLoginToRally => 'Prihlásenie do aplikácie Rally';

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

  @override
  String get rallyLoginSignUp => 'REGISTROVAŤ SA';

  @override
  String get rallyLoginUsername => 'Používateľské meno';

  @override
  String get rallyLoginPassword => 'Heslo';

  @override
  String get rallyLoginLabelLogin => 'Prihlásiť sa';

  @override
  String get rallyLoginRememberMe => 'Zapamätať si ma';

  @override
  String get rallyLoginButtonLogin => 'PRIHLÁSIŤ SA';

  @override
  String rallyAlertsMessageHeadsUpShopping(Object percent) {
    return 'Upozorňujeme, že ste minuli ${percent} rozpočtu v Nákupoch na tento mesiac.';
  }

  @override
  String rallyAlertsMessageSpentOnRestaurants(Object amount) {
    return 'Tento týždeň ste minuli ${amount} v reštauráciách.';
  }

  @override
  String rallyAlertsMessageATMFees(Object amount) {
    return 'Tento mesiac ste minuli ${amount} na poplatky v bankomatoch';
  }

  @override
  String rallyAlertsMessageCheckingAccount(Object percent) {
    return 'Dobrá práca. Zostatok na vašom bežnom účte je oproti minulému mesiacu o ${percent} vyšší.';
  }

  @override
  String rallyAlertsMessageUnassignedTransactions(int count) {
    return intl.Intl.pluralLogic(
      count,
      locale: localeName,
      one:
          'Zvýšte svoj potenciálny odpočet dane. Prideľte kategórie 1 nepridelenej transakcii.',
      few:
          'Zvýšte svoj potenciálny odpočet dane. Prideľte kategórie ${count} neprideleným transakciám.',
      many:
          'Zvýšte svoj potenciálny odpočet dane. Assign categories to ${count} unassigned transactions.',
      other:
          'Zvýšte svoj potenciálny odpočet dane. Prideľte kategórie ${count} neprideleným transakciám.',
    );
  }

  @override
  String get rallySeeAllAccounts => 'Zobraziť všetky účty';

  @override
  String get rallySeeAllBills => 'Zobraziť všetky faktúry';

  @override
  String get rallySeeAllBudgets => 'Zobraziť všetky rozpočty';

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

  @override
  String rallyBillAmount(Object billName, Object date, Object amount) {
    return 'Termín splatnosti faktúry za ${billName} vo výške ${amount} je ${date}.';
  }

  @override
  String rallyBudgetAmount(Object budgetName, Object amountUsed,
      Object amountTotal, Object amountLeft) {
    return 'Rozpočet ${budgetName} s minutou sumou ${amountUsed} z ${amountTotal} a zostatkom ${amountLeft}';
  }

  @override
  String get craneDescription => 'Prispôsobená cestovná aplikácia';

  @override
  String get homeCategoryReference => 'ŠTÝLY A ĎALŠIE';

  @override
  String get demoInvalidURL => 'Webovú adresu sa nepodarilo zobraziť:';

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

  @override
  String get demoInfoTooltip => 'Informácie';

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

  @override
  String get demoDocumentationTooltip => 'Dokumentácia rozhraní API';

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

  @override
  String get demoCodeViewerCopyAll => 'KOPÍROVAŤ VŠETKO';

  @override
  String get demoCodeViewerCopiedToClipboardMessage =>
      'Skopírované do schránky.';

  @override
  String demoCodeViewerFailedToCopyToClipboardMessage(Object error) {
    return 'Kopírovanie do schránky sa nepodarilo: ${error}';
  }

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

  @override
  String get demoOptionsFeatureDescription =>
      'Klepnutím sem zobrazíte dostupné možnosti pre túto ukážku.';

  @override
  String get settingsTitle => 'Nastavenia';

  @override
  String get settingsButtonLabel => 'Nastavenia';

  @override
  String get settingsButtonCloseLabel => 'Zavrieť nastavenia';

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

  @override
  String get settingsTextScaling => 'Mierka písma';

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

  @override
  String get settingsTextScalingNormal => 'Normálna';

  @override
  String get settingsTextScalingLarge => 'Veľké';

  @override
  String get settingsTextScalingHuge => 'Veľmi veľké';

  @override
  String get settingsTextDirection => 'Smer textu';

  @override
  String get settingsTextDirectionLocaleBased =>
      'Na základe miestneho nastavenia';

  @override
  String get settingsTextDirectionLTR => 'Ľ-P';

  @override
  String get settingsTextDirectionRTL => 'P-Ľ';

  @override
  String get settingsLocale => 'Miestne nastavenie';

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

  @override
  String get settingsTheme => 'Motív';

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

  @override
  String get settingsLightTheme => 'Svetlý';

  @override
  String get settingsSlowMotion => 'Spomalenie';

  @override
  String get settingsAbout => 'Flutter Gallery';

  @override
  String get settingsFeedback => 'Odoslať spätnú väzbu';

  @override
  String get settingsAttribution => 'Navrhol TOASTER v Londýne';

  @override
  String get demoBottomAppBarTitle => 'Dolný panel aplikácií';

  @override
  String get demoBottomAppBarSubtitle =>
      'Zobrazuje v dolnej časti navigáciu a akcie';

  @override
  String get demoBottomAppBarDescription =>
      'Dolné panely aplikácií poskytujú prístup k dolnému navigačnému vysúvaciemu panelu a až štyrom akciám (vrátane plávajúceho tlačidla akcie).';

  @override
  String get bottomAppBarNotch => 'Výrez';

  @override
  String get bottomAppBarPosition => 'Pozícia plávajúceho tlačidla akcie';

  @override
  String get bottomAppBarPositionDockedEnd => 'Ukotvené – na konci';

  @override
  String get bottomAppBarPositionDockedCenter => 'Ukotvené – v strede';

  @override
  String get bottomAppBarPositionFloatingEnd => 'Plávajúce – na konci';

  @override
  String get bottomAppBarPositionFloatingCenter => 'Plávajúce – v strede';

  @override
  String get demoBannerTitle => 'Banner';

  @override
  String get demoBannerSubtitle => 'Zobrazovanie bannera v zozname';

  @override
  String get demoBannerDescription =>
      'Banner zobrazuje dôležitú nadväzujúcu správu a poskytuje akcie, pomocou ktorých môžu používatelia vybrať možnosti v ňom (alebo ho zavrieť). Na jeho zavretie sa vyžaduje akcia používateľa.';

  @override
  String get demoBottomNavigationTitle => 'Dolná navigácia';

  @override
  String get demoBottomNavigationSubtitle =>
      'Dolná navigácia s prelínajúcimi sa zobrazeniami';

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

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

  @override
  String get demoBottomNavigationDescription =>
      'Dolné navigačné panely zobrazujú v dolnej časti obrazovky tri až päť cieľov. Každý cieľ prestavuje ikona a nepovinný textový štítok. Používateľ, ktorý klepne na ikonu dolnej navigácie, prejde do cieľa navigácie najvyššej úrovne, ktorá je s touto ikonou spojená.';

  @override
  String get demoButtonTitle => 'Tlačidlá';

  @override
  String get demoButtonSubtitle => 'Ploché, zvýšené, s obrysom a ďalšie';

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

  @override
  String get demoFlatButtonDescription =>
      'Ploché tlačidlo po stlačení zobrazí atramentovú škvrnu, ale nezvýši sa. Používajte ploché tlačidlá v paneloch s nástrojmi, dialógových oknách a texte s odsadením';

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

  @override
  String get demoRaisedButtonDescription =>
      'Zvýšené tlačidlá pridávajú rozmery do prevažne plochých rozložení. Zvýrazňujú funkcie v neprehľadných alebo širokých priestoroch.';

  @override
  String get demoOutlineButtonTitle => 'Tlačidlo s obrysom';

  @override
  String get demoOutlineButtonDescription =>
      'Tlačidlá s obrysom sa po stlačení zmenia na nepriehľadné a zvýšia sa. Často sú spárované so zvýšenými tlačidlami na označenie alternatívnej sekundárnej akcie.';

  @override
  String get demoToggleButtonTitle => 'Prepínače';

  @override
  String get demoToggleButtonDescription =>
      'Pomocou prepínačov môžete zoskupiť súvisiace možnosti. Skupina by mala zdieľať spoločný kontajner na zvýraznenie skupín súvisiacich prepínačov';

  @override
  String get demoFloatingButtonTitle => 'Plávajúce tlačidlo akcie';

  @override
  String get demoFloatingButtonDescription =>
      'Plávajúce tlačidlo akcie je okrúhla ikona vznášajúca sa nad obsahom propagujúca primárnu akciu v aplikácii.';

  @override
  String get demoCardTitle => 'Karty';

  @override
  String get demoCardSubtitle => 'Základné karty s oblými rohmi';

  @override
  String get demoChipTitle => 'Prvky';

  @override
  String get demoCardDescription =>
      'Karta je hárok vzhľadu Material, ktorá predstavuje niektoré súvisiace informácie, napríklad album, zemepisnú polohu, jedlo, kontaktné údaje a podobne.';

  @override
  String get demoChipSubtitle =>
      'Kompaktné prvky predstavujúce vstup, atribút alebo akciu';

  @override
  String get demoActionChipTitle => 'Prvok akcie';

  @override
  String get demoActionChipDescription =>
      'Prvky akcie sú skupina možností spúšťajúcich akcie súvisiace s hlavným obsahom. V používateľskom rozhraní by sa mali zobrazovať dynamicky a v kontexte.';

  @override
  String get demoChoiceChipTitle => 'Prvok výberu';

  @override
  String get demoChoiceChipDescription =>
      'Prvky výberu predstavujú jednotlivé možnosti z určitej skupiny. Obsahujú súvisiaci popisný text alebo kategórie.';

  @override
  String get demoFilterChipTitle => 'Prvok filtra';

  @override
  String get demoFilterChipDescription =>
      'Prvky filtra odfiltrujú obsah pomocou značiek alebo popisných slov.';

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

  @override
  String get demoInputChipDescription =>
      'Prvky vstupu sú komplexné informácie, napríklad subjekt (osoba, miesto, vec) alebo text konverzácie, uvedené v kompaktnej podobe.';

  @override
  String get demoDataTableTitle => 'Tabuľky údajov';

  @override
  String get demoDataTableSubtitle => 'Riadky a stĺpce informácií';

  @override
  String get demoDataTableDescription =>
      'Tabuľky údajov zobrazujú informácie vo formáte pripomínajúcom mriežku riadkov a stĺpcov. Usporiadavajú informácie tak, že sa dajú ľahko vyhľadať, takže používatelia môžu hľadať vzory a štatistiky.';

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

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

  @override
  String get dataTableColumnCalories => 'Kalórie';

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

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

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

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

  @override
  String get dataTableColumnCalcium => 'Vápnik';

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

  @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} s cukrom';
  }

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

  @override
  String get demoDialogTitle => 'Dialógové okná';

  @override
  String get demoDialogSubtitle => 'Jednoduché, upozornenie a celá obrazovka';

  @override
  String get demoAlertDialogTitle => 'Upozornenie';

  @override
  String get demoAlertDialogDescription =>
      'Dialógové okno upozornenia informuje používateľa o situáciách, ktoré vyžadujú potvrdenie. Má voliteľný názov a voliteľný zoznam akcií.';

  @override
  String get demoAlertTitleDialogTitle => 'Upozornenie s názvom';

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

  @override
  String get demoSimpleDialogDescription =>
      'Jednoduché dialógové okno poskytuje používateľovi výber medzi viacerými možnosťami. Má voliteľný názov, ktorý sa zobrazuje nad možnosťami.';

  @override
  String get demoGridListsTitle => 'Mriežkové zoznamy';

  @override
  String get demoGridListsSubtitle => 'Rozloženie riadkov a stĺpcov';

  @override
  String get demoGridListsDescription =>
      'Mriežkové zoznamy sú najvhodnejšie na prezentáciu homogénnych dát, zvyčajne obrázkov. Jednotlivé položky v mriežkovom zozname sa nazývajú dlaždice.';

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

  @override
  String get demoGridListsHeaderTitle => 'S hlavičkou';

  @override
  String get demoGridListsFooterTitle => 'S pätou';

  @override
  String get demoSlidersTitle => 'Posúvače';

  @override
  String get demoSlidersSubtitle =>
      'Miniaplikácie na výber hodnoty potiahnutím';

  @override
  String get demoSlidersDescription =>
      'Posúvače predstavujú rozsah hodnôt na pruhu, z ktorých si môžu používatelia jednu vybrať. Sú ideálne na úpravu nastavení, ako je napríklad hlasitosť, jas alebo použitie filtrov obrázkov.';

  @override
  String get demoRangeSlidersTitle => 'Posúvače s rozsahom';

  @override
  String get demoRangeSlidersDescription =>
      'Posúvače predstavujú rozsah hodnôt na pruhu. Môžu mať na oboch koncoch pruhu ikony označujúce rozsah hodnôt. Sú ideálne na úpravu nastavení, ako je napríklad hlasitosť, jas alebo použitie filtrov obrázkov.';

  @override
  String get demoCustomSlidersTitle => 'Vlastné posúvače';

  @override
  String get demoCustomSlidersDescription =>
      'Posúvače predstavujú rozsah hodnôt na pruhu, z ktorých si môžu používatelia vybrať jednu hodnotu alebo určitý rozsah. Môžete im pridať motív alebo si ich prispôsobiť.';

  @override
  String get demoSlidersContinuousWithEditableNumericalValue =>
      'Neobmedzený s upraviteľnou číselnou hodnotou';

  @override
  String get demoSlidersDiscrete => 'Diskrétny';

  @override
  String get demoSlidersDiscreteSliderWithCustomTheme =>
      'Diskrétny posúvač s vlastným motívom';

  @override
  String get demoSlidersContinuousRangeSliderWithCustomTheme =>
      'Neobmedzený posúvač rozsahu a vlastným motívom';

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

  @override
  String get demoSlidersEditableNumericalValue => 'Upraviteľná číselná hodnota';

  @override
  String get demoMenuTitle => 'Ponuka';

  @override
  String get demoContextMenuTitle => 'Kontextová ponuka';

  @override
  String get demoSectionedMenuTitle => 'Rozdelená ponuka';

  @override
  String get demoSimpleMenuTitle => 'Jednoduchá ponuka';

  @override
  String get demoChecklistMenuTitle => 'Ponuka kontrolného zoznamu';

  @override
  String get demoMenuSubtitle => 'Tlačidlá ponuky a jednoduché ponuky';

  @override
  String get demoMenuDescription =>
      'Ponuka zobrazuje zoznam možností v dočasnom okne. Spustí sa pri interakcii používateľov s tlačidlom, akciou alebo iným ovládacím prvkom.';

  @override
  String get demoMenuItemValueOne => 'Prvá položka ponuky';

  @override
  String get demoMenuItemValueTwo => 'Druhá položka ponuky';

  @override
  String get demoMenuItemValueThree => 'Tretia položka ponuky';

  @override
  String get demoMenuOne => 'Jedna';

  @override
  String get demoMenuTwo => 'Dve';

  @override
  String get demoMenuThree => 'Tri';

  @override
  String get demoMenuFour => 'Štyri';

  @override
  String get demoMenuAnItemWithAContextMenuButton =>
      'Položka s kontextovou ponukou';

  @override
  String get demoMenuContextMenuItemOne => 'Prvá položka kontextovej ponuky';

  @override
  String get demoMenuADisabledMenuItem => 'Deaktivovaná položka ponuky';

  @override
  String get demoMenuContextMenuItemThree =>
      'Tretia položka kontextovej ponuky';

  @override
  String get demoMenuAnItemWithASectionedMenu => 'Položka s rozdelenou ponukou';

  @override
  String get demoMenuPreview => 'Zobraziť ukážku';

  @override
  String get demoMenuShare => 'Zdieľať';

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

  @override
  String get demoMenuRemove => 'Odstrániť';

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

  @override
  String demoMenuChecked(Object value) {
    return 'Začiarknuté: ${value}';
  }

  @override
  String get demoMenuAnItemWithASimpleMenu => 'Položka s jednoduchou ponukou';

  @override
  String get demoMenuAnItemWithAChecklistMenu =>
      'Položka s ponukou kontrolného zoznamu';

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

  @override
  String get demoFullscreenDialogDescription =>
      'Hodnota fullscreenDialog určuje, či je prichádzajúca stránka modálne dialógové okno na celú obrazovku';

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

  @override
  String get demoCupertinoActivityIndicatorSubtitle =>
      'Indikátory aktivity v štýle systému iOS';

  @override
  String get demoCupertinoActivityIndicatorDescription =>
      'Indikátor aktivity v štýle systému iOS, ktorý sa otáča v smere hodinových ručičiek.';

  @override
  String get demoCupertinoButtonsTitle => 'Tlačidlá';

  @override
  String get demoCupertinoButtonsSubtitle => 'Tlačidlá v štýle systému iOS';

  @override
  String get demoCupertinoButtonsDescription =>
      'Tlačidlo v štýle systému iOS. Zahŕňa text a ikonu, ktorá sa po dotyku stmaví alebo vybledne. Voliteľne môže mať aj pozadie.';

  @override
  String get demoCupertinoAlertsTitle => 'Upozornenia';

  @override
  String get demoCupertinoAlertsSubtitle =>
      'Dialógové okná upozornení v štýle systému iOS';

  @override
  String get demoCupertinoAlertTitle => 'Upozornenie';

  @override
  String get demoCupertinoAlertDescription =>
      'Dialógové okno upozornenia informuje používateľa o situáciách, ktoré vyžadujú potvrdenie. Dialógové okno upozornenia má voliteľný názov, obsah aj zoznam akcií. Názov sa zobrazuje nad obsahom a akcie pod obsahom.';

  @override
  String get demoCupertinoAlertWithTitleTitle => 'Upozornenie s názvom';

  @override
  String get demoCupertinoAlertButtonsTitle => 'Upozornenie s tlačidlami';

  @override
  String get demoCupertinoAlertButtonsOnlyTitle => 'Iba tlačidlá upozornení';

  @override
  String get demoCupertinoActionSheetTitle => 'Hárok s akciami';

  @override
  String get demoCupertinoActionSheetDescription =>
      'Hárok s akciami je špecifický štýl upozornenia ponúkajúceho používateľovi dve alebo viac možností, ktoré sa týkajú aktuálneho kontextu. Má názov, dodatočnú správu a zoznam akcií.';

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

  @override
  String get demoCupertinoNavigationBarSubtitle =>
      'Navigačný panel v štýle systému iOS';

  @override
  String get demoCupertinoNavigationBarDescription =>
      'Ide o navigačný panel v štýle systému iOS. Navigačný panel je panel s nástrojmi, ktorý vo svojom strede minimálne obsahuje názov stránky.';

  @override
  String get demoCupertinoPickerTitle => 'Výbery';

  @override
  String get demoCupertinoPickerSubtitle =>
      'Výbery dátumu a času v štýle systému iOS';

  @override
  String get demoCupertinoPickerDescription =>
      'Pomocou miniaplikácie výberu v štýle systému iOS môžete vybrať dátumy, časy, alebo oboje.';

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

  @override
  String get demoCupertinoPickerDate => 'Dátum';

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

  @override
  String get demoCupertinoPickerDateTime => 'Dátum a čas';

  @override
  String get demoCupertinoPullToRefreshTitle => 'Obnovenie potiahnutím';

  @override
  String get demoCupertinoPullToRefreshSubtitle =>
      'Potiahnutie v štýle systému iOS na obnovenie riadenia';

  @override
  String get demoCupertinoPullToRefreshDescription =>
      'Miniaplikácia s implementovaným potiahnutím v štýle systému iOS, ktoré umožňuje obnoviť riadenie obsahu.';

  @override
  String get demoCupertinoSegmentedControlTitle => 'Segmentované ovládanie';

  @override
  String get demoCupertinoSegmentedControlSubtitle =>
      'Segmentované ovládanie v štýle systému iOS';

  @override
  String get demoCupertinoSegmentedControlDescription =>
      'Pomocou tejto funkcie môžete vyberať medzi viacerými navzájom sa vylučujúcimi možnosťami. Po vybraní jednej možnosti v segmentovanom ovládaní sa výber ostatných zruší.';

  @override
  String get demoCupertinoSliderTitle => 'Posúvač';

  @override
  String get demoCupertinoSliderSubtitle => 'Posúvač v štýle systému iOS';

  @override
  String get demoCupertinoSliderDescription =>
      'Posúvačom je možné vyberať hodnoty zo súvislej aj nesúvislej skupiny.';

  @override
  String demoCupertinoSliderContinuous(Object value) {
    return 'Súvislá: ${value}';
  }

  @override
  String demoCupertinoSliderDiscrete(Object value) {
    return 'Nesúvislá: ${value}';
  }

  @override
  String get demoCupertinoSwitchSubtitle => 'Prepínač v štýle systému iOS';

  @override
  String get demoCupertinoSwitchDescription =>
      'Prepínačom je možné prepínať stav zapnuté alebo vypnuté pre jedno nastavenie.';

  @override
  String get demoCupertinoTabBarTitle => 'Panel kariet';

  @override
  String get demoCupertinoTabBarSubtitle =>
      'Spodný panel kariet v štýle systému iOS';

  @override
  String get demoCupertinoTabBarDescription =>
      'Spodný navigačný panel kariet v štýle systému iOS. Zobrazuje viacero kariet, z ktorých je jedna aktívna. Predvolene je to prvá karta.';

  @override
  String get cupertinoTabBarHomeTab => 'Domov';

  @override
  String get cupertinoTabBarChatTab => 'Čet';

  @override
  String get cupertinoTabBarProfileTab => 'Profil';

  @override
  String get demoCupertinoTextFieldTitle => 'Textové polia';

  @override
  String get demoCupertinoTextFieldSubtitle =>
      'Textové polia v štýle systému iOS';

  @override
  String get demoCupertinoTextFieldDescription =>
      'Textové pole umožňuje používateľovi zadávať text, či už pomocou hardvérovej klávesnice, alebo tej na obrazovke.';

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

  @override
  String get demoColorsSubtitle => 'Všetky vopred definované farby';

  @override
  String get demoColorsDescription =>
      'Konštantné farby a vzorka farieb, ktoré predstavujú paletu farieb vzhľadu Material Design.';

  @override
  String get demoTypographyTitle => 'Typografia';

  @override
  String get demoTypographySubtitle => 'Všetky preddefinované štýly textu';

  @override
  String get demoTypographyDescription =>
      'Definície rôznych typografických štýlov vo vzhľade Material Design.';

  @override
  String get demo2dTransformationsTitle => '2D transformácie';

  @override
  String get demo2dTransformationsSubtitle =>
      'Posunutie, priblíženie a otočenie';

  @override
  String get demo2dTransformationsDescription =>
      'Klepnutím upavujte dlaždice a gestami sa pohybujte po okolí. Posúvajte presunutím, približujte stiahnutím prstov a otáčajte dvoma prstami. Na začiatočnú orientáciu sa vrátite stlačením tlačidla Resetovať.';

  @override
  String get demo2dTransformationsResetTooltip => 'Resetovať transformácie';

  @override
  String get demo2dTransformationsEditTooltip => 'Upraviť dlaždicu';

  @override
  String get buttonText => 'TLAČIDLO';

  @override
  String get demoBottomSheetTitle => 'Dolný hárok';

  @override
  String get demoBottomSheetSubtitle => 'Trvalé a modálne dolné hárky';

  @override
  String get demoBottomSheetPersistentTitle => 'Trvalý dolný hárok';

  @override
  String get demoBottomSheetPersistentDescription =>
      'Trvalý dolný hárok zobrazuje informácie doplňujúce hlavný obsah aplikácie. Zobrazuje sa neustále, aj keď používateľ interaguje s inými časťami aplikácie.';

  @override
  String get demoBottomSheetModalTitle => 'Modálny dolný hárok';

  @override
  String get demoBottomSheetModalDescription =>
      'Modálny dolný hárok je alternatíva k ponuke alebo dialógovému oknu. Bráni používateľovi interagovať so zvyškom aplikácie.';

  @override
  String get demoBottomSheetAddLabel => 'Pridať';

  @override
  String get demoBottomSheetButtonText => 'ZOBRAZIŤ DOLNÝ HÁROK';

  @override
  String get demoBottomSheetHeader => 'Hlavička';

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

  @override
  String get demoListsTitle => 'Zoznamy';

  @override
  String get demoListsSubtitle => 'Rozloženia posúvacích zoznamov';

  @override
  String get demoListsDescription =>
      'Jeden riadok s pevnou výškou, ktorý obvykle obsahuje text a ikonu na začiatku alebo na konci.';

  @override
  String get demoOneLineListsTitle => 'Jeden riadok';

  @override
  String get demoTwoLineListsTitle => 'Dva riadky';

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

  @override
  String get demoProgressIndicatorTitle => 'Indikátory priebehu';

  @override
  String get demoProgressIndicatorSubtitle => 'Lineárne, kruhové, neurčené';

  @override
  String get demoCircularProgressIndicatorTitle => 'Kruhový indikátor priebehu';

  @override
  String get demoCircularProgressIndicatorDescription =>
      'Kruhový indikátor priebehu so vzhľadom Material Design, ktorý sa otáča, keď je aplikácia zaneprázdnená.';

  @override
  String get demoLinearProgressIndicatorTitle => 'Lineárny indikátor priebehu';

  @override
  String get demoLinearProgressIndicatorDescription =>
      'Lineárny indikátor priebehu so vzhľadom Material Design, ktorý sa nazýva aj ukazovateľ priebehu.';

  @override
  String get demoPickersTitle => 'Výbery';

  @override
  String get demoPickersSubtitle => 'Výber dátumu a času';

  @override
  String get demoDatePickerTitle => 'Výber dátumu';

  @override
  String get demoDatePickerDescription =>
      'Zobrazuje dialógové okno s výberom dátumu so vzhľadom Material Design.';

  @override
  String get demoTimePickerTitle => 'Výber času';

  @override
  String get demoTimePickerDescription =>
      'Zobrazuje dialógové okno s výberom času so vzhľadom Material Design.';

  @override
  String get demoPickersShowPicker => 'ZOBRAZIŤ VÝBER';

  @override
  String get demoTabsTitle => 'Karty';

  @override
  String get demoTabsScrollingTitle => 'Posúvací';

  @override
  String get demoTabsNonScrollingTitle => 'Neposúvací';

  @override
  String get demoTabsSubtitle =>
      'Karty so samostatne posúvateľnými zobrazeniami';

  @override
  String get demoTabsDescription =>
      'Karty usporiadajú obsah z rôznych obrazoviek, množín údajov a ďalších interakcií.';

  @override
  String get demoSnackbarsTitle => 'Oznámenia';

  @override
  String get demoSnackbarsSubtitle =>
      'Oznámenia zobrazujú správy v dolnej časti obrazovky';

  @override
  String get demoSnackbarsDescription =>
      'Oznámenia informujú používateľov o procese, ktorý aplikácia vykonáva alebo bude vykonávať. Zobrazujú sa dočasne v dolnej časti obrazovky. Nemali by rušiť dojem používateľov a na zrušenie ich zobrazovania nie je zo strany používateľa potrebná žiadna akcia.';

  @override
  String get demoSnackbarsButtonLabel => 'ZOBRAZIŤ OZNÁMENIE';

  @override
  String get demoSnackbarsText => 'Toto je oznámenie.';

  @override
  String get demoSnackbarsActionButtonLabel => 'AKCIA';

  @override
  String get demoSnackbarsAction => 'Stlačili ste tlačidlo akcie oznámenia.';

  @override
  String get demoSelectionControlsTitle => 'Ovládacie prvky výberu';

  @override
  String get demoSelectionControlsSubtitle =>
      'Začiarkavacie políčka a prepínače';

  @override
  String get demoSelectionControlsCheckboxTitle => 'Začiarkavacie políčko';

  @override
  String get demoSelectionControlsCheckboxDescription =>
      'Začiarkavacie políčka umožňujú používateľovi vybrať viacero možností zo skupiny možností. Hodnota bežného začiarkavacieho políčka je pravda alebo nepravda. Hodnota začiarkavacieho políčka s troma stavmi môže byť tiež nulová.';

  @override
  String get demoSelectionControlsRadioTitle => 'Prepínač';

  @override
  String get demoSelectionControlsRadioDescription =>
      'Prepínače umožňujú používateľovi vybrať jednu položku zo skupiny možností. Prepínače použite na výhradný výber, ak sa domnievate, že používateľ by mal vidieť všetky dostupné možnosti vedľa seba.';

  @override
  String get demoSelectionControlsSwitchTitle => 'Prepínač';

  @override
  String get demoSelectionControlsSwitchDescription =>
      'Prepínače na zapnutie alebo vypnutie stavu jednej možnosti nastavení. Príslušná možnosť, ktorú prepínač ovláda, ako aj stav, v ktorom sa nachádza, by mali jasne vyplývať zo zodpovedajúceho vloženého štítka.';

  @override
  String get demoBottomTextFieldsTitle => 'Textové polia';

  @override
  String get demoTextFieldTitle => 'Textové polia';

  @override
  String get demoTextFieldSubtitle =>
      'Jeden riadok upraviteľného textu a čísel';

  @override
  String get demoTextFieldDescription =>
      'Textové polia umožňujú používateľom zadávať text do používateľského rozhrania. Zvyčajne sa nachádzajú vo formulároch a dialógových oknách.';

  @override
  String get demoTextFieldShowPasswordLabel => 'Zobraziť heslo';

  @override
  String get demoTextFieldHidePasswordLabel => 'Skryť heslo';

  @override
  String get demoTextFieldFormErrors =>
      'Pred odoslaním odstráňte chyby označené červenou.';

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

  @override
  String get demoTextFieldOnlyAlphabeticalChars =>
      'Zadajte iba abecedné znaky.';

  @override
  String get demoTextFieldEnterUSPhoneNumber =>
      '(###) ###-#### – Zadajte telefónne číslo v USA.';

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

  @override
  String get demoTextFieldPasswordsDoNotMatch => 'Heslá sa nezhodujú';

  @override
  String get demoTextFieldWhatDoPeopleCallYou =>
      'V súvislosti s čím vám ľudia volajú?';

  @override
  String get demoTextFieldNameField => 'Názov*';

  @override
  String get demoTextFieldWhereCanWeReachYou =>
      'Na akom čísle sa môžeme s vami spojiť?';

  @override
  String get demoTextFieldPhoneNumber => 'Telefónne číslo*';

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

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

  @override
  String get demoTextFieldTellUsAboutYourself =>
      'Povedzte nám o sebe (napíšte napríklad, kde pracujete alebo aké máte záľuby)';

  @override
  String get demoTextFieldKeepItShort =>
      'Napíšte stručný text. Toto je iba ukážka.';

  @override
  String get demoTextFieldLifeStory => 'Biografia';

  @override
  String get demoTextFieldSalary => 'Plat';

  @override
  String get demoTextFieldUSD => 'USD';

  @override
  String get demoTextFieldNoMoreThan => 'Maximálne 8 znakov.';

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

  @override
  String get demoTextFieldRetypePassword => 'Znovu zadajte heslo*';

  @override
  String get demoTextFieldSubmit => 'ODOSLAŤ';

  @override
  String demoTextFieldNameHasPhoneNumber(Object name, Object phoneNumber) {
    return 'Telefónne číslo používateľa ${name} je ${phoneNumber}';
  }

  @override
  String get demoTextFieldRequiredField => '* Označuje povinné pole.';

  @override
  String get demoTooltipTitle => 'Popisy';

  @override
  String get demoTooltipSubtitle =>
      'Krátka správa zobrazujúca sa po dlhom stlačení alebo umiestnení kurzora myši';

  @override
  String get demoTooltipDescription =>
      'Popisy poskytujú textové štítky, ktoré pomáhajú vysvetliť funkciu tlačidla alebo inej akcie v používateľskom rozhraní. Zobrazujú informatívny text, keď používatelia umiestnia kurzor myši na prvok, označia ho alebo ho dlho stlačia.';

  @override
  String get demoTooltipInstructions =>
      'Popis zobrazíte dlhým stlačením alebo umiestnením kurzora myši.';

  @override
  String get bottomNavigationCommentsTab => 'Komentáre';

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

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

  @override
  String get bottomNavigationAlarmTab => 'Budík';

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

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

  @override
  String get buttonTextCreate => 'Vytvoriť';

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

  @override
  String get chipTurnOnLights => 'Zapnúť svetlá';

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

  @override
  String get chipMedium => 'Stredné';

  @override
  String get chipLarge => 'Veľké';

  @override
  String get chipElevator => 'Výťah';

  @override
  String get chipWasher => 'Práčka';

  @override
  String get chipFireplace => 'Krb';

  @override
  String get chipBiking => 'Cyklistika';

  @override
  String get dialogDiscardTitle => 'Chcete zahodiť koncept?';

  @override
  String get dialogLocationTitle =>
      'Chcete použiť službu určovania polohy od Googlu?';

  @override
  String get dialogLocationDescription =>
      'Povoľte, aby mohol Google pomáhať aplikáciám určovať polohu. Znamená to, že do Googlu budú odosielané anonymné údaje o polohe, aj keď nebudú spustené žiadne aplikácie.';

  @override
  String get dialogCancel => 'ZRUŠIŤ';

  @override
  String get dialogDiscard => 'ZAHODIŤ';

  @override
  String get dialogDisagree => 'NESÚHLASÍM';

  @override
  String get dialogAgree => 'SÚHLASÍM';

  @override
  String get dialogSetBackup => 'Nastavenie zálohovacieho účtu';

  @override
  String get dialogAddAccount => 'Pridať účet';

  @override
  String get dialogShow => 'ZOBRAZIŤ DIALÓGOVÉ OKNO';

  @override
  String get dialogFullscreenTitle => 'Dialógové okno na celú obrazovku';

  @override
  String get dialogFullscreenSave => 'ULOŽIŤ';

  @override
  String get dialogFullscreenDescription =>
      'Ukážka dialógového okna na celú obrazovku';

  @override
  String get cupertinoButton => 'Tlačidlo';

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

  @override
  String get cupertinoAlertCancel => 'Zrušiť';

  @override
  String get cupertinoAlertDiscard => 'Zahodiť';

  @override
  String get cupertinoAlertLocationTitle =>
      'Chcete povoliť Mapám prístup k vašej polohe, keď túto aplikáciu používate?';

  @override
  String get cupertinoAlertLocationDescription =>
      'Vaša aktuálna poloha sa zobrazí na mape a budú sa pomocou nej vyhľadávať trasy, výsledky vyhľadávania v okolí a odhadované časy cesty.';

  @override
  String get cupertinoAlertAllow => 'Povoliť';

  @override
  String get cupertinoAlertDontAllow => 'Nepovoliť';

  @override
  String get cupertinoAlertFavoriteDessert => 'Výber obľúbeného dezertu';

  @override
  String get cupertinoAlertDessertDescription =>
      'Vyberte si v zozname nižšie svoj obľúbený typ dezertu. Na základe vášho výberu sa prispôsobí zoznam navrhovaných reštaurácií vo vašom okolí.';

  @override
  String get cupertinoAlertCheesecake => 'Tvarohový koláč';

  @override
  String get cupertinoAlertTiramisu => 'Tiramisu';

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

  @override
  String get cupertinoAlertChocolateBrownie => 'Čokoládový koláč';

  @override
  String get cupertinoShowAlert => 'Zobraziť upozornenie';

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

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

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

  @override
  String get colorsDeepPurple => 'TMAVOFIALOVÁ';

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

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

  @override
  String get colorsLightBlue => 'SVETLOMODRÁ';

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

  @override
  String get colorsTeal => 'MODROZELENÁ';

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

  @override
  String get colorsLightGreen => 'SVETLOZELENÁ';

  @override
  String get colorsLime => 'ŽLTOZELENÁ';

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

  @override
  String get colorsAmber => 'ŽLTOHNEDÁ';

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

  @override
  String get colorsDeepOrange => 'TMAVOORANŽOVÁ';

  @override
  String get colorsBrown => 'HNEDÁ';

  @override
  String get colorsGrey => 'SIVÁ';

  @override
  String get colorsBlueGrey => 'MODROSIVÁ';

  @override
  String get placeChennai => 'Chennai';

  @override
  String get placeTanjore => 'Thanjavur';

  @override
  String get placeChettinad => 'Chettinad';

  @override
  String get placePondicherry => 'Pondicherry';

  @override
  String get placeFlowerMarket => 'Trh s kvetmi';

  @override
  String get placeBronzeWorks => 'Bronzová zlievareň';

  @override
  String get placeMarket => 'Trh';

  @override
  String get placeThanjavurTemple => 'Chrám v Thanjavure';

  @override
  String get placeSaltFarm => 'Soľná farma';

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

  @override
  String get placeSilkMaker => 'Výrobca hodvábu';

  @override
  String get placeLunchPrep => 'Príprava obeda';

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

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

  @override
  String get starterAppTitle => 'Štartovacia aplikácia';

  @override
  String get starterAppDescription =>
      'Responzívne rozloženie štartovacej aplikácie';

  @override
  String get starterAppGenericButton => 'TLAČIDLO';

  @override
  String get starterAppTooltipAdd => 'Pridať';

  @override
  String get starterAppTooltipFavorite => 'Zaradiť medzi obľúbené';

  @override
  String get starterAppTooltipShare => 'Zdieľať';

  @override
  String get starterAppTooltipSearch => 'Hľadať';

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

  @override
  String get starterAppGenericSubtitle => 'Podnadpis';

  @override
  String get starterAppGenericHeadline => 'Nadpis';

  @override
  String get starterAppGenericBody => 'Obsahová časť';

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

  @override
  String get shrineMenuCaption => 'PONUKA';

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

  @override
  String get shrineCategoryNameAccessories => 'DOPLNKY';

  @override
  String get shrineCategoryNameClothing => 'OBLEČENIE';

  @override
  String get shrineCategoryNameHome => 'DOMÁCNOSŤ';

  @override
  String get shrineLogoutButtonCaption => 'ODHLÁSIŤ SA';

  @override
  String get shrineLoginUsernameLabel => 'Používateľské meno';

  @override
  String get shrineLoginPasswordLabel => 'Heslo';

  @override
  String get shrineCancelButtonCaption => 'ZRUŠIŤ';

  @override
  String get shrineNextButtonCaption => 'ĎALEJ';

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

  @override
  String shrineProductQuantity(Object quantity) {
    return 'Množstvo: ${quantity}';
  }

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

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

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

  @override
  String get shrineCartTotalCaption => 'CELKOVE';

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

  @override
  String get shrineCartShippingCaption => 'Dopravné:';

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

  @override
  String get shrineProductVagabondSack => 'Taška Vagabond';

  @override
  String get shrineProductStellaSunglasses => 'Slnečné okuliare Stella';

  @override
  String get shrineProductWhitneyBelt => 'Opasok Whitney';

  @override
  String get shrineProductGardenStrand => 'Záhradný pás';

  @override
  String get shrineProductStrutEarrings => 'Náušnice Strut';

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

  @override
  String get shrineProductWeaveKeyring => 'Kľúčenka Weave';

  @override
  String get shrineProductGatsbyHat => 'Klobúk Gatsby';

  @override
  String get shrineProductShrugBag => 'Kabelka na plece';

  @override
  String get shrineProductGiltDeskTrio => 'Trio pozlátených stolíkov';

  @override
  String get shrineProductCopperWireRack => 'Medený drôtený stojan';

  @override
  String get shrineProductSootheCeramicSet => 'Keramická súprava Soothe';

  @override
  String get shrineProductHurrahsTeaSet => 'Čajová súprava Hurrahs';

  @override
  String get shrineProductBlueStoneMug => 'Modrý keramický pohár';

  @override
  String get shrineProductRainwaterTray => 'Zberná nádoba na dažďovú vodu';

  @override
  String get shrineProductChambrayNapkins => 'Obrúsky Chambray';

  @override
  String get shrineProductSucculentPlanters => 'Sukulenty';

  @override
  String get shrineProductQuartetTable => 'Štvorcový stôl';

  @override
  String get shrineProductKitchenQuattro => 'Kuchynská skrinka';

  @override
  String get shrineProductClaySweater => 'Terakotový sveter';

  @override
  String get shrineProductSeaTunic => 'Plážová tunika';

  @override
  String get shrineProductPlasterTunic => 'Tunika';

  @override
  String get shrineProductWhitePinstripeShirt => 'Biela pásiková košeľa';

  @override
  String get shrineProductChambrayShirt => 'Košeľa Chambray';

  @override
  String get shrineProductSeabreezeSweater => 'Sveter na chladný vánok';

  @override
  String get shrineProductGentryJacket => 'Kabátik';

  @override
  String get shrineProductNavyTrousers => 'Námornícke nohavice';

  @override
  String get shrineProductWalterHenleyWhite =>
      'Tričko bez límca so zapínaním Walter (biele)';

  @override
  String get shrineProductSurfAndPerfShirt => 'Surferské tričko';

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

  @override
  String get shrineProductRamonaCrossover => 'Prechodné šaty Ramona';

  @override
  String get shrineProductClassicWhiteCollar =>
      'Klasická košeľa s bielym límcom';

  @override
  String get shrineProductCeriseScallopTee => 'Tričko s lemom Cerise';

  @override
  String get shrineProductShoulderRollsTee => 'Tričko na plecia';

  @override
  String get shrineProductGreySlouchTank => 'Sivé tielko';

  @override
  String get shrineProductSunshirtDress => 'Slnečné šaty';

  @override
  String get shrineProductFineLinesTee => 'Tričko s tenkými pásikmi';

  @override
  String get shrineTooltipSearch => 'Hľadať';

  @override
  String get shrineTooltipSettings => 'Nastavenia';

  @override
  String get shrineTooltipOpenMenu => 'Otvoriť ponuku';

  @override
  String get shrineTooltipCloseMenu => 'Zavrieť ponuku';

  @override
  String get shrineTooltipCloseCart => 'Zavrieť košík';

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

  @override
  String get shrineScreenReaderProductAddToCart => 'Pridať do košíka';

  @override
  String shrineScreenReaderRemoveProductButton(Object product) {
    return 'Odstrániť výrobok ${product}';
  }

  @override
  String get shrineTooltipRemoveItem => 'Odstrániť položku';

  @override
  String get craneFormDiners => 'Reštaurácie';

  @override
  String get craneFormDate => 'Vyberte dátum';

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

  @override
  String get craneFormLocation => 'Vyberte miesto';

  @override
  String get craneFormTravelers => 'Cestujúci';

  @override
  String get craneFormOrigin => 'Vyberte východiskové miesto';

  @override
  String get craneFormDestination => 'Vyberte cieľ';

  @override
  String get craneFormDates => 'Vyberte dátumy';

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

  @override
  String get craneSleep => 'REŽIM SPÁNKU';

  @override
  String get craneEat => 'JEDLO';

  @override
  String get craneFlySubhead => 'Prieskum letov podľa cieľa';

  @override
  String get craneSleepSubhead => 'Prieskum objektov podľa cieľa';

  @override
  String get craneEatSubhead => 'Prieskum reštaurácií podľa cieľa';

  @override
  String craneFlyStops(int numberOfStops) {
    return intl.Intl.pluralLogic(
      numberOfStops,
      locale: localeName,
      zero: 'Priamy let',
      one: '1 medzipristátie',
      few: '${numberOfStops} medzipristátia',
      many: '${numberOfStops} stops',
      other: '${numberOfStops} medzipristátí',
    );
  }

  @override
  String craneSleepProperties(int totalProperties) {
    return intl.Intl.pluralLogic(
      totalProperties,
      locale: localeName,
      zero: 'Žiadne dostupné objekty',
      one: '1 dostupný objekt',
      few: '${totalProperties} dostupné objekty',
      many: '${totalProperties} Available Properties',
      other: '${totalProperties} dostupných objektov',
    );
  }

  @override
  String craneEatRestaurants(int totalRestaurants) {
    return intl.Intl.pluralLogic(
      totalRestaurants,
      locale: localeName,
      zero: 'Žiadne reštaurácie',
      one: '1 reštaurácia',
      few: '${totalRestaurants} reštaurácie',
      many: '${totalRestaurants} Restaurants',
      other: '${totalRestaurants} reštaurácií',
    );
  }

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

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

  @override
  String get craneFly2 => 'Dolina Khumbu, Nepál';

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

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

  @override
  String get craneFly5 => 'Vitznau, Švajčiarsko';

  @override
  String get craneFly6 => 'Mexiko (mesto), 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ézia';

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

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

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

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

  @override
  String get craneSleep4 => 'Vitznau, Švajčiarsko';

  @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, Taiwan';

  @override
  String get craneEat0 => 'Neapol, Taliansko';

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

  @override
  String get craneEat2 => 'Córdoba, Argentína';

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

  @override
  String get craneEat4 => 'Paríž, Francúzsko';

  @override
  String get craneEat5 => 'Soul, Južná Kórea';

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

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

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

  @override
  String get craneEat9 => 'Madrid, Španielsko';

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

  @override
  String get craneFly0SemanticLabel =>
      'Chata v zasneženej krajine s ihličnatými stromami';

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

  @override
  String get craneFly2SemanticLabel =>
      'Modlitebné vlajky so zasneženou horou v pozadí';

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

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

  @override
  String get craneFly5SemanticLabel =>
      'Hotel na brehu jazera s horami v pozadí';

  @override
  String get craneFly6SemanticLabel =>
      'Letecký pohľad na palác Palacio de Bellas Artes';

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

  @override
  String get craneFly8SemanticLabel => 'Háj superstromov';

  @override
  String get craneFly9SemanticLabel =>
      'Muž opierajúci sa o starodávne modré auto';

  @override
  String get craneFly10SemanticLabel => 'Veže mešity Al-Azhar pri západe slnka';

  @override
  String get craneFly11SemanticLabel => 'Tehlový maják pri mori';

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

  @override
  String get craneFly13SemanticLabel => 'Bazén pri mori s palmami';

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

  @override
  String get craneSleep1SemanticLabel =>
      'Chata v zasneženej krajine s ihličnatými stromami';

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

  @override
  String get craneSleep3SemanticLabel =>
      'Muž opierajúci sa o starodávne modré auto';

  @override
  String get craneSleep4SemanticLabel =>
      'Hotel na brehu jazera s horami v pozadí';

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

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

  @override
  String get craneSleep7SemanticLabel =>
      'Pestrofarebné byty na námestí Riberia';

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

  @override
  String get craneSleep9SemanticLabel => 'Tehlový maják pri mori';

  @override
  String get craneSleep10SemanticLabel =>
      'Veže mešity Al-Azhar pri západe slnka';

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

  @override
  String get craneEat0SemanticLabel => 'Pizza v peci na drevo';

  @override
  String get craneEat1SemanticLabel =>
      'Prázdny bar so stoličkami v bufetovom štýle';

  @override
  String get craneEat2SemanticLabel => 'Hamburger';

  @override
  String get craneEat3SemanticLabel => 'Kórejské taco';

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

  @override
  String get craneEat5SemanticLabel =>
      'Priestor na sedenie v umeleckej reštaurácii';

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

  @override
  String get craneEat7SemanticLabel => 'Vstup do pekárne';

  @override
  String get craneEat8SemanticLabel => 'Tanier s rakmi';

  @override
  String get craneEat9SemanticLabel => 'Kaviarenský pult s múčnikmi';

  @override
  String get craneEat10SemanticLabel => 'Žena s obrovským pastrami sendvičom';

  @override
  String get fortnightlyMenuFrontPage => 'Titulná strana';

  @override
  String get fortnightlyMenuWorld => 'Svet';

  @override
  String get fortnightlyMenuUS => 'USA';

  @override
  String get fortnightlyMenuPolitics => 'Politika';

  @override
  String get fortnightlyMenuBusiness => 'Biznis';

  @override
  String get fortnightlyMenuTech => 'Technológie';

  @override
  String get fortnightlyMenuScience => 'Veda';

  @override
  String get fortnightlyMenuSports => 'Šport';

  @override
  String get fortnightlyMenuTravel => 'Cestovanie';

  @override
  String get fortnightlyMenuCulture => 'Kultúra';

  @override
  String get fortnightlyTrendingTechDesign => 'Technologický dizajn';

  @override
  String get fortnightlyTrendingReform => 'Reforma';

  @override
  String get fortnightlyTrendingHealthcareRevolution =>
      'Revolúcia v zdravotníctve';

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

  @override
  String get fortnightlyTrendingStocks => 'Akcie';

  @override
  String get fortnightlyLatestUpdates => 'Posledné novinky';

  @override
  String get fortnightlyHeadlineHealthcare =>
      'Tichá, ale zároveň účinná revolúcia v zdravotníctve';

  @override
  String get fortnightlyHeadlineWar =>
      'Rozdelené životy američanov počas vojny';

  @override
  String get fortnightlyHeadlineGasoline => 'Budúcnosť benzínu';

  @override
  String get fortnightlyHeadlineArmy => 'Reforma Zelenej armády zvnútra';

  @override
  String get fortnightlyHeadlineStocks =>
      'V čase stagnácie akcií sa mnohí sústreďujú na menu';

  @override
  String get fortnightlyHeadlineFabrics =>
      'Pomocou technológií vyrábajú návrhári futuristické látky';

  @override
  String get fortnightlyHeadlineFeminists =>
      'Feministky sa vrhli na partizánstvo';

  @override
  String get fortnightlyHeadlineBees => 'Nedostatok poľnohospodárskych včiel';
}
