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

  @override
  String githubRepo(Object repoName) {
    return 'GitHub spremište ${repoName}';
  }

  @override
  String aboutDialogDescription(Object repoLink) {
    return 'Da biste vidjeli izvorni kôd za ovu aplikaciju, posjetite ${repoLink}.';
  }

  @override
  String get signIn => 'PRIJAVA';

  @override
  String get bannerDemoText =>
      'Vaša je zaporka ažurirana na vašem drugom uređaju. Prijavite se ponovo.';

  @override
  String get bannerDemoResetText => 'Poništi natpis';

  @override
  String get bannerDemoMultipleText => 'Više radnji';

  @override
  String get bannerDemoLeadingText => 'Početna ikona';

  @override
  String get dismiss => 'ODBACI';

  @override
  String get backToGallery => 'Natrag u galeriju';

  @override
  String get cardsDemoTappable => 'Reagira na dodir';

  @override
  String get cardsDemoSelectable => 'Može se odabrati (dugi pritisak)';

  @override
  String get cardsDemoExplore => 'Istražite';

  @override
  String cardsDemoExploreSemantics(Object destinationName) {
    return 'Istražite: ${destinationName}';
  }

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

  @override
  String get cardsDemoTravelDestinationTitle1 =>
      'Deset gradova koje trebate posjetiti u Tamil Naduu';

  @override
  String get cardsDemoTravelDestinationDescription1 => 'Broj 10';

  @override
  String get cardsDemoTravelDestinationCity1 => 'Thanjavur';

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

  @override
  String get cardsDemoTravelDestinationTitle2 => 'Obrtnici južne Indije';

  @override
  String get cardsDemoTravelDestinationDescription2 => 'Prelci svile';

  @override
  String get cardsDemoTravelDestinationCity2 => 'Chettinad';

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

  @override
  String get cardsDemoTravelDestinationTitle3 => 'Hram Brihadisvara';

  @override
  String get cardsDemoTravelDestinationDescription3 => 'Hramovi';

  @override
  String get homeHeaderGallery => 'Galerija';

  @override
  String get homeHeaderCategories => 'Kategorije';

  @override
  String get shrineDescription => 'Moderna aplikacija za maloprodaju';

  @override
  String get fortnightlyDescription => 'Aplikacija vijesti sa sadržajem';

  @override
  String get rallyDescription => 'Aplikacija za osobne financije';

  @override
  String get rallyAccountDataChecking => 'Tekući';

  @override
  String get rallyAccountDataHomeSavings => 'Štednja za kupnju doma';

  @override
  String get rallyAccountDataCarSavings => 'Štednja za automobil';

  @override
  String get rallyAccountDataVacation => 'Odmor';

  @override
  String get rallyAccountDetailDataAnnualPercentageYield =>
      'Godišnji postotak prinosa';

  @override
  String get rallyAccountDetailDataInterestRate => 'Kamatna stopa';

  @override
  String get rallyAccountDetailDataInterestYtd =>
      'Kamate od početka godine do danas';

  @override
  String get rallyAccountDetailDataInterestPaidLastYear =>
      'Kamate plaćene prošle godine';

  @override
  String get rallyAccountDetailDataNextStatement => 'Sljedeća izjava';

  @override
  String get rallyAccountDetailDataAccountOwner => 'Vlasnik računa';

  @override
  String get rallyBillDetailTotalAmount => 'Ukupni iznos';

  @override
  String get rallyBillDetailAmountPaid => 'Plaćeni iznos';

  @override
  String get rallyBillDetailAmountDue => 'Iznos duga';

  @override
  String get rallyBudgetCategoryCoffeeShops => 'Kafići';

  @override
  String get rallyBudgetCategoryGroceries => 'Namirnice';

  @override
  String get rallyBudgetCategoryRestaurants => 'Restorani';

  @override
  String get rallyBudgetCategoryClothing => 'Odjeća';

  @override
  String get rallyBudgetDetailTotalCap => 'Ukupna kapitalizacija';

  @override
  String get rallyBudgetDetailAmountUsed => 'Iskorišteni iznos';

  @override
  String get rallyBudgetDetailAmountLeft => 'Preostali iznos';

  @override
  String get rallySettingsManageAccounts => 'Upravljajte računima';

  @override
  String get rallySettingsTaxDocuments => 'Porezni dokumenti';

  @override
  String get rallySettingsPasscodeAndTouchId => 'Šifra i Touch ID';

  @override
  String get rallySettingsNotifications => 'Obavijesti';

  @override
  String get rallySettingsPersonalInformation => 'Osobni podaci';

  @override
  String get rallySettingsPaperlessSettings => 'Postavke bez papira';

  @override
  String get rallySettingsFindAtms => 'Pronađite bankomate';

  @override
  String get rallySettingsHelp => 'Pomoć';

  @override
  String get rallySettingsSignOut => 'Odjava';

  @override
  String get rallyAccountTotal => 'Ukupno';

  @override
  String get rallyBillsDue => 'Rok';

  @override
  String get rallyBudgetLeft => 'Preostalo';

  @override
  String get rallyAccounts => 'Računi';

  @override
  String get rallyBills => 'Računi';

  @override
  String get rallyBudgets => 'Proračuni';

  @override
  String get rallyAlerts => 'Upozorenja';

  @override
  String get rallySeeAll => 'PRIKAŽI SVE';

  @override
  String get rallyFinanceLeft => 'PREOSTALO';

  @override
  String get rallyTitleOverview => 'PREGLED';

  @override
  String get rallyTitleAccounts => 'RAČUNI';

  @override
  String get rallyTitleBills => 'RAČUNI';

  @override
  String get rallyTitleBudgets => 'PRORAČUNI';

  @override
  String get rallyTitleSettings => 'POSTAVKE';

  @override
  String get rallyLoginLoginToRally => 'Prijavite se na Rally';

  @override
  String get rallyLoginNoAccount => 'Nemate račun?';

  @override
  String get rallyLoginSignUp => 'REGISTRACIJA';

  @override
  String get rallyLoginUsername => 'Korisničko ime';

  @override
  String get rallyLoginPassword => 'Zaporka';

  @override
  String get rallyLoginLabelLogin => 'Prijava';

  @override
  String get rallyLoginRememberMe => 'Zapamti me';

  @override
  String get rallyLoginButtonLogin => 'PRIJAVA';

  @override
  String rallyAlertsMessageHeadsUpShopping(Object percent) {
    return 'Upozorenje! Iskoristili ste ${percent} proračuna za kupnju ovaj mjesec.';
  }

  @override
  String rallyAlertsMessageSpentOnRestaurants(Object amount) {
    return 'Ovaj ste mjesec potrošili ${amount} u restoranima';
  }

  @override
  String rallyAlertsMessageATMFees(Object amount) {
    return 'Ovaj ste mjesec potrošili ${amount} za naknade za bankomate';
  }

  @override
  String rallyAlertsMessageCheckingAccount(Object percent) {
    return 'Bravo! Na tekućem računu imate ${percent} više nego prošli mjesec.';
  }

  @override
  String rallyAlertsMessageUnassignedTransactions(int count) {
    return intl.Intl.pluralLogic(
      count,
      locale: localeName,
      one:
          'Možda možete dobiti veći povrat poreza! Dodijelite kategorije jednoj nedodijeljenoj transakciji.',
      few:
          'Možda možete dobiti veći povrat poreza! Dodijelite kategorije za ${count} nedodijeljene transakcije.',
      other:
          'Možda možete dobiti veći povrat poreza! Dodijelite kategorije za ${count} nedodijeljenih transakcija.',
    );
  }

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

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

  @override
  String get rallySeeAllBudgets => 'Prikaži sve proračune';

  @override
  String rallyAccountAmount(
      Object accountName, Object accountNumber, Object amount) {
    return '${accountName} račun ${accountNumber} s iznosom od ${amount}.';
  }

  @override
  String rallyBillAmount(Object billName, Object date, Object amount) {
    return 'Račun ${billName} na iznos ${amount} dospijeva ${date}.';
  }

  @override
  String rallyBudgetAmount(Object budgetName, Object amountUsed,
      Object amountTotal, Object amountLeft) {
    return '${budgetName} proračun, iskorišteno: ${amountUsed} od ${amountTotal}, preostalo: ${amountLeft}';
  }

  @override
  String get craneDescription => 'Prilagođena aplikacija za putovanja';

  @override
  String get homeCategoryReference => 'STILOVI I DRUGO';

  @override
  String get demoInvalidURL => 'Prikazivanje URL-a nije uspjelo:';

  @override
  String get demoOptionsTooltip => 'Opcije';

  @override
  String get demoInfoTooltip => 'Informacije';

  @override
  String get demoCodeTooltip => 'Kôd demonstracije';

  @override
  String get demoDocumentationTooltip => 'Dokumentacija API-ja';

  @override
  String get demoFullscreenTooltip => 'Cijeli zaslon';

  @override
  String get demoCodeViewerCopyAll => 'KOPIRAJ SVE';

  @override
  String get demoCodeViewerCopiedToClipboardMessage =>
      'Kopirano u međuspremnik.';

  @override
  String demoCodeViewerFailedToCopyToClipboardMessage(Object error) {
    return 'Kopiranje u međuspremnik nije uspjelo: ${error}';
  }

  @override
  String get demoOptionsFeatureTitle => 'Opcije prikaza';

  @override
  String get demoOptionsFeatureDescription =>
      'Dodirnite ovdje da biste vidjeli dostupne opcije za ovaj demo.';

  @override
  String get settingsTitle => 'Postavke';

  @override
  String get settingsButtonLabel => 'Postavke';

  @override
  String get settingsButtonCloseLabel => 'Zatvori postavke';

  @override
  String get settingsSystemDefault => 'Sustav';

  @override
  String get settingsTextScaling => 'Skaliranje teksta';

  @override
  String get settingsTextScalingSmall => 'Mali';

  @override
  String get settingsTextScalingNormal => 'Uobičajeni';

  @override
  String get settingsTextScalingLarge => 'Veliki';

  @override
  String get settingsTextScalingHuge => 'Ogroman';

  @override
  String get settingsTextDirection => 'Smjer teksta';

  @override
  String get settingsTextDirectionLocaleBased =>
      'Na temelju oznake zemlje/jezika';

  @override
  String get settingsTextDirectionLTR => 'Slijeva udesno';

  @override
  String get settingsTextDirectionRTL => 'Zdesna ulijevo';

  @override
  String get settingsLocale => 'Oznaka zemlje/jezika';

  @override
  String get settingsPlatformMechanics => 'Mehanika platforme';

  @override
  String get settingsTheme => 'Tema';

  @override
  String get settingsDarkTheme => 'Tamno';

  @override
  String get settingsLightTheme => 'Svijetlo';

  @override
  String get settingsSlowMotion => 'Usporena snimka';

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

  @override
  String get settingsFeedback => 'Pošaljite komentare';

  @override
  String get settingsAttribution => 'Dizajnirala agencija TOASTER iz Londona';

  @override
  String get demoBottomAppBarTitle => 'Donja traka aplikacije';

  @override
  String get demoBottomAppBarSubtitle =>
      'Prikazuje ladicu za navigaciju i radnje pri dnu';

  @override
  String get demoBottomAppBarDescription =>
      'Donja traka aplikacije omogućuje pristup donjoj ladici za navigaciju i najviše četirima radnjama, uključujući plutajući gumb za radnju.';

  @override
  String get bottomAppBarNotch => 'Urez';

  @override
  String get bottomAppBarPosition => 'Položaj plutajućeg gumba za radnju';

  @override
  String get bottomAppBarPositionDockedEnd => 'Usidren – na kraju';

  @override
  String get bottomAppBarPositionDockedCenter => 'Usidren – u sredini';

  @override
  String get bottomAppBarPositionFloatingEnd => 'Plutajući – na kraju';

  @override
  String get bottomAppBarPositionFloatingCenter => 'Plutajući – u sredini';

  @override
  String get demoBannerTitle => 'Natpis';

  @override
  String get demoBannerSubtitle => 'Prikazivanje natpisa na popisu';

  @override
  String get demoBannerDescription =>
      'Natpis prikazuje važnu, jezgrovitu poruku i navodi radnje koje korisnici trebaju izvršiti (mogu i odbaciti natpis). Odbacivanje nije moguće bez korisničke radnje.';

  @override
  String get demoBottomNavigationTitle => 'Donja navigacija';

  @override
  String get demoBottomNavigationSubtitle =>
      'Donja navigacija koja se postupno prikazuje i nestaje';

  @override
  String get demoBottomNavigationPersistentLabels => 'Fiksne oznake';

  @override
  String get demoBottomNavigationSelectedLabel => 'Odabrana oznaka';

  @override
  String get demoBottomNavigationDescription =>
      'Donja navigacijska traka prikazuje tri do pet odredišta pri dnu zaslona. Svako odredište predstavlja ikona i tekstna oznaka koja nije obavezna. Kad korisnik dodirne ikonu na donjoj navigacijskoj traci, otvara se odredište navigacije na najvišoj razini povezano s tom ikonom.';

  @override
  String get demoButtonTitle => 'Gumbi';

  @override
  String get demoButtonSubtitle => 'Ravni, izdignuti, ocrtani i ostali';

  @override
  String get demoFlatButtonTitle => 'Ravni gumb';

  @override
  String get demoFlatButtonDescription =>
      'Ravni gumb prikazuje mrlju boje prilikom pritiska, ali se ne podiže. Ravne gumbe koristite na alatnim trakama, u dijalozima i ugrađene u ispunu';

  @override
  String get demoRaisedButtonTitle => 'Izdignuti gumb';

  @override
  String get demoRaisedButtonDescription =>
      'Izdignuti gumbi dodaju dimenziju većini ravnih rasporeda. Naglašavaju funkcije na prostorima koji su prostrani ili imaju mnogo sadržaja.';

  @override
  String get demoOutlineButtonTitle => 'Ocrtani gumb';

  @override
  String get demoOutlineButtonDescription =>
      'Ocrtani gumbi postaju neprozirni i izdižu se kad se pritisnu. Obično se uparuju s izdignutim gumbima da bi naznačili alternativnu, sekundarnu radnju.';

  @override
  String get demoToggleButtonTitle => 'Prekidači';

  @override
  String get demoToggleButtonDescription =>
      'Prekidači se mogu upotrebljavati za grupiranje povezanih opcija. Da bi se naglasile grupe povezanih prekidača, grupa bi trebala dijeliti zajednički spremnik';

  @override
  String get demoFloatingButtonTitle => 'Plutajući gumb za radnju';

  @override
  String get demoFloatingButtonDescription =>
      'Plutajući gumb za radnju okrugla je ikona gumba koja lebdi iznad sadržaja u svrhu promocije primarne radnje u aplikaciji.';

  @override
  String get demoCardTitle => 'Kartice';

  @override
  String get demoCardSubtitle => 'Osnovne kartice sa zaobljenim uglovima';

  @override
  String get demoChipTitle => 'Čipovi';

  @override
  String get demoCardDescription =>
      'Kartica je list materijala na kojem se pružaju neke povezane informacije, na primjer album, geografska lokacija, jelo, podaci za kontakt itd.';

  @override
  String get demoChipSubtitle =>
      'Kompaktni elementi koji predstavljaju unos, atribut ili radnju';

  @override
  String get demoActionChipTitle => 'Čip radnji';

  @override
  String get demoActionChipDescription =>
      'Čipovi radnje skup su opcija koji pokreću radnju povezanu s primarnim sadržajem. Čipovi radnje trebali bi se prikazivati dinamički i kontekstualno na korisničkom sučelju.';

  @override
  String get demoChoiceChipTitle => 'Čip odabira';

  @override
  String get demoChoiceChipDescription =>
      'Čipovi odabira predstavljaju jedan odabir iz skupa. Čipovi odabira sadrže povezani opisni tekst ili kategorije.';

  @override
  String get demoFilterChipTitle => 'Element filtriranja';

  @override
  String get demoFilterChipDescription =>
      'Elementi filtriranja koriste oznake ili opisne riječi kao način filtriranja sadržaja.';

  @override
  String get demoInputChipTitle => 'Čip unosa';

  @override
  String get demoInputChipDescription =>
      'Čipovi unosa predstavljaju kompleksne informacije, na primjer entitete (osobe, mjesta ili predmete) ili tekst razgovora, u kompaktnom obliku.';

  @override
  String get demoDataTableTitle => 'Podatkovne tablice';

  @override
  String get demoDataTableSubtitle => 'Redci i stupci informacija';

  @override
  String get demoDataTableDescription =>
      'Podatkovne tablice prikazuju informacije u rešetki redaka i stupaca. Informacije su organizirane tako da ih je lako pregledavati kako bi korisnici mogli tražiti uzorke i uvide.';

  @override
  String get dataTableHeader => 'Prehrana';

  @override
  String get dataTableColumnDessert => 'Desert (1 porcija)';

  @override
  String get dataTableColumnCalories => 'Kalorije';

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

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

  @override
  String get dataTableColumnProtein => 'Bjelančevine (g)';

  @override
  String get dataTableColumnSodium => 'Natrij (mg)';

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

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

  @override
  String get dataTableRowFrozenYogurt => 'Zamrznuti jogurt';

  @override
  String get dataTableRowIceCreamSandwich => 'Sladoledni sendvič';

  @override
  String get dataTableRowEclair => 'Ekler';

  @override
  String get dataTableRowCupcake => 'Cupcake';

  @override
  String get dataTableRowGingerbread => 'Paprenjak';

  @override
  String get dataTableRowJellyBean => 'Žele bomboni';

  @override
  String get dataTableRowLollipop => 'Lizalica';

  @override
  String get dataTableRowHoneycomb => 'Saće';

  @override
  String get dataTableRowDonut => 'Krafna';

  @override
  String get dataTableRowApplePie => 'Pita od jabuka';

  @override
  String dataTableRowWithSugar(Object value) {
    return '${value} sa šećerom';
  }

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

  @override
  String get demoDialogTitle => 'Dijalozi';

  @override
  String get demoDialogSubtitle =>
      'Jednostavni, upozorenje i na cijelom zaslonu';

  @override
  String get demoAlertDialogTitle => 'Upozorenje';

  @override
  String get demoAlertDialogDescription =>
      'Dijalog upozorenja informira korisnika o situacijama koje je potrebno potvrditi. Dijalog upozorenja ima naslov i popis radnji, no te stavke nisu obavezne.';

  @override
  String get demoAlertTitleDialogTitle => 'Upozorenje s naslovom';

  @override
  String get demoSimpleDialogTitle => 'Jednostavni';

  @override
  String get demoSimpleDialogDescription =>
      'Jednostavni dijalog nudi korisnicima odabir između nekoliko opcija. Jednostavni dijalog ima naslov koji nije obavezan i prikazuje se iznad opcija odabira.';

  @override
  String get demoGridListsTitle => 'Popisi u rešetki';

  @override
  String get demoGridListsSubtitle => 'Izgled redaka i stupaca';

  @override
  String get demoGridListsDescription =>
      'Popisi u rešetki najprikladniji su za predstavljanje homogenih podataka, uglavnom slika. Svaka stavka na popisu u rešetki naziva se pločica.';

  @override
  String get demoGridListsImageOnlyTitle => 'Samo slika';

  @override
  String get demoGridListsHeaderTitle => 'Sa zaglavljem';

  @override
  String get demoGridListsFooterTitle => 'S podnožjem';

  @override
  String get demoSlidersTitle => 'Klizači';

  @override
  String get demoSlidersSubtitle => 'Widgeti za odabir vrijednosti klizanjem';

  @override
  String get demoSlidersDescription =>
      'Klizači odražavaju raspon vrijednosti duž trake na kojoj korisnici mogu odabrati pojedinačnu vrijednost. Idealni su za podešavanje postavki kao što su glasnoća, svjetlina ili primjena filtara za slike.';

  @override
  String get demoRangeSlidersTitle => 'Klizači raspona';

  @override
  String get demoRangeSlidersDescription =>
      'Klizači odražavaju raspon vrijednost duž trake. Mogu imati ikone na oba kraja trake koji odražavaju raspon vrijednosti. Idealni su za podešavanje postavki kao što su glasnoća, svjetlina ili primjena filtara za slike.';

  @override
  String get demoCustomSlidersTitle => 'Prilagođeni klizači';

  @override
  String get demoCustomSlidersDescription =>
      'Klizači odražavaju raspon vrijednosti duž trake na kojoj korisnici mogu odabrati pojedinačnu vrijednost ili raspon vrijednosti. Klizači mogu biti tematski ili prilagođeni.';

  @override
  String get demoSlidersContinuousWithEditableNumericalValue =>
      'Kontinuirani s numeričkom vrijednošću koju je moguće urediti';

  @override
  String get demoSlidersDiscrete => 'Diskretni';

  @override
  String get demoSlidersDiscreteSliderWithCustomTheme =>
      'Diskretni klizač s prilagođenom temom';

  @override
  String get demoSlidersContinuousRangeSliderWithCustomTheme =>
      'Kontinuirani klizač raspona s prilagođenom temom';

  @override
  String get demoSlidersContinuous => 'Kontinuirani';

  @override
  String get demoSlidersEditableNumericalValue =>
      'Numerička vrijednost s mogućnošću uređivanja';

  @override
  String get demoMenuTitle => 'Izbornik';

  @override
  String get demoContextMenuTitle => 'Kontekstni izbornik';

  @override
  String get demoSectionedMenuTitle => 'Izbornik po odjeljcima';

  @override
  String get demoSimpleMenuTitle => 'Jednostavan izbornik';

  @override
  String get demoChecklistMenuTitle => 'Izbornik s kontrolnim popisom';

  @override
  String get demoMenuSubtitle => 'Gumbi izbornika i jednostavni izbornici';

  @override
  String get demoMenuDescription =>
      'Izbornik prikazuje popis izbora na privremenoj površini. Pojavljuju se prilikom korisnikove interakcije s gumbom, radnjom i ostalim kontrolama.';

  @override
  String get demoMenuItemValueOne => 'Prva stavka izbornika';

  @override
  String get demoMenuItemValueTwo => 'Druga stavka izbornika';

  @override
  String get demoMenuItemValueThree => 'Treća stavka izbornika';

  @override
  String get demoMenuOne => 'Jedan';

  @override
  String get demoMenuTwo => 'Dva';

  @override
  String get demoMenuThree => 'Tri';

  @override
  String get demoMenuFour => 'Četiri';

  @override
  String get demoMenuAnItemWithAContextMenuButton =>
      'Stavka s kontekstnim izbornikom';

  @override
  String get demoMenuContextMenuItemOne => 'Prva stavka kontekstnog izbornika';

  @override
  String get demoMenuADisabledMenuItem => 'Onemogućena stavka izbornika';

  @override
  String get demoMenuContextMenuItemThree =>
      'Treća stavka kontekstnog izbornika';

  @override
  String get demoMenuAnItemWithASectionedMenu =>
      'Stavka s izbornikom po odjeljcima';

  @override
  String get demoMenuPreview => 'Pregled';

  @override
  String get demoMenuShare => 'Udio';

  @override
  String get demoMenuGetLink => 'Dohvati vezu';

  @override
  String get demoMenuRemove => 'Ukloni';

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

  @override
  String demoMenuChecked(Object value) {
    return 'Označeno: ${value}';
  }

  @override
  String get demoMenuAnItemWithASimpleMenu =>
      'Stavka s jednostavnim izbornikom';

  @override
  String get demoMenuAnItemWithAChecklistMenu =>
      'Stavka s izbornikom s kontrolnim popisom';

  @override
  String get demoFullscreenDialogTitle => 'Na cijelom zaslonu';

  @override
  String get demoFullscreenDialogDescription =>
      'Svojstvo fullscreenDialog određuje je li dolazna stranica modalni dijalog na cijelom zaslonu';

  @override
  String get demoCupertinoActivityIndicatorTitle => 'Pokazivač aktivnosti';

  @override
  String get demoCupertinoActivityIndicatorSubtitle =>
      'Pokazivači aktivnosti u iOS-ovom stilu';

  @override
  String get demoCupertinoActivityIndicatorDescription =>
      'Pokazivač aktivnosti u iOS-ovom stilu koji se okreće u smjeru kazaljke na satu.';

  @override
  String get demoCupertinoButtonsTitle => 'Gumbi';

  @override
  String get demoCupertinoButtonsSubtitle => 'Gumbi u iOS-ovom stilu';

  @override
  String get demoCupertinoButtonsDescription =>
      'Gumb u iOS-ovom stilu. Na njemu su tekst i/ili ikona koji se postupno prikazuju ili nestaju na dodir. Može imati pozadinu, no to nije obavezno.';

  @override
  String get demoCupertinoAlertsTitle => 'Upozorenja';

  @override
  String get demoCupertinoAlertsSubtitle =>
      'Dijalozi upozorenja u iOS-ovom stilu';

  @override
  String get demoCupertinoAlertTitle => 'Upozorenje';

  @override
  String get demoCupertinoAlertDescription =>
      'Dijalog upozorenja informira korisnika o situacijama koje je potrebno potvrditi. Dijalog upozorenja ima naslov, sadržaj i popis radnji, no te stavke nisu obavezne. Naslov se prikazuje iznad sadržaja, a radnje ispod sadržaja.';

  @override
  String get demoCupertinoAlertWithTitleTitle => 'Upozorenje s naslovom';

  @override
  String get demoCupertinoAlertButtonsTitle => 'Upozorenje s gumbima';

  @override
  String get demoCupertinoAlertButtonsOnlyTitle => 'Samo gumbi upozorenja';

  @override
  String get demoCupertinoActionSheetTitle => 'Tablica radnji';

  @override
  String get demoCupertinoActionSheetDescription =>
      'Tablica radnji poseban je stil upozorenja koje korisniku nudi barem dvije opcije na izbor u vezi s trenutačnim kontekstom. Tablica radnji može imati naslov, dodatnu poruku i popis radnji.';

  @override
  String get demoCupertinoNavigationBarTitle => 'Navigacijska traka';

  @override
  String get demoCupertinoNavigationBarSubtitle =>
      'Navigacijska traka u iOS-ovom stilu';

  @override
  String get demoCupertinoNavigationBarDescription =>
      'Navigacijska traka u iOS-ovom stilu. Navigacijska traka jest alatna traka koja se sastoji barem od naslova stranice u središtu alatne trake.';

  @override
  String get demoCupertinoPickerTitle => 'Alati za odabir';

  @override
  String get demoCupertinoPickerSubtitle =>
      'Alati za odabir datuma i vremena u iOS-ovom stilu';

  @override
  String get demoCupertinoPickerDescription =>
      'Widget alata za odabir u iOS-ovom stilu koji se može koristiti za odabir datuma, vremena ili i datuma i vremena.';

  @override
  String get demoCupertinoPickerTimer => 'Odbrojavanje';

  @override
  String get demoCupertinoPickerDate => 'Datum';

  @override
  String get demoCupertinoPickerTime => 'Vrijeme';

  @override
  String get demoCupertinoPickerDateTime => 'Datum i vrijeme';

  @override
  String get demoCupertinoPullToRefreshTitle => 'Povucite za osvježavanje';

  @override
  String get demoCupertinoPullToRefreshSubtitle =>
      'Kontrola povuci za osvježavanje u iOS-ovom stilu';

  @override
  String get demoCupertinoPullToRefreshDescription =>
      'Widget na kojem je implementirana kontrola povuci za osvježavanje sadržaja u iOS-ovom stilu.';

  @override
  String get demoCupertinoSegmentedControlTitle => 'Segmentirano upravljanje';

  @override
  String get demoCupertinoSegmentedControlSubtitle =>
      'Segmentirano upravljanje u stilu iOS-a';

  @override
  String get demoCupertinoSegmentedControlDescription =>
      'Koristi se za odabir između nekoliko opcija koje se međusobno isključuju. Kad se u segmentiranom upravljanju odabere jedna opcija, poništava se odabir ostalih opcija.';

  @override
  String get demoCupertinoSliderTitle => 'Klizač';

  @override
  String get demoCupertinoSliderSubtitle => 'Klizač u iOS-ovom stilu';

  @override
  String get demoCupertinoSliderDescription =>
      'Klizač se može koristiti za odabir kontinuiranog ili diskretnog skupa vrijednosti.';

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

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

  @override
  String get demoCupertinoSwitchSubtitle => 'Prekidač u iOS-ovom stilu';

  @override
  String get demoCupertinoSwitchDescription =>
      'Prekidač se koristi za uključivanje/isključivanje stanja jedne postavke.';

  @override
  String get demoCupertinoTabBarTitle => 'Traka kartica';

  @override
  String get demoCupertinoTabBarSubtitle =>
      'Donja traka kartica u iOS-ovom stilu';

  @override
  String get demoCupertinoTabBarDescription =>
      'Donja navigacijska traka kartica u iOS-ovom stilu. Prikazuje više kartica dok je jedna kartica aktivna (prema zadanim postavkama to je prva kartica).';

  @override
  String get cupertinoTabBarHomeTab => 'Početna';

  @override
  String get cupertinoTabBarChatTab => 'Chat';

  @override
  String get cupertinoTabBarProfileTab => 'Profil';

  @override
  String get demoCupertinoTextFieldTitle => 'Tekstna polja';

  @override
  String get demoCupertinoTextFieldSubtitle => 'Tekstna polja u iOS-ovom stilu';

  @override
  String get demoCupertinoTextFieldDescription =>
      'Tekstno polje omogućuje korisniku da unese tekst, bilo pomoću hardverske ili pomoću tipkovnice na zaslonu.';

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

  @override
  String get demoColorsSubtitle => 'Sve unaprijed definirane boje';

  @override
  String get demoColorsDescription =>
      'Boje i konstante uzoraka boja koje predstavljaju paletu boja materijalnog dizajna.';

  @override
  String get demoTypographyTitle => 'Tipografija';

  @override
  String get demoTypographySubtitle =>
      'Svi unaprijed definirani stilovi teksta';

  @override
  String get demoTypographyDescription =>
      'Definicije raznih tipografskih stilova u materijalnom dizajnu.';

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

  @override
  String get demo2dTransformationsSubtitle => 'Pomicanje, zumiranje i rotacija';

  @override
  String get demo2dTransformationsDescription =>
      'Dodirnite da biste uređivali pločice i koristite pokrete da biste premještali scenu. Povucite da biste pomicali, spojite prste da biste zumirali i rotirajte pomoću dva prsta. Pritisnite gumb za poništavanje da biste se vratili na početno usmjerenje.';

  @override
  String get demo2dTransformationsResetTooltip => 'Poništavanje transformacija';

  @override
  String get demo2dTransformationsEditTooltip => 'Uređivanje pločice';

  @override
  String get buttonText => 'GUMB';

  @override
  String get demoBottomSheetTitle => 'Donja tablica';

  @override
  String get demoBottomSheetSubtitle => 'Fiksne i modalne donje tablice';

  @override
  String get demoBottomSheetPersistentTitle => 'Fiksna donja tablica';

  @override
  String get demoBottomSheetPersistentDescription =>
      'Fiksna donja tablica prikazuje informacije koje nadopunjuju primarni sadržaj aplikacije. Ostaje vidljiva čak i tijekom korisnikove interakcije s drugim dijelovima aplikacije.';

  @override
  String get demoBottomSheetModalTitle => 'Modalna donja tablica';

  @override
  String get demoBottomSheetModalDescription =>
      'Modalna donja tablica alternativa je izborniku ili dijalogu i onemogućuje korisnicima interakciju s ostatkom aplikacije.';

  @override
  String get demoBottomSheetAddLabel => 'Dodavanje';

  @override
  String get demoBottomSheetButtonText => 'PRIKAŽI DONJU TABLICU';

  @override
  String get demoBottomSheetHeader => 'Zaglavlje';

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

  @override
  String get demoListsTitle => 'Popisi';

  @override
  String get demoListsSubtitle => 'Pomicanje po izgledu popisa';

  @override
  String get demoListsDescription =>
      'Jedan redak fiksne visine koji uglavnom sadrži tekst te ikonu na početku ili na kraju.';

  @override
  String get demoOneLineListsTitle => 'Jedan redak';

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

  @override
  String get demoListsSecondary => 'Dodatni tekst';

  @override
  String get demoProgressIndicatorTitle => 'Pokazivači napretka';

  @override
  String get demoProgressIndicatorSubtitle => 'Linearni, kružni, neodređeni';

  @override
  String get demoCircularProgressIndicatorTitle => 'Kružni pokazivač napretka';

  @override
  String get demoCircularProgressIndicatorDescription =>
      'Kružni pokazivač napretka u materijalnom dizajnu koji okretanjem pokazuje da je aplikacija zauzeta.';

  @override
  String get demoLinearProgressIndicatorTitle => 'Linearni pokazivač napretka';

  @override
  String get demoLinearProgressIndicatorDescription =>
      'Linearni pokazivač napretka u materijalnom dizajnu poznat i kao traka napretka.';

  @override
  String get demoPickersTitle => 'Alati za odabir';

  @override
  String get demoPickersSubtitle => 'Odabir datuma i vremena';

  @override
  String get demoDatePickerTitle => 'Alat za odabir datuma';

  @override
  String get demoDatePickerDescription =>
      'Prikazuje dijalog koji sadrži alat za odabir datuma u materijalnom dizajnu.';

  @override
  String get demoTimePickerTitle => 'Alat za odabir vremena';

  @override
  String get demoTimePickerDescription =>
      'Prikazuje dijalog koji sadrži alat za odabir vremena u materijalnom dizajnu.';

  @override
  String get demoPickersShowPicker => 'PRIKAŽI ALAT ZA ODABIR';

  @override
  String get demoTabsTitle => 'Kartice';

  @override
  String get demoTabsScrollingTitle => 'Pomicanje';

  @override
  String get demoTabsNonScrollingTitle => 'Bez pomicanja';

  @override
  String get demoTabsSubtitle =>
      'Kartice s prikazima koji se mogu pomicati neovisno';

  @override
  String get demoTabsDescription =>
      'Kartice organiziraju sadržaj s različitih zaslona, iz različitih skupova podataka i drugih interakcija.';

  @override
  String get demoSnackbarsTitle => 'Kratke interaktivne obavijesti';

  @override
  String get demoSnackbarsSubtitle =>
      'Kratke interaktivne obavijesti prikazuju poruke na dnu zaslona';

  @override
  String get demoSnackbarsDescription =>
      'Kratke interaktivne obavijesti obavještavaju korisnike o postupku koji je aplikacija izvela ili će izvesti. One se pojavljuju privremeno prema dnu zaslona. Ne bi trebale ometati korisnički doživljaj i nije potreban korisnički unos da bi nestale.';

  @override
  String get demoSnackbarsButtonLabel =>
      'PRIKAŽITE KRATKU INTERAKTIVNU OBAVIJEST';

  @override
  String get demoSnackbarsText => 'Ovo je kratka interaktivna obavijest.';

  @override
  String get demoSnackbarsActionButtonLabel => 'RADNJA';

  @override
  String get demoSnackbarsAction =>
      'Pritisnuli ste radnju za kratku interaktivnu obavijest.';

  @override
  String get demoSelectionControlsTitle => 'Kontrole odabira';

  @override
  String get demoSelectionControlsSubtitle =>
      'Potvrdni okviri, izborni gumbi i prekidači';

  @override
  String get demoSelectionControlsCheckboxTitle => 'Potvrdni okvir';

  @override
  String get demoSelectionControlsCheckboxDescription =>
      'Potvrdni okviri omogućavaju korisniku odabir više opcija iz skupa. Vrijednost normalnog potvrdnog okvira točna je ili netočna, a vrijednost potvrdnog okvira s tri stanja može biti i nula.';

  @override
  String get demoSelectionControlsRadioTitle => 'Radio';

  @override
  String get demoSelectionControlsRadioDescription =>
      'Izborni gumbi omogućavaju korisniku odabir jedne opcije iz skupa. Upotrebljavajte izborne gumbe da biste omogućili ekskluzivni odabir ako mislite da korisnik treba vidjeti sve dostupne opcije istodobno.';

  @override
  String get demoSelectionControlsSwitchTitle => 'Prekidač';

  @override
  String get demoSelectionControlsSwitchDescription =>
      'Prekidači za uključivanje/isključivanje mijenjaju stanje jedne opcije postavki. Opcija kojom upravlja prekidač, kao i njezino stanje, trebali bi biti jasni iz odgovarajuće ugrađene oznake.';

  @override
  String get demoBottomTextFieldsTitle => 'Tekstualna polja';

  @override
  String get demoTextFieldTitle => 'Tekstualna polja';

  @override
  String get demoTextFieldSubtitle =>
      'Jedan redak teksta i brojeva koji se mogu uređivati';

  @override
  String get demoTextFieldDescription =>
      'Tekstualna polja omogućuju korisnicima da unesu tekst u korisničko sučelje. Obično su u obliku obrazaca i dijaloga.';

  @override
  String get demoTextFieldShowPasswordLabel => 'Prikaži zaporku';

  @override
  String get demoTextFieldHidePasswordLabel => 'Sakrij zaporku';

  @override
  String get demoTextFieldFormErrors =>
      'Prije slanja ispravite pogreške označene crvenom bojom.';

  @override
  String get demoTextFieldNameRequired => 'Ime je obavezno.';

  @override
  String get demoTextFieldOnlyAlphabeticalChars =>
      'Unesite samo slova abecede.';

  @override
  String get demoTextFieldEnterUSPhoneNumber =>
      '(###) ###-#### – unesite telefonski broj u SAD-u.';

  @override
  String get demoTextFieldEnterPassword => 'Unesite zaporku.';

  @override
  String get demoTextFieldPasswordsDoNotMatch => 'Zaporke se ne podudaraju';

  @override
  String get demoTextFieldWhatDoPeopleCallYou => 'Kako vas zovu?';

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

  @override
  String get demoTextFieldWhereCanWeReachYou =>
      'Na kojem vas broju možemo dobiti?';

  @override
  String get demoTextFieldPhoneNumber => 'Telefonski broj*';

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

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

  @override
  String get demoTextFieldTellUsAboutYourself =>
      'Recite nam nešto o sebi (na primjer napišite što radite ili koji su vam hobiji)';

  @override
  String get demoTextFieldKeepItShort =>
      'Neka bude kratko, ovo je samo demonstracija.';

  @override
  String get demoTextFieldLifeStory => 'Biografija';

  @override
  String get demoTextFieldSalary => 'Plaća';

  @override
  String get demoTextFieldUSD => 'USD';

  @override
  String get demoTextFieldNoMoreThan =>
      'Ne možete unijeti više od osam znakova.';

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

  @override
  String get demoTextFieldRetypePassword => 'Ponovo unesite zaporku*';

  @override
  String get demoTextFieldSubmit => 'POŠALJI';

  @override
  String demoTextFieldNameHasPhoneNumber(Object name, Object phoneNumber) {
    return '${name} ima telefonski broj ${phoneNumber}';
  }

  @override
  String get demoTextFieldRequiredField => '* označava obavezno polje';

  @override
  String get demoTooltipTitle => 'Opisi';

  @override
  String get demoTooltipSubtitle =>
      'Kratka poruka prikazana kod dugog pritiska ili zadržavanja iznad elementa';

  @override
  String get demoTooltipDescription =>
      'Opisi pružaju tekstne oznake koje pomažu objasniti funkciju gumba ili druge radnje korisničkog sučelja. Opisi prikazuju informativni tekst kada se korisnik zadrži iznad elementa, fokusira se na njega ili ga dugo pritisne.';

  @override
  String get demoTooltipInstructions =>
      'Koristite dugi pritisak ili se zadržite iznad elementa za prikazivanje opisa.';

  @override
  String get bottomNavigationCommentsTab => 'Komentari';

  @override
  String get bottomNavigationCalendarTab => 'Kalendar';

  @override
  String get bottomNavigationAccountTab => 'Račun';

  @override
  String get bottomNavigationAlarmTab => 'Alarm';

  @override
  String get bottomNavigationCameraTab => 'Fotoaparat';

  @override
  String bottomNavigationContentPlaceholder(Object title) {
    return 'Rezervirano mjesto za karticu ${title}';
  }

  @override
  String get buttonTextCreate => 'Izradite';

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

  @override
  String get chipTurnOnLights => 'Uključivanje svjetla';

  @override
  String get chipSmall => 'Malo';

  @override
  String get chipMedium => 'Srednje';

  @override
  String get chipLarge => 'Veliko';

  @override
  String get chipElevator => 'Dizalo';

  @override
  String get chipWasher => 'Perilica';

  @override
  String get chipFireplace => 'Kamin';

  @override
  String get chipBiking => 'Vožnja biciklom';

  @override
  String get dialogDiscardTitle => 'Želite li odbaciti skicu?';

  @override
  String get dialogLocationTitle =>
      'Želite li upotrebljavati Googleovu uslugu lokacije?';

  @override
  String get dialogLocationDescription =>
      'Dopustite Googleu da pomogne aplikacijama odrediti lokaciju. To znači da će se anonimni podaci o lokaciji slati Googleu, čak i kada se ne izvodi nijedna aplikacija.';

  @override
  String get dialogCancel => 'ODUSTANI';

  @override
  String get dialogDiscard => 'ODBACI';

  @override
  String get dialogDisagree => 'NE SLAŽEM SE';

  @override
  String get dialogAgree => 'PRIHVAĆAM';

  @override
  String get dialogSetBackup => 'Postavljanje računa za sigurnosno kopiranje';

  @override
  String get dialogAddAccount => 'Dodavanje računa';

  @override
  String get dialogShow => 'PRIKAŽI DIJALOG';

  @override
  String get dialogFullscreenTitle => 'Dijalog na cijelom zaslonu';

  @override
  String get dialogFullscreenSave => 'SPREMI';

  @override
  String get dialogFullscreenDescription =>
      'Demonstracija dijaloga na cijelom zaslonu';

  @override
  String get cupertinoButton => 'Gumb';

  @override
  String get cupertinoButtonWithBackground => 'S pozadinom';

  @override
  String get cupertinoAlertCancel => 'Odustani';

  @override
  String get cupertinoAlertDiscard => 'Odbaci';

  @override
  String get cupertinoAlertLocationTitle =>
      'Želite li dopustiti da aplikacija \"Karte pristupa vašoj lokaciji dok je upotrebljavate?';

  @override
  String get cupertinoAlertLocationDescription =>
      'Vaša trenutačna lokacija prikazivat će se na karti i koristiti za upute, rezultate pretraživanja u blizini i procjenu vremena putovanja.';

  @override
  String get cupertinoAlertAllow => 'Dopusti';

  @override
  String get cupertinoAlertDontAllow => 'Ne dopusti';

  @override
  String get cupertinoAlertFavoriteDessert => 'Odaberite omiljeni desert';

  @override
  String get cupertinoAlertDessertDescription =>
      'Odaberite svoju omiljenu vrstu deserta na popisu u nastavku. Vaš će se odabir koristiti za prilagodbu predloženog popisa zalogajnica u vašem području.';

  @override
  String get cupertinoAlertCheesecake => 'Torta od sira';

  @override
  String get cupertinoAlertTiramisu => 'Tiramisu';

  @override
  String get cupertinoAlertApplePie => 'Pita od jabuka';

  @override
  String get cupertinoAlertChocolateBrownie => 'Čokoladni kolač';

  @override
  String get cupertinoShowAlert => 'Prikaži upozorenje';

  @override
  String get colorsRed => 'CRVENA';

  @override
  String get colorsPink => 'RUŽIČASTA';

  @override
  String get colorsPurple => 'LJUBIČASTA';

  @override
  String get colorsDeepPurple => 'TAMNOLJUBIČASTA';

  @override
  String get colorsIndigo => 'MODROLJUBIČASTA';

  @override
  String get colorsBlue => 'PLAVA';

  @override
  String get colorsLightBlue => 'SVIJETLOPLAVA';

  @override
  String get colorsCyan => 'CIJAN';

  @override
  String get colorsTeal => 'TIRKIZNOPLAVA';

  @override
  String get colorsGreen => 'ZELENA';

  @override
  String get colorsLightGreen => 'SVIJETLOZELENA';

  @override
  String get colorsLime => 'ŽUTOZELENA';

  @override
  String get colorsYellow => 'ŽUTA';

  @override
  String get colorsAmber => 'JANTARNA';

  @override
  String get colorsOrange => 'NARANČASTA';

  @override
  String get colorsDeepOrange => 'TAMNONARANČASTA';

  @override
  String get colorsBrown => 'SMEĐA';

  @override
  String get colorsGrey => 'SIVA';

  @override
  String get colorsBlueGrey => 'PLAVOSIVA';

  @override
  String get placeChennai => 'Chennai';

  @override
  String get placeTanjore => 'Tanjore';

  @override
  String get placeChettinad => 'Chettinad';

  @override
  String get placePondicherry => 'Pondicherry';

  @override
  String get placeFlowerMarket => 'Cvjećarnica na tržnici';

  @override
  String get placeBronzeWorks => 'Radionica za izradu bronce';

  @override
  String get placeMarket => 'Tržnica';

  @override
  String get placeThanjavurTemple => 'Hram Thanjavur';

  @override
  String get placeSaltFarm => 'Solana';

  @override
  String get placeScooters => 'Skuteri';

  @override
  String get placeSilkMaker => 'Proizvođači svile';

  @override
  String get placeLunchPrep => 'Priprema ručka';

  @override
  String get placeBeach => 'Plaža';

  @override
  String get placeFisherman => 'Ribar';

  @override
  String get starterAppTitle => 'Aplikacija za pokretanje';

  @override
  String get starterAppDescription =>
      'Responzivni izgled aplikacije za pokretanje';

  @override
  String get starterAppGenericButton => 'GUMB';

  @override
  String get starterAppTooltipAdd => 'Dodavanje';

  @override
  String get starterAppTooltipFavorite => 'Favorit';

  @override
  String get starterAppTooltipShare => 'Dijeljenje';

  @override
  String get starterAppTooltipSearch => 'Pretraživanje';

  @override
  String get starterAppGenericTitle => 'Naslov';

  @override
  String get starterAppGenericSubtitle => 'Titlovi';

  @override
  String get starterAppGenericHeadline => 'Naslov';

  @override
  String get starterAppGenericBody => 'Glavni tekst';

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

  @override
  String get shrineMenuCaption => 'IZBORNIK';

  @override
  String get shrineCategoryNameAll => 'SVE';

  @override
  String get shrineCategoryNameAccessories => 'DODACI';

  @override
  String get shrineCategoryNameClothing => 'ODJEĆA';

  @override
  String get shrineCategoryNameHome => 'DOM';

  @override
  String get shrineLogoutButtonCaption => 'ODJAVA';

  @override
  String get shrineLoginUsernameLabel => 'Korisničko ime';

  @override
  String get shrineLoginPasswordLabel => 'Zaporka';

  @override
  String get shrineCancelButtonCaption => 'ODUSTANI';

  @override
  String get shrineNextButtonCaption => 'SLJEDEĆE';

  @override
  String get shrineCartPageCaption => 'KOŠARICA';

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

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

  @override
  String shrineCartItemCount(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'NEMA STAVKI',
      one: 'JEDNA STAVKA',
      few: '${quantity} STAVKE',
      other: '${quantity} STAVKI',
    );
  }

  @override
  String get shrineCartClearButtonCaption => 'ISPRAZNI KOŠARICU';

  @override
  String get shrineCartTotalCaption => 'UKUPNO';

  @override
  String get shrineCartSubtotalCaption => 'Međuzbroj:';

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

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

  @override
  String get shrineProductVagabondSack => 'Vrećasta torba';

  @override
  String get shrineProductStellaSunglasses => 'Sunčane naočale Stella';

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

  @override
  String get shrineProductGardenStrand => 'Vrtni konop';

  @override
  String get shrineProductStrutEarrings => 'Strut naušnice';

  @override
  String get shrineProductVarsitySocks => 'Čarape s prugama';

  @override
  String get shrineProductWeaveKeyring => 'Pleteni privjesak za ključeve';

  @override
  String get shrineProductGatsbyHat => 'Kačket';

  @override
  String get shrineProductShrugBag =>
      'Torba s kratkom ručkom za nošenje na ramenu';

  @override
  String get shrineProductGiltDeskTrio => 'Trio pozlaćenih stolića';

  @override
  String get shrineProductCopperWireRack => 'Bakrena vješalica';

  @override
  String get shrineProductSootheCeramicSet => 'Keramički set Soothe';

  @override
  String get shrineProductHurrahsTeaSet => 'Čajni set Hurrahs';

  @override
  String get shrineProductBlueStoneMug => 'Plava kamena šalica';

  @override
  String get shrineProductRainwaterTray => 'Posuda za kišnicu';

  @override
  String get shrineProductChambrayNapkins => 'Ubrusi od chambraya';

  @override
  String get shrineProductSucculentPlanters => 'Posude za sukulentne biljke';

  @override
  String get shrineProductQuartetTable => 'Četiri stolića';

  @override
  String get shrineProductKitchenQuattro => 'Četverodijelni kuhinjski set';

  @override
  String get shrineProductClaySweater => 'Džemper u boji gline';

  @override
  String get shrineProductSeaTunic => 'Tunika morskoplave boje';

  @override
  String get shrineProductPlasterTunic => 'Tunika u boji gipsa';

  @override
  String get shrineProductWhitePinstripeShirt => 'Prugasta bijela košulja';

  @override
  String get shrineProductChambrayShirt => 'Košulja od chambraya';

  @override
  String get shrineProductSeabreezeSweater => 'Džemper s nautičkim uzorkom';

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

  @override
  String get shrineProductNavyTrousers => 'Mornarskoplave hlače';

  @override
  String get shrineProductWalterHenleyWhite => 'Walter Henley (bijele boje)';

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

  @override
  String get shrineProductGingerScarf => 'Šal u boji đumbira';

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

  @override
  String get shrineProductClassicWhiteCollar => 'Klasična bijela košulja';

  @override
  String get shrineProductCeriseScallopTee =>
      'Tamnoružičasta majica s valovitim rubom';

  @override
  String get shrineProductShoulderRollsTee => 'Majica s podvrnutim rukavima';

  @override
  String get shrineProductGreySlouchTank => 'Siva majica bez rukava';

  @override
  String get shrineProductSunshirtDress => 'Haljina za zaštitu od sunca';

  @override
  String get shrineProductFineLinesTee => 'Majica s tankim crtama';

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

  @override
  String get shrineTooltipSettings => 'Postavke';

  @override
  String get shrineTooltipOpenMenu => 'Otvorite izbornik';

  @override
  String get shrineTooltipCloseMenu => 'Zatvorite izbornik';

  @override
  String get shrineTooltipCloseCart => 'Zatvorite košaricu';

  @override
  String shrineScreenReaderCart(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'Košarica, nema artikala',
      one: 'Košarica, jedan artikl',
      few: 'Košarica, ${quantity} artikla',
      other: 'Košarica, ${quantity} artikala',
    );
  }

  @override
  String get shrineScreenReaderProductAddToCart => 'Dodavanje u košaricu';

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

  @override
  String get shrineTooltipRemoveItem => 'Uklonite stavku';

  @override
  String get craneFormDiners => 'Zalogajnice';

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

  @override
  String get craneFormTime => 'Odaberite vrijeme';

  @override
  String get craneFormLocation => 'Odaberite lokaciju';

  @override
  String get craneFormTravelers => 'Putnici';

  @override
  String get craneFormOrigin => 'Odaberite polazište';

  @override
  String get craneFormDestination => 'Odaberite odredište';

  @override
  String get craneFormDates => 'Odaberite datume';

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

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

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

  @override
  String get craneFly => 'LET';

  @override
  String get craneSleep => 'SPAVANJE';

  @override
  String get craneEat => 'PREHRANA';

  @override
  String get craneFlySubhead => 'Istražite letove po odredištu';

  @override
  String get craneSleepSubhead => 'Istražite smještajne objekte po odredištu';

  @override
  String get craneEatSubhead => 'Istražite restorane po odredištu';

  @override
  String craneFlyStops(int numberOfStops) {
    return intl.Intl.pluralLogic(
      numberOfStops,
      locale: localeName,
      zero: 'Direktni',
      one: 'Jedna stanica',
      few: '${numberOfStops} stanice',
      other: '${numberOfStops} stanica',
    );
  }

  @override
  String craneSleepProperties(int totalProperties) {
    return intl.Intl.pluralLogic(
      totalProperties,
      locale: localeName,
      zero: 'Nema dostupnih entiteta',
      one: 'Jedan dostupan entitet',
      few: '${totalProperties} dostupna entita',
      other: '${totalProperties} dostupnih entiteta',
    );
  }

  @override
  String craneEatRestaurants(int totalRestaurants) {
    return intl.Intl.pluralLogic(
      totalRestaurants,
      locale: localeName,
      zero: 'Nema restorana',
      one: 'Jedan restoran',
      few: '${totalRestaurants} restorana',
      other: '${totalRestaurants} restorana',
    );
  }

  @override
  String get craneFly0 => 'Aspen, Sjedinjene Američke Države';

  @override
  String get craneFly1 => 'Big Sur, Sjedinjene Američke Države';

  @override
  String get craneFly2 => 'Dolina Khumbu, Nepal';

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

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

  @override
  String get craneFly5 => 'Vitznau, Švicarska';

  @override
  String get craneFly6 => 'Ciudad de Mexico, Meksiko';

  @override
  String get craneFly7 => 'Mount Rushmore, Sjedinjene Američke Države';

  @override
  String get craneFly8 => 'Singapur';

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

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

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

  @override
  String get craneFly12 => 'Napa, Sjedinjene Američke Države';

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

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

  @override
  String get craneSleep1 => 'Aspen, Sjedinjene Američke Države';

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

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

  @override
  String get craneSleep4 => 'Vitznau, Švicarska';

  @override
  String get craneSleep5 => 'Big Sur, Sjedinjene Američke Države';

  @override
  String get craneSleep6 => 'Napa, Sjedinjene Američke Države';

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

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

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

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

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

  @override
  String get craneEat0 => 'Napulj, Italija';

  @override
  String get craneEat1 => 'Dallas, Sjedinjene Američke Države';

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

  @override
  String get craneEat3 => 'Portland, Sjedinjene Američke Države';

  @override
  String get craneEat4 => 'Pariz, Francuska';

  @override
  String get craneEat5 => 'Seoul, Južna Koreja';

  @override
  String get craneEat6 => 'Seattle, Sjedinjene Američke Države';

  @override
  String get craneEat7 => 'Nashville, Sjedinjene Američke Države';

  @override
  String get craneEat8 => 'Atlanta, Sjedinjene Američke Države';

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

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

  @override
  String get craneFly0SemanticLabel =>
      'Planinska kuća u snježnom krajoliku sa zimzelenim drvećem';

  @override
  String get craneFly1SemanticLabel => 'Šator u polju';

  @override
  String get craneFly2SemanticLabel =>
      'Molitvene zastave ispred snježne planine';

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

  @override
  String get craneFly4SemanticLabel => 'Bungalovi iznad vode';

  @override
  String get craneFly5SemanticLabel => 'Hotel na obali jezera ispred planina';

  @override
  String get craneFly6SemanticLabel =>
      'Pogled na Palaču lijepe umjetnosti iz zraka';

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

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

  @override
  String get craneFly9SemanticLabel =>
      'Muškarac se naslanja na antikni plavi automobil';

  @override
  String get craneFly10SemanticLabel =>
      'Minareti džamije Al-Azhar za vrijeme zalaska sunca';

  @override
  String get craneFly11SemanticLabel => 'Cigleni svjetionik na moru';

  @override
  String get craneFly12SemanticLabel => 'Bazen s palmama';

  @override
  String get craneFly13SemanticLabel => 'Bazen uz more s palmama';

  @override
  String get craneSleep0SemanticLabel => 'Bungalovi iznad vode';

  @override
  String get craneSleep1SemanticLabel =>
      'Planinska kuća u snježnom krajoliku sa zimzelenim drvećem';

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

  @override
  String get craneSleep3SemanticLabel =>
      'Muškarac se naslanja na antikni plavi automobil';

  @override
  String get craneSleep4SemanticLabel => 'Hotel na obali jezera ispred planina';

  @override
  String get craneSleep5SemanticLabel => 'Šator u polju';

  @override
  String get craneSleep6SemanticLabel => 'Bazen s palmama';

  @override
  String get craneSleep7SemanticLabel => 'Šareni stanovi na trgu Ribeira';

  @override
  String get craneSleep8SemanticLabel =>
      'Majanske ruševine na litici iznad plaže';

  @override
  String get craneSleep9SemanticLabel => 'Cigleni svjetionik na moru';

  @override
  String get craneSleep10SemanticLabel =>
      'Minareti džamije Al-Azhar za vrijeme zalaska sunca';

  @override
  String get craneSleep11SemanticLabel => 'Neboder Taipei 101';

  @override
  String get craneEat0SemanticLabel => 'Pizza u krušnoj peći';

  @override
  String get craneEat1SemanticLabel =>
      'Prazan bar sa stolicama u stilu zalogajnice';

  @override
  String get craneEat2SemanticLabel => 'Hamburger';

  @override
  String get craneEat3SemanticLabel => 'Korejski taco';

  @override
  String get craneEat4SemanticLabel => 'Čokoladni desert';

  @override
  String get craneEat5SemanticLabel =>
      'Područje za sjedenje u umjetničkom restoranu';

  @override
  String get craneEat6SemanticLabel => 'Jelo od škampa';

  @override
  String get craneEat7SemanticLabel => 'Ulaz u pekarnicu';

  @override
  String get craneEat8SemanticLabel => 'Tanjur s riječnim rakovima';

  @override
  String get craneEat9SemanticLabel => 'Šank u kafiću sa slasticama';

  @override
  String get craneEat10SemanticLabel =>
      'Žena drži ogroman sendvič s dimljenom govedinom';

  @override
  String get fortnightlyMenuFrontPage => 'Naslovnica';

  @override
  String get fortnightlyMenuWorld => 'Svijet';

  @override
  String get fortnightlyMenuUS => 'SAD';

  @override
  String get fortnightlyMenuPolitics => 'Politika';

  @override
  String get fortnightlyMenuBusiness => 'Biznis';

  @override
  String get fortnightlyMenuTech => 'Tehnologija';

  @override
  String get fortnightlyMenuScience => 'Znanost';

  @override
  String get fortnightlyMenuSports => 'Sport';

  @override
  String get fortnightlyMenuTravel => 'Putovanja';

  @override
  String get fortnightlyMenuCulture => 'Kultura';

  @override
  String get fortnightlyTrendingTechDesign => 'TechDesign';

  @override
  String get fortnightlyTrendingReform => 'Reform';

  @override
  String get fortnightlyTrendingHealthcareRevolution => 'HealthcareRevolution';

  @override
  String get fortnightlyTrendingGreenArmy => 'GreenArmy';

  @override
  String get fortnightlyTrendingStocks => 'Stocks';

  @override
  String get fortnightlyLatestUpdates => 'Posljednje novosti';

  @override
  String get fortnightlyHeadlineHealthcare =>
      'Tiha, ali moćna revolucija zdravstva';

  @override
  String get fortnightlyHeadlineWar =>
      'Podijeljeni američki životi tijekom rata';

  @override
  String get fortnightlyHeadlineGasoline => 'Budućnost goriva';

  @override
  String get fortnightlyHeadlineArmy =>
      'Reforma programa The Green Army iznutra';

  @override
  String get fortnightlyHeadlineStocks =>
      'Dok dionice stagniraju, mnogi se okreću valutama';

  @override
  String get fortnightlyHeadlineFabrics =>
      'Dizajneri koriste tehnologiju za izradu futurističkih materijala';

  @override
  String get fortnightlyHeadlineFeminists => 'Feministički pogled na stranačje';

  @override
  String get fortnightlyHeadlineBees => 'Domaćim pčelama nedostaje izvora';
}
