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

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

  @override
  String aboutDialogDescription(Object repoLink) {
    return 'Bu uygulamanın kaynak kodunu görmek için lütfen ${repoLink} sayfasını ziyaret edin.';
  }

  @override
  String get signIn => 'OTURUM AÇ';

  @override
  String get bannerDemoText =>
      'Şifreniz diğer cihazınızda güncellendi. Lütfen tekrar oturum açın.';

  @override
  String get bannerDemoResetText => 'Banner\'ı sıfırla';

  @override
  String get bannerDemoMultipleText => 'Birden çok işlem';

  @override
  String get bannerDemoLeadingText => 'Ön Simge';

  @override
  String get dismiss => 'KAPAT';

  @override
  String get backToGallery => 'Galeriye dön';

  @override
  String get cardsDemoTappable => 'Dokunulabilen';

  @override
  String get cardsDemoSelectable => 'Seçilebilir (uzun basma)';

  @override
  String get cardsDemoExplore => 'Keşfet';

  @override
  String cardsDemoExploreSemantics(Object destinationName) {
    return 'Keşfedin: ${destinationName}';
  }

  @override
  String cardsDemoShareSemantics(Object destinationName) {
    return 'Paylaşın: ${destinationName}';
  }

  @override
  String get cardsDemoTravelDestinationTitle1 =>
      'Tamil Nadu\'da Gezilecek İlk 10 Şehir';

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

  @override
  String get cardsDemoTravelDestinationCity1 => 'Thanjavur';

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

  @override
  String get cardsDemoTravelDestinationTitle2 =>
      'Güney Hindistan\'ın Zanaatkarları';

  @override
  String get cardsDemoTravelDestinationDescription2 => 'İpek Üreticileri';

  @override
  String get cardsDemoTravelDestinationCity2 => 'Chettinad';

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

  @override
  String get cardsDemoTravelDestinationTitle3 => 'Brihadisvara Tapınağı';

  @override
  String get cardsDemoTravelDestinationDescription3 => 'Tapınaklar';

  @override
  String get homeHeaderGallery => 'Galeri';

  @override
  String get homeHeaderCategories => 'Kategoriler';

  @override
  String get shrineDescription => 'Şık bir perakende uygulaması';

  @override
  String get fortnightlyDescription => 'İçeriğe odaklanmış haberler uygulaması';

  @override
  String get rallyDescription => 'Kişisel finans uygulaması';

  @override
  String get rallyAccountDataChecking => 'Mevduat';

  @override
  String get rallyAccountDataHomeSavings => 'Ev İçin Biriktirilen';

  @override
  String get rallyAccountDataCarSavings => 'Araba İçin Biriktirilen';

  @override
  String get rallyAccountDataVacation => 'Tatil';

  @override
  String get rallyAccountDetailDataAnnualPercentageYield =>
      'Yıllık Faiz Getirisi';

  @override
  String get rallyAccountDetailDataInterestRate => 'Faiz Oranı';

  @override
  String get rallyAccountDetailDataInterestYtd => 'Yılın Başından Bugüne Faiz';

  @override
  String get rallyAccountDetailDataInterestPaidLastYear =>
      'Geçen Yıl Ödenen Faiz';

  @override
  String get rallyAccountDetailDataNextStatement => 'Sonraki Ekstre';

  @override
  String get rallyAccountDetailDataAccountOwner => 'Hesap Sahibi';

  @override
  String get rallyBillDetailTotalAmount => 'Toplam Tutar';

  @override
  String get rallyBillDetailAmountPaid => 'Ödenen Tutar';

  @override
  String get rallyBillDetailAmountDue => 'Ödenmesi Gereken Tutar';

  @override
  String get rallyBudgetCategoryCoffeeShops => 'Kafeler';

  @override
  String get rallyBudgetCategoryGroceries => 'Market Alışverişi';

  @override
  String get rallyBudgetCategoryRestaurants => 'Restoranlar';

  @override
  String get rallyBudgetCategoryClothing => 'Giyim';

  @override
  String get rallyBudgetDetailTotalCap => 'Toplam Değer';

  @override
  String get rallyBudgetDetailAmountUsed => 'Kullanılan Miktar';

  @override
  String get rallyBudgetDetailAmountLeft => 'Kalan Miktar';

  @override
  String get rallySettingsManageAccounts => 'Hesapları Yönet';

  @override
  String get rallySettingsTaxDocuments => 'Vergi Dokümanları';

  @override
  String get rallySettingsPasscodeAndTouchId => 'Şifre kodu ve Touch ID';

  @override
  String get rallySettingsNotifications => 'Bildirimler';

  @override
  String get rallySettingsPersonalInformation => 'Kişisel Bilgiler';

  @override
  String get rallySettingsPaperlessSettings => 'Kağıt kullanmayan Ayarlar';

  @override
  String get rallySettingsFindAtms => 'ATMi bul';

  @override
  String get rallySettingsHelp => 'Yardım';

  @override
  String get rallySettingsSignOut => 'Oturumu kapat';

  @override
  String get rallyAccountTotal => 'Toplam';

  @override
  String get rallyBillsDue => 'Ödenecek tutar:';

  @override
  String get rallyBudgetLeft => 'Sol';

  @override
  String get rallyAccounts => 'Hesaplar';

  @override
  String get rallyBills => 'Faturalar';

  @override
  String get rallyBudgets => 'Bütçeler';

  @override
  String get rallyAlerts => 'Uyarılar';

  @override
  String get rallySeeAll => 'TÜMÜNÜ GÖSTER';

  @override
  String get rallyFinanceLeft => 'KALDI';

  @override
  String get rallyTitleOverview => 'GENEL BAKIŞ';

  @override
  String get rallyTitleAccounts => 'HESAPLAR';

  @override
  String get rallyTitleBills => 'FATURALAR';

  @override
  String get rallyTitleBudgets => 'BÜTÇELER';

  @override
  String get rallyTitleSettings => 'AYARLAR';

  @override
  String get rallyLoginLoginToRally => 'Rally\'ye giriş yapın';

  @override
  String get rallyLoginNoAccount => 'Hesabınız yok mu?';

  @override
  String get rallyLoginSignUp => 'KAYDOL';

  @override
  String get rallyLoginUsername => 'Kullanıcı adı';

  @override
  String get rallyLoginPassword => 'Şifre';

  @override
  String get rallyLoginLabelLogin => 'Giriş yapın';

  @override
  String get rallyLoginRememberMe => 'Beni Hatırla';

  @override
  String get rallyLoginButtonLogin => 'GİRİŞ YAP';

  @override
  String rallyAlertsMessageHeadsUpShopping(Object percent) {
    return 'Dikkat! Bu ayın Alışveriş bütçenizi ${percent} oranında harcadınız.';
  }

  @override
  String rallyAlertsMessageSpentOnRestaurants(Object amount) {
    return 'Bu hafta Restoranlarda ${amount} harcadınız.';
  }

  @override
  String rallyAlertsMessageATMFees(Object amount) {
    return 'Bu ay ${amount} tutarında ATM komisyonu ödediniz.';
  }

  @override
  String rallyAlertsMessageCheckingAccount(Object percent) {
    return 'Harika! Çek hesabınız geçen aya göre ${percent} daha fazla.';
  }

  @override
  String rallyAlertsMessageUnassignedTransactions(int count) {
    return intl.Intl.pluralLogic(
      count,
      locale: localeName,
      one:
          'Olası vergi iadenizi artırın. 1 atanmamış işleme kategoriler atayın.',
      other:
          'Olası vergi iadenizi artırın. ${count} atanmamış işleme kategoriler atayın.',
    );
  }

  @override
  String get rallySeeAllAccounts => 'Tüm hesapları göster';

  @override
  String get rallySeeAllBills => 'Tüm faturaları göster';

  @override
  String get rallySeeAllBudgets => 'Tüm bütçeleri göster';

  @override
  String rallyAccountAmount(
      Object accountName, Object accountNumber, Object amount) {
    return 'Bakiyesi ${amount} olan ${accountNumber} numaralı ${accountName} hesabı.';
  }

  @override
  String rallyBillAmount(Object billName, Object date, Object amount) {
    return 'Son ödeme tarihi ${date} olan ${amount} tutarındaki ${billName} faturası.';
  }

  @override
  String rallyBudgetAmount(Object budgetName, Object amountUsed,
      Object amountTotal, Object amountLeft) {
    return 'Toplamı ${amountTotal} olan ve ${amountUsed} kullanıldıktan sonra ${amountLeft} kalan ${budgetName} bütçesi';
  }

  @override
  String get craneDescription => 'Kişiselleştirilmiş seyahat uygulaması';

  @override
  String get homeCategoryReference => 'STİLLER VE DİĞERLERİ';

  @override
  String get demoInvalidURL => 'URL görüntülenemedi:';

  @override
  String get demoOptionsTooltip => 'Seçenekler';

  @override
  String get demoInfoTooltip => 'Bilgi';

  @override
  String get demoCodeTooltip => 'Demo Kodu';

  @override
  String get demoDocumentationTooltip => 'API Dokümanları';

  @override
  String get demoFullscreenTooltip => 'Tam Ekran';

  @override
  String get demoCodeViewerCopyAll => 'TÜMÜNÜ KOPYALA';

  @override
  String get demoCodeViewerCopiedToClipboardMessage => 'Panoya kopyalandı.';

  @override
  String demoCodeViewerFailedToCopyToClipboardMessage(Object error) {
    return 'Panoya kopyalanamadı: ${error}';
  }

  @override
  String get demoOptionsFeatureTitle => 'Seçenekleri göster';

  @override
  String get demoOptionsFeatureDescription =>
      'Bu demodaki kullanılabilir seçenekleri görmek için buraya dokunun.';

  @override
  String get settingsTitle => 'Ayarlar';

  @override
  String get settingsButtonLabel => 'Ayarlar';

  @override
  String get settingsButtonCloseLabel => 'Ayarları kapat';

  @override
  String get settingsSystemDefault => 'Sistem';

  @override
  String get settingsTextScaling => 'Metin ölçekleme';

  @override
  String get settingsTextScalingSmall => 'Küçük';

  @override
  String get settingsTextScalingNormal => 'Normal';

  @override
  String get settingsTextScalingLarge => 'Büyük';

  @override
  String get settingsTextScalingHuge => 'Çok büyük';

  @override
  String get settingsTextDirection => 'Metin yönü';

  @override
  String get settingsTextDirectionLocaleBased => 'Yerel ayara göre';

  @override
  String get settingsTextDirectionLTR => 'LTR';

  @override
  String get settingsTextDirectionRTL => 'RTL';

  @override
  String get settingsLocale => 'Yerel ayar';

  @override
  String get settingsPlatformMechanics => 'Platform mekaniği';

  @override
  String get settingsTheme => 'Tema';

  @override
  String get settingsDarkTheme => 'Koyu';

  @override
  String get settingsLightTheme => 'Açık';

  @override
  String get settingsSlowMotion => 'Ağır çekim';

  @override
  String get settingsAbout => 'Flutter Gallery hakkında';

  @override
  String get settingsFeedback => 'Geri bildirim gönder';

  @override
  String get settingsAttribution => 'Londra\'da TOASTER tarafından tasarlandı';

  @override
  String get demoBottomAppBarTitle => 'Alt uygulama çubuğu';

  @override
  String get demoBottomAppBarSubtitle =>
      'Gezinmeyi ve işlemleri altta gösterir';

  @override
  String get demoBottomAppBarDescription =>
      'Alt uygulama çubuğu, hem alt gezinme çekmecesine hem de kayan işlem düğmesi dahil olmak üzere dörde kadar işleme erişim sağlar.';

  @override
  String get bottomAppBarNotch => 'Çentik';

  @override
  String get bottomAppBarPosition => 'Kayan İşlem Düğmesinin Konumu';

  @override
  String get bottomAppBarPositionDockedEnd => 'Yerleştirilmiş - Uçta';

  @override
  String get bottomAppBarPositionDockedCenter => 'Yerleştirilmiş - Ortada';

  @override
  String get bottomAppBarPositionFloatingEnd => 'Kayan - Uçta';

  @override
  String get bottomAppBarPositionFloatingCenter => 'Kayan - Ortada';

  @override
  String get demoBannerTitle => 'Banner';

  @override
  String get demoBannerSubtitle => 'Liste içinde banner görüntüleme';

  @override
  String get demoBannerDescription =>
      'Bannerlar önemli kısa mesajlar görüntüler ve kullanıcıların yerine getirmeleri (veya banner\'ı kapatmaları) için işlemler sunar. Banner\'ın kapanması için kullanıcının işlem yapması gerekir.';

  @override
  String get demoBottomNavigationTitle => 'Alt gezinme';

  @override
  String get demoBottomNavigationSubtitle =>
      'Çapraz şeffaflaşan görünümlü alt gezinme';

  @override
  String get demoBottomNavigationPersistentLabels => 'Sürekli etiketler';

  @override
  String get demoBottomNavigationSelectedLabel => 'Seçilen etiket';

  @override
  String get demoBottomNavigationDescription =>
      'Alt gezinme çubukları, ekranın altında 3 ila beş arasında varış noktası görüntüler. Her bir varış noktası bir simge ve tercihe bağlı olarak metin etiketiyle temsil edilir. Kullanıcı, bir alt gezinme simgesine dokunduğunda, bu simge ile ilişkilendirilmiş üst düzey gezinme varış noktasına gider.';

  @override
  String get demoButtonTitle => 'Düğmeler';

  @override
  String get demoButtonSubtitle => 'Düz, yükseltilmiş, dış çizgili ve fazlası';

  @override
  String get demoFlatButtonTitle => 'Düz Düğme';

  @override
  String get demoFlatButtonDescription =>
      'Basıldığında mürekkep sıçraması görüntüleyen ancak basıldıktan sonra yukarı kalkmayan düz düğme. Düz düğmeleri araç çubuklarında, iletişim kutularında ve dolgulu satır içinde kullanın';

  @override
  String get demoRaisedButtonTitle => 'Yükseltilmiş Düğme';

  @override
  String get demoRaisedButtonDescription =>
      'Yükseltilmiş düğmeler çoğunlukla düz düzenlere boyut ekler. Yoğun veya geniş alanlarda işlevleri vurgular.';

  @override
  String get demoOutlineButtonTitle => 'Dış Çizgili Düğme';

  @override
  String get demoOutlineButtonDescription =>
      'Dış çizgili düğmeler basıldığında opak olur ve yükselir. Alternatif, ikincil işlemi belirtmek için genellikle yükseltilmiş düğmelerle eşlenirler.';

  @override
  String get demoToggleButtonTitle => 'Açma/Kapatma Düğmeleri';

  @override
  String get demoToggleButtonDescription =>
      'Açma/kapatma düğmeleri benzer seçenekleri gruplamak için kullanılabilir. Benzer açma/kapatma düğmesi gruplarını vurgulamak için grubun ortak bir kapsayıcıyı paylaşması gerekir.';

  @override
  String get demoFloatingButtonTitle => 'Kayan İşlem Düğmesi';

  @override
  String get demoFloatingButtonDescription =>
      'Kayan işlem düğmesi, uygulamadaki birincil işlemi öne çıkarmak için içeriğin üzerine gelen dairesel bir simge düğmesidir.';

  @override
  String get demoCardTitle => 'Kartlar';

  @override
  String get demoCardSubtitle => 'Yuvarlatılmış köşeli temel kartlar';

  @override
  String get demoChipTitle => 'Çipler';

  @override
  String get demoCardDescription =>
      'Kartlar; albüm, coğrafi konum, yemek, iletişim bilgileri gibi alakalı bilgileri temsil etmek için kullanılan Materyal sayfalarıdır.';

  @override
  String get demoChipSubtitle =>
      'Giriş, özellik ve işlem temsil eden kompakt öğeler';

  @override
  String get demoActionChipTitle => 'İşlem Çipi';

  @override
  String get demoActionChipDescription =>
      'İşlem çipleri, asıl içerikle ilgili bir işlemi tetikleyen bir dizi seçenektir. İşlem çipleri, kullanıcı arayüzünde dinamik ve içeriğe dayalı olarak görünmelidir.';

  @override
  String get demoChoiceChipTitle => 'Seçenek Çipi';

  @override
  String get demoChoiceChipDescription =>
      'Seçenek çipleri, bir dizi seçenekten tek bir seçeneği temsil eder. Seçenek çipleri ilgili açıklayıcı metin veya kategoriler içerir.';

  @override
  String get demoFilterChipTitle => 'Filtre çipi';

  @override
  String get demoFilterChipDescription =>
      'Filtre çipleri, içeriği filtreleme yöntemi olarak etiketler ve açıklayıcı kelimeler kullanır.';

  @override
  String get demoInputChipTitle => 'Giriş Çipi';

  @override
  String get demoInputChipDescription =>
      'Giriş çipleri, bir varlık (kişi, yer veya şey) gibi karmaşık bir bilgi parçasını ya da kompakt bir formda konuşma dili metnini temsil eder.';

  @override
  String get demoDataTableTitle => 'Veri Tabloları';

  @override
  String get demoDataTableSubtitle => 'Bilgi satırları ve sütunları';

  @override
  String get demoDataTableDescription =>
      'Veri tabloları bilgileri ızgara biçimindeki satırlar ve sütunlarda görüntüler. Kullanıcıların model ve sonuç arayabilmesi için bilgiyi kolayca taranabilecek şekilde düzenler.';

  @override
  String get dataTableHeader => 'Beslenme';

  @override
  String get dataTableColumnDessert => 'Tatlı (1 porsiyon)';

  @override
  String get dataTableColumnCalories => 'Kalori';

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

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

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

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

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

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

  @override
  String get dataTableRowFrozenYogurt => 'Dondurulmuş yoğurt';

  @override
  String get dataTableRowIceCreamSandwich => 'Dondurmalı sandviç';

  @override
  String get dataTableRowEclair => 'Ekler';

  @override
  String get dataTableRowCupcake => 'Küçük kek';

  @override
  String get dataTableRowGingerbread => 'Kurabiye';

  @override
  String get dataTableRowJellyBean => 'Jelibon';

  @override
  String get dataTableRowLollipop => 'Lolipop';

  @override
  String get dataTableRowHoneycomb => 'Bal peteği';

  @override
  String get dataTableRowDonut => 'Simit';

  @override
  String get dataTableRowApplePie => 'Elmalı turta';

  @override
  String dataTableRowWithSugar(Object value) {
    return 'Şekerli ${value}';
  }

  @override
  String dataTableRowWithHoney(Object value) {
    return 'Ballı ${value}';
  }

  @override
  String get demoDialogTitle => 'İletişim kutuları';

  @override
  String get demoDialogSubtitle => 'Basit, uyarı ve tam ekran';

  @override
  String get demoAlertDialogTitle => 'Uyarı';

  @override
  String get demoAlertDialogDescription =>
      'Uyarı iletişim kutusu, kullanıcıyı onay gerektiren durumlar hakkında bilgilendirir. Uyarı iletişim kutusunun isteğe bağlı başlığı ve isteğe bağlı işlemler listesi vardır.';

  @override
  String get demoAlertTitleDialogTitle => 'Başlıklı Uyarı';

  @override
  String get demoSimpleDialogTitle => 'Basit';

  @override
  String get demoSimpleDialogDescription =>
      'Basit iletişim kutusu, kullanıcıya birkaç seçenek arasından seçim yapma olanağı sunar. Basit iletişim kutusunun seçeneklerin üzerinde görüntülenen isteğe bağlı bir başlığı vardır.';

  @override
  String get demoGridListsTitle => 'Tablo Listeler';

  @override
  String get demoGridListsSubtitle => 'Satır ve sütun düzeni';

  @override
  String get demoGridListsDescription =>
      'Tablo Listeler, genellikle resimler gibi benzer türdeki verileri sunmanın en uygun yöntemidir. Tablodaki her öğeye kutu denir.';

  @override
  String get demoGridListsImageOnlyTitle => 'Yalnızca resim';

  @override
  String get demoGridListsHeaderTitle => 'Üst bilgisi olan';

  @override
  String get demoGridListsFooterTitle => 'Alt bilgisi olan';

  @override
  String get demoSlidersTitle => 'Kaydırma Çubukları';

  @override
  String get demoSlidersSubtitle =>
      'Kaydırarak bir değer seçmeyi sağlayan widget';

  @override
  String get demoSlidersDescription =>
      'Kullanıcılar, kaydırma çubuklarını kullanarak belirtilen değer aralığı içinde bir değeri seçebilir. Kaydırma çubukları, ses düzeyi ve parlaklık gibi ayarları düzenlemek veya görüntü filtreleri uygulamak için idealdir.';

  @override
  String get demoRangeSlidersTitle => 'Aralık Kaydırma Çubukları';

  @override
  String get demoRangeSlidersDescription =>
      'Kaydırma çubukları, bir çubuk boyunca çeşitli değerler yansıtır. Kaydırma çubuklarının her iki ucunda değer aralığının alt ve üst değerlerini gösteren simgeler bulunabilir. Kaydırma çubukları, ses düzeyi ve parlaklık gibi ayarları düzenlemek veya görüntü filtreleri uygulamak için idealdir.';

  @override
  String get demoCustomSlidersTitle => 'Özel Kaydırma Çubukları';

  @override
  String get demoCustomSlidersDescription =>
      'Kullanıcılar, kaydırma çubuklarını kullanarak belirtilen değer aralığı içinde bir değer veya değer aralığını seçebilir. Kaydırma çubukları temalı veya özelleştirilmiş olabilir.';

  @override
  String get demoSlidersContinuousWithEditableNumericalValue =>
      'Düzenlenebilir Sayısal Değere Sahip Kesintisiz';

  @override
  String get demoSlidersDiscrete => 'Ayrık';

  @override
  String get demoSlidersDiscreteSliderWithCustomTheme =>
      'Özelleştirilmiş Temaya Sahip Ayrık Değerli Kaydırma Çubuğu';

  @override
  String get demoSlidersContinuousRangeSliderWithCustomTheme =>
      'Özelleştirilmiş Temaya Sahip Sürekli Aralık Değerli Çubuğu';

  @override
  String get demoSlidersContinuous => 'Sürekli';

  @override
  String get demoSlidersEditableNumericalValue =>
      'Düzenlenebilir sayısal değer';

  @override
  String get demoMenuTitle => 'Menü';

  @override
  String get demoContextMenuTitle => 'İçerik menüsü';

  @override
  String get demoSectionedMenuTitle => 'Bölümlere ayrılmış menü';

  @override
  String get demoSimpleMenuTitle => 'Basit menü';

  @override
  String get demoChecklistMenuTitle => 'Liste menü';

  @override
  String get demoMenuSubtitle => 'Menü düğmeleri ve basit menüler';

  @override
  String get demoMenuDescription =>
      'Menü, geçici bir yüzeyde seçenekler listesini görüntüler. Menüler, kullanıcılar bir düğme, işlem veya başka bir kontrolle etkileşimde bulunduğunda görünür.';

  @override
  String get demoMenuItemValueOne => 'Menü öğesi bir';

  @override
  String get demoMenuItemValueTwo => 'Menü öğesi iki';

  @override
  String get demoMenuItemValueThree => 'Menü öğesi üç';

  @override
  String get demoMenuOne => 'Bir';

  @override
  String get demoMenuTwo => 'İki';

  @override
  String get demoMenuThree => 'Üç';

  @override
  String get demoMenuFour => 'Dört';

  @override
  String get demoMenuAnItemWithAContextMenuButton => 'İçerik menüsü olan öğe';

  @override
  String get demoMenuContextMenuItemOne => 'İçerik menüsü öğesi bir';

  @override
  String get demoMenuADisabledMenuItem => 'Devre dışı menü öğesi';

  @override
  String get demoMenuContextMenuItemThree => 'İçerik menüsü öğesi üç';

  @override
  String get demoMenuAnItemWithASectionedMenu =>
      'Bölümlere ayrılmış menüsü olan öğe';

  @override
  String get demoMenuPreview => 'Önizle';

  @override
  String get demoMenuShare => 'Paylaş';

  @override
  String get demoMenuGetLink => 'Bağlantıyı al';

  @override
  String get demoMenuRemove => 'Kaldır';

  @override
  String demoMenuSelected(Object value) {
    return 'Seçildi: ${value}';
  }

  @override
  String demoMenuChecked(Object value) {
    return 'İşaretlendi: ${value}';
  }

  @override
  String get demoMenuAnItemWithASimpleMenu => 'Basit menüsü olan öğe';

  @override
  String get demoMenuAnItemWithAChecklistMenu => 'Liste menüsü olan öğe';

  @override
  String get demoFullscreenDialogTitle => 'Tam Ekran';

  @override
  String get demoFullscreenDialogDescription =>
      'Tam ekran iletişim kutusu özelliği, gelen sayfanın tam ekran kalıcı bir iletişim kutusu olup olmadığını belirtir.';

  @override
  String get demoCupertinoActivityIndicatorTitle => 'Etkinlik göstergesi';

  @override
  String get demoCupertinoActivityIndicatorSubtitle =>
      'iOS stili işlem göstergeleri';

  @override
  String get demoCupertinoActivityIndicatorDescription =>
      'Saat yönünde dönen iOS-tarzında işlem göstergesi';

  @override
  String get demoCupertinoButtonsTitle => 'Düğmeler';

  @override
  String get demoCupertinoButtonsSubtitle => 'iOS tarzı düğmeler';

  @override
  String get demoCupertinoButtonsDescription =>
      'iOS tarzı düğme. Dokunulduğunda rengi açılan ve kararan metin ve/veya simge içerir. İsteğe bağlı olarak arka planı bulunabilir.';

  @override
  String get demoCupertinoAlertsTitle => 'Uyarılar';

  @override
  String get demoCupertinoAlertsSubtitle => 'iOS tarzı uyarı iletişim kutuları';

  @override
  String get demoCupertinoAlertTitle => 'Uyarı';

  @override
  String get demoCupertinoAlertDescription =>
      'Uyarı iletişim kutusu, kullanıcıyı onay gerektiren durumlar hakkında bilgilendirir. Uyarı iletişim kutusunun isteğe bağlı başlığı, isteğe bağlı içeriği ve isteğe bağlı işlemler listesi vardır. Başlık içeriğin üzerinde görüntülenir ve işlemler içeriğin altında görüntülenir.';

  @override
  String get demoCupertinoAlertWithTitleTitle => 'Başlıklı Uyarı';

  @override
  String get demoCupertinoAlertButtonsTitle => 'Düğmeli Uyarı';

  @override
  String get demoCupertinoAlertButtonsOnlyTitle => 'Yalnızca Uyarı Düğmeleri';

  @override
  String get demoCupertinoActionSheetTitle => 'İşlem Sayfası';

  @override
  String get demoCupertinoActionSheetDescription =>
      'İşlem sayfası, kullanıcıya geçerli bağlamla ilgili iki veya daha fazla seçenek sunan belirli bir uyarı tarzıdır. Bir işlem sayfasının başlığı, ek mesajı ve işlemler listesi olabilir.';

  @override
  String get demoCupertinoNavigationBarTitle => 'Gezinme çubuğu';

  @override
  String get demoCupertinoNavigationBarSubtitle => 'iOS stili gezinme çubuğu';

  @override
  String get demoCupertinoNavigationBarDescription =>
      'iOS stili bir gezinme çubuğu. Gezinme çubuğu, ortasında sayfa başlığını minimum düzeyde içeren bir araç çubuğudur.';

  @override
  String get demoCupertinoPickerTitle => 'Seçiciler';

  @override
  String get demoCupertinoPickerSubtitle => 'iOS stili tarih ve saat seçici';

  @override
  String get demoCupertinoPickerDescription =>
      'Tarih, saat veya hem tarih hem de saat seçmek için kullanılabilen iOS stili seçici widget\'ı.';

  @override
  String get demoCupertinoPickerTimer => 'Zamanlayıcı';

  @override
  String get demoCupertinoPickerDate => 'Tarih';

  @override
  String get demoCupertinoPickerTime => 'Saat';

  @override
  String get demoCupertinoPickerDateTime => 'Tarih ve Saat';

  @override
  String get demoCupertinoPullToRefreshTitle => 'Yenilemek için aşağı çekin';

  @override
  String get demoCupertinoPullToRefreshSubtitle =>
      'iOS stili yenilemek için aşağı çekme denetimi';

  @override
  String get demoCupertinoPullToRefreshDescription =>
      'iOS stili yenilemek için aşağı çekme denetimini uygulayan widget.';

  @override
  String get demoCupertinoSegmentedControlTitle => 'Bölümlere ayrılmış kontrol';

  @override
  String get demoCupertinoSegmentedControlSubtitle =>
      'iOS-tarzı bölümlere ayrılmış kontrol';

  @override
  String get demoCupertinoSegmentedControlDescription =>
      'Birbirini dışlayan bir dizi seçenek arasında seçim yapmak için kullanıldı. Segmentlere ayrılmış kontrolde bir seçenek belirlendiğinde, segmentlere ayrılmış denetimdeki diğer seçenek belirlenemez.';

  @override
  String get demoCupertinoSliderTitle => 'Kaydırma çubuğu';

  @override
  String get demoCupertinoSliderSubtitle => 'iOS tarzında kaydırma çubuğu';

  @override
  String get demoCupertinoSliderDescription =>
      'Kaydırma çubukları sürekli veya aralıklı değerler içinden seçim yapmak için kullanılır.';

  @override
  String demoCupertinoSliderContinuous(Object value) {
    return 'Sürekli: ${value}';
  }

  @override
  String demoCupertinoSliderDiscrete(Object value) {
    return 'Aralıklı: ${value}';
  }

  @override
  String get demoCupertinoSwitchSubtitle => 'iOS tarzında anahtar';

  @override
  String get demoCupertinoSwitchDescription =>
      'Anahtarlar tek bir ayarın açık/kapalı durumunu değiştirmek için kullanılır.';

  @override
  String get demoCupertinoTabBarTitle => 'Sekme çubuğu';

  @override
  String get demoCupertinoTabBarSubtitle => 'iOS tarzında alt sekme çubuğu';

  @override
  String get demoCupertinoTabBarDescription =>
      'iOS tarzında alt gezinme sekmesi çubuğu. Birden fazla sekme gösterilir. Varsayılan olarak ilk sekme olmak üzere içlerinden biri etkin durumda olur.';

  @override
  String get cupertinoTabBarHomeTab => 'Ana sayfa';

  @override
  String get cupertinoTabBarChatTab => 'Sohbet';

  @override
  String get cupertinoTabBarProfileTab => 'Profil';

  @override
  String get demoCupertinoTextFieldTitle => 'Metin-alanları';

  @override
  String get demoCupertinoTextFieldSubtitle => 'iOS stili metin alanı';

  @override
  String get demoCupertinoTextFieldDescription =>
      'Metin alanı, kullanıcının donanım klavyesi veya ekran klavyesi ile metin girmesini sağlar.';

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

  @override
  String get demoColorsSubtitle => 'Önceden tanımlanmış renklerin tümü';

  @override
  String get demoColorsDescription =>
      'Materyal Tasarımın renk paletini temsil eden renk ve renk örneği sabitleri.';

  @override
  String get demoTypographyTitle => 'Yazı biçimi';

  @override
  String get demoTypographySubtitle => 'Önceden tanımlanmış tüm metin stilleri';

  @override
  String get demoTypographyDescription =>
      'Materyal Tasarımında bulunan çeşitli tipografik stillerin tanımları.';

  @override
  String get demo2dTransformationsTitle => '2D dönüşümler';

  @override
  String get demo2dTransformationsSubtitle =>
      'Kaydırma, yakınlaştırma, döndürme';

  @override
  String get demo2dTransformationsDescription =>
      'Blokları düzenlemek için dokunun ve sahnede farklı yerlere taşımak için hareketleri kullanın. Kaydırmak için sürükleyin, yakınlaştırmak için sıkıştırın, iki parmağınızla döndürün. Başlangıç yönüne geri döndürmek için sıfırlama düğmesine basın.';

  @override
  String get demo2dTransformationsResetTooltip => 'Dönüşümleri sıfırla';

  @override
  String get demo2dTransformationsEditTooltip => 'Bloğu düzenle';

  @override
  String get buttonText => 'DÜĞME';

  @override
  String get demoBottomSheetTitle => 'Alt sayfa';

  @override
  String get demoBottomSheetSubtitle => 'Sürekli ve kalıcı alt sayfalar';

  @override
  String get demoBottomSheetPersistentTitle => 'Sürekli görüntülenen alt sayfa';

  @override
  String get demoBottomSheetPersistentDescription =>
      'Sürekli görüntülenen alt sayfa, uygulamanın asıl içeriğine ek bilgileri gösterir ve kullanıcı uygulamanın diğer bölümleriyle etkileşimde bulunurken görünmeye devam eder.';

  @override
  String get demoBottomSheetModalTitle => 'Kalıcı alt sayfa';

  @override
  String get demoBottomSheetModalDescription =>
      'Kalıcı alt sayfa, alternatif bir menü veya iletişim kutusudur ve kullanıcının uygulamanın geri kalanı ile etkileşimde bulunmasını önler.';

  @override
  String get demoBottomSheetAddLabel => 'Ekle';

  @override
  String get demoBottomSheetButtonText => 'ALT SAYFAYI GÖSTER';

  @override
  String get demoBottomSheetHeader => 'Üst bilgi';

  @override
  String demoBottomSheetItem(Object value) {
    return 'Ürün ${value}';
  }

  @override
  String get demoListsTitle => 'Listeler';

  @override
  String get demoListsSubtitle => 'Kayan liste düzenleri';

  @override
  String get demoListsDescription =>
      'Tipik olarak biraz metnin yanı sıra başında veya sonunda simge olan sabit yükseklikli tek satır.';

  @override
  String get demoOneLineListsTitle => 'Tek Satır';

  @override
  String get demoTwoLineListsTitle => 'İki Satır';

  @override
  String get demoListsSecondary => 'İkincil metin';

  @override
  String get demoProgressIndicatorTitle => 'İlerleme durumu göstergeleri';

  @override
  String get demoProgressIndicatorSubtitle => 'Doğrusal, dairesel, belirsiz';

  @override
  String get demoCircularProgressIndicatorTitle =>
      'Dairesel İlerleme Durumu Göstergesi';

  @override
  String get demoCircularProgressIndicatorDescription =>
      'Dönerek uygulamanın meşgul olduğunu gösteren Materyal Tasarıma sahip dairesel ilerleme durumu göstergesi';

  @override
  String get demoLinearProgressIndicatorTitle =>
      'Doğrusal İlerleme Durumu Göstergesi';

  @override
  String get demoLinearProgressIndicatorDescription =>
      'İlerleme çubuğu olarak da bilinen, Materyal Tasarıma sahip doğrusal ilerleme durumu göstergesi';

  @override
  String get demoPickersTitle => 'Seçiciler';

  @override
  String get demoPickersSubtitle => 'Tarih ve saat seçme';

  @override
  String get demoDatePickerTitle => 'Tarih Seçici';

  @override
  String get demoDatePickerDescription =>
      'Materyal Tasarıma sahip tarih seçici içeren bir iletişim kutusu gösterir.';

  @override
  String get demoTimePickerTitle => 'Saat Seçici';

  @override
  String get demoTimePickerDescription =>
      'Materyal Tasarıma sahip saat seçici içeren bir iletişim kutusu gösterir.';

  @override
  String get demoPickersShowPicker => 'SEÇİCİYİ GÖSTER';

  @override
  String get demoTabsTitle => 'Sekmeler';

  @override
  String get demoTabsScrollingTitle => 'Kaydırarak';

  @override
  String get demoTabsNonScrollingTitle => 'Kaydırma olmadan';

  @override
  String get demoTabsSubtitle =>
      'Bağımsız olarak kaydırılabilen görünümlü sekmeler';

  @override
  String get demoTabsDescription =>
      'Sekmeler farklı ekranlarda, veri kümelerinde ve diğer etkileşimlerde bulunan içeriği düzenler.';

  @override
  String get demoSnackbarsTitle => 'Snackbar\'lar';

  @override
  String get demoSnackbarsSubtitle =>
      'Snackbar\'lar ekranın alt bölümünde mesaj gösterir';

  @override
  String get demoSnackbarsDescription =>
      'Snackbar\'lar bir uygulamanın gerçekleştirdiği veya gerçekleştireceği bir işlemi kullanıcılara bildirir. Ekranın altına yakın bir yerde geçici olarak görünür. Kullanıcı deneyimini engellememeli ve ekrandan kaybolması için kullanıcının bir işlem yapmasını gerektirmemelidir.';

  @override
  String get demoSnackbarsButtonLabel => 'SNACKBAR GÖSTER';

  @override
  String get demoSnackbarsText => 'Bu bir snackbar.';

  @override
  String get demoSnackbarsActionButtonLabel => 'İŞLEM';

  @override
  String get demoSnackbarsAction => 'Snackbar işlemine bastınız.';

  @override
  String get demoSelectionControlsTitle => 'Seçim kontrolleri';

  @override
  String get demoSelectionControlsSubtitle =>
      'Onay kutuları, radyo düğmeleri ve anahtarlar';

  @override
  String get demoSelectionControlsCheckboxTitle => 'Onay Kutusu';

  @override
  String get demoSelectionControlsCheckboxDescription =>
      'Onay kutuları, kullanıcıya bir dizi seçenek arasından birden fazlasını belirlemesine olanak sağlar. Normal bir onay kutusunun değeri true (doğru) veya false (yanlış) olur. Üç durumlu onay kutusunun değeri boş da olabilir.';

  @override
  String get demoSelectionControlsRadioTitle => 'Radyo düğmesi';

  @override
  String get demoSelectionControlsRadioDescription =>
      'Radyo düğmeleri, kullanıcının bir dizi seçenek arasından birini belirlemesine olanak sağlar. Kullanıcının tüm mevcut seçenekleri yan yana görmesi gerektiğini düşünüyorsanız özel seçim için radyo düğmelerini kullanın.';

  @override
  String get demoSelectionControlsSwitchTitle => 'Anahtar';

  @override
  String get demoSelectionControlsSwitchDescription =>
      'Açık/kapalı anahtarları, tek bir ayarlar seçeneğinin durumunu açar veya kapatır. Anahtarın kontrol ettiği seçeneğin yanı sıra seçeneğin bulunduğu durum, karşılık gelen satır içi etikette açıkça belirtilmelidir.';

  @override
  String get demoBottomTextFieldsTitle => 'Metin-alanları';

  @override
  String get demoTextFieldTitle => 'Metin-alanları';

  @override
  String get demoTextFieldSubtitle =>
      'Tek satır düzenlenebilir metin ve sayılar';

  @override
  String get demoTextFieldDescription =>
      'Metin alanları, kullanıcıların bir kullanıcı arayüzüne metin girmesini sağlar. Genellikle formlarda ve iletişim kutularında görünürler.';

  @override
  String get demoTextFieldShowPasswordLabel => 'Şifreyi göster';

  @override
  String get demoTextFieldHidePasswordLabel => 'Şifreyi gizle';

  @override
  String get demoTextFieldFormErrors =>
      'Göndermeden önce lütfen kırmızı renkle belirtilen hataları düzeltin';

  @override
  String get demoTextFieldNameRequired => 'Ad gerekli.';

  @override
  String get demoTextFieldOnlyAlphabeticalChars =>
      'Lütfen sadece alfabetik karakterler girin.';

  @override
  String get demoTextFieldEnterUSPhoneNumber =>
      '(###) ###-#### - ABD\'ye ait bir telefon numarası girin.';

  @override
  String get demoTextFieldEnterPassword => 'Lütfen bir şifre girin.';

  @override
  String get demoTextFieldPasswordsDoNotMatch => 'Şifreler eşleşmiyor';

  @override
  String get demoTextFieldWhatDoPeopleCallYou =>
      'Size hangi adla hitap ediliyor?';

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

  @override
  String get demoTextFieldWhereCanWeReachYou => 'Size nereden ulaşabiliriz?';

  @override
  String get demoTextFieldPhoneNumber => 'Telefon numarası*';

  @override
  String get demoTextFieldYourEmailAddress => 'E-posta adresiniz';

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

  @override
  String get demoTextFieldTellUsAboutYourself =>
      'Bize kendinizden bahsedin (örneğin, ne iş yaptığınızı veya hobilerinizi yazın)';

  @override
  String get demoTextFieldKeepItShort => 'Kısa tutun, bu sadece bir demo.';

  @override
  String get demoTextFieldLifeStory => 'Hayat hikayesi';

  @override
  String get demoTextFieldSalary => 'Salary';

  @override
  String get demoTextFieldUSD => 'USD';

  @override
  String get demoTextFieldNoMoreThan => 'En fazla 8 karakter.';

  @override
  String get demoTextFieldPassword => 'Şifre*';

  @override
  String get demoTextFieldRetypePassword => 'Şifreyi yeniden yazın*';

  @override
  String get demoTextFieldSubmit => 'GÖNDER';

  @override
  String demoTextFieldNameHasPhoneNumber(Object name, Object phoneNumber) {
    return '${name} adlı kişinin telefon numarası: ${phoneNumber}';
  }

  @override
  String get demoTextFieldRequiredField => '* zorunlu alanı belirtir';

  @override
  String get demoTooltipTitle => 'İpuçları';

  @override
  String get demoTooltipSubtitle =>
      'Uzun basmada veya fareyle üzerine gelmede görüntülenen kısa mesaj';

  @override
  String get demoTooltipDescription =>
      'İpuçları, bir düğmenin işlevini veya diğer kullanıcı arayüzü işlemini açıklamaya yardımcı olan metin etiketleri sağlar. İpuçları, kullanıcı fareyle bir öğenin üzerine geldiğinde veya öğeye odaklandığında ya da uzun bastığında bilgilendirici metin görüntüler.';

  @override
  String get demoTooltipInstructions =>
      'İpucunu görüntülemek için uzun basın veya fareyle üzerine gelin.';

  @override
  String get bottomNavigationCommentsTab => 'Yorumlar';

  @override
  String get bottomNavigationCalendarTab => 'Takvim';

  @override
  String get bottomNavigationAccountTab => 'Hesap';

  @override
  String get bottomNavigationAlarmTab => 'Alarm';

  @override
  String get bottomNavigationCameraTab => 'Kamera';

  @override
  String bottomNavigationContentPlaceholder(Object title) {
    return '${title} sekmesi için yer tutucu';
  }

  @override
  String get buttonTextCreate => 'Oluştur';

  @override
  String dialogSelectedOption(Object value) {
    return 'Şunu seçtiniz: \"${value}\"';
  }

  @override
  String get chipTurnOnLights => 'Işıkları aç';

  @override
  String get chipSmall => 'Küçük';

  @override
  String get chipMedium => 'Orta';

  @override
  String get chipLarge => 'Büyük';

  @override
  String get chipElevator => 'Asansör';

  @override
  String get chipWasher => 'Çamaşır makinesi';

  @override
  String get chipFireplace => 'Şömine';

  @override
  String get chipBiking => 'Bisiklet';

  @override
  String get dialogDiscardTitle => 'Taslak silinsin mi?';

  @override
  String get dialogLocationTitle => 'Google\'ın konum hizmeti kullanılsın mı?';

  @override
  String get dialogLocationDescription =>
      'Google\'ın, uygulamaların konum tespiti yapmasına yardımcı olmasına izin verin. Bu, hiçbir uygulama çalışmıyorken bile anonim konum verilerinin Google\'a gönderilmesi anlamına gelir.';

  @override
  String get dialogCancel => 'İPTAL';

  @override
  String get dialogDiscard => 'SİL';

  @override
  String get dialogDisagree => 'KABUL ETMİYORUM';

  @override
  String get dialogAgree => 'KABUL EDİYORUM';

  @override
  String get dialogSetBackup => 'Yedekleme hesabı ayarla';

  @override
  String get dialogAddAccount => 'Hesap ekle';

  @override
  String get dialogShow => 'İLETİŞİM KUTUSUNU GÖSTER';

  @override
  String get dialogFullscreenTitle => 'Tam Ekran İletişim Kutusu';

  @override
  String get dialogFullscreenSave => 'KAYDET';

  @override
  String get dialogFullscreenDescription => 'Tam ekran iletişim kutusu demosu';

  @override
  String get cupertinoButton => 'Düğme';

  @override
  String get cupertinoButtonWithBackground => 'Arka Planı Olan';

  @override
  String get cupertinoAlertCancel => 'İptal';

  @override
  String get cupertinoAlertDiscard => 'Sil';

  @override
  String get cupertinoAlertLocationTitle =>
      'Uygulamayı kullanırken \"Haritalar\"ın konumunuza erişmesine izin verilsin mi?';

  @override
  String get cupertinoAlertLocationDescription =>
      'Geçerli konumunuz haritada gösterilecek, yol tarifleri, yakındaki arama sonuçları ve tahmini seyahat süreleri için kullanılacak.';

  @override
  String get cupertinoAlertAllow => 'İzin ver';

  @override
  String get cupertinoAlertDontAllow => 'İzin Verme';

  @override
  String get cupertinoAlertFavoriteDessert => 'Select Favorite Dessert';

  @override
  String get cupertinoAlertDessertDescription =>
      'Lütfen aşağıdaki listeden en sevdiğiniz tatlı türünü seçin. Seçiminiz, bölgenizdeki önerilen restoranlar listesini özelleştirmek için kullanılacak.';

  @override
  String get cupertinoAlertCheesecake => 'Cheesecake';

  @override
  String get cupertinoAlertTiramisu => 'Tiramisu';

  @override
  String get cupertinoAlertApplePie => 'Elmalı Turta';

  @override
  String get cupertinoAlertChocolateBrownie => 'Çikolatalı Browni';

  @override
  String get cupertinoShowAlert => 'Uyarıyı Göster';

  @override
  String get colorsRed => 'KIRMIZI';

  @override
  String get colorsPink => 'PEMBE';

  @override
  String get colorsPurple => 'MOR';

  @override
  String get colorsDeepPurple => 'KOYU MOR';

  @override
  String get colorsIndigo => 'ÇİVİT MAVİSİ';

  @override
  String get colorsBlue => 'MAVİ';

  @override
  String get colorsLightBlue => 'AÇIK MAVİ';

  @override
  String get colorsCyan => 'CAMGÖBEĞİ';

  @override
  String get colorsTeal => 'TURKUAZ';

  @override
  String get colorsGreen => 'YEŞİL';

  @override
  String get colorsLightGreen => 'AÇIK YEŞİL';

  @override
  String get colorsLime => 'KÜF YEŞİLİ';

  @override
  String get colorsYellow => 'SARI';

  @override
  String get colorsAmber => 'KEHRİBAR RENNGİ';

  @override
  String get colorsOrange => 'TURUNCU';

  @override
  String get colorsDeepOrange => 'KOYU TURUNCU';

  @override
  String get colorsBrown => 'KAHVERENGİ';

  @override
  String get colorsGrey => 'GRİ';

  @override
  String get colorsBlueGrey => 'MAVİYE ÇALAN GRİ';

  @override
  String get placeChennai => 'Chennai';

  @override
  String get placeTanjore => 'Thanjavur';

  @override
  String get placeChettinad => 'Chettinad';

  @override
  String get placePondicherry => 'Pondicherry';

  @override
  String get placeFlowerMarket => 'Çiçek Pazarı';

  @override
  String get placeBronzeWorks => 'Bronz İşler';

  @override
  String get placeMarket => 'Pazar';

  @override
  String get placeThanjavurTemple => 'Thanjavur Tapınağı';

  @override
  String get placeSaltFarm => 'Tuz Çiftliği';

  @override
  String get placeScooters => 'Scooter\'lar';

  @override
  String get placeSilkMaker => 'İpek Üreticisi';

  @override
  String get placeLunchPrep => 'Öğle Yemeği Hazırlığı';

  @override
  String get placeBeach => 'Kumsal';

  @override
  String get placeFisherman => 'Balıkçı';

  @override
  String get starterAppTitle => 'Başlangıç uygulaması';

  @override
  String get starterAppDescription => 'Duyarlı başlangıç düzeni';

  @override
  String get starterAppGenericButton => 'DÜĞME';

  @override
  String get starterAppTooltipAdd => 'Ekle';

  @override
  String get starterAppTooltipFavorite => 'Favoriler listesine ekle';

  @override
  String get starterAppTooltipShare => 'Paylaş';

  @override
  String get starterAppTooltipSearch => 'Ara';

  @override
  String get starterAppGenericTitle => 'Başlık';

  @override
  String get starterAppGenericSubtitle => 'Alt başlık';

  @override
  String get starterAppGenericHeadline => 'Başlık';

  @override
  String get starterAppGenericBody => 'Gövde';

  @override
  String starterAppDrawerItem(Object value) {
    return 'Ürün ${value}';
  }

  @override
  String get shrineMenuCaption => 'MENÜ';

  @override
  String get shrineCategoryNameAll => 'TÜMÜ';

  @override
  String get shrineCategoryNameAccessories => 'AKSESUARLAR';

  @override
  String get shrineCategoryNameClothing => 'GİYİM';

  @override
  String get shrineCategoryNameHome => 'EV';

  @override
  String get shrineLogoutButtonCaption => 'ÇIKIŞ YAP';

  @override
  String get shrineLoginUsernameLabel => 'Kullanıcı adı';

  @override
  String get shrineLoginPasswordLabel => 'Şifre';

  @override
  String get shrineCancelButtonCaption => 'İPTAL';

  @override
  String get shrineNextButtonCaption => 'SONRAKİ';

  @override
  String get shrineCartPageCaption => 'ALIŞVERİŞ SEPETİ';

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

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

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

  @override
  String get shrineCartClearButtonCaption => 'ALIŞVERİŞ SEPETİNİ BOŞALT';

  @override
  String get shrineCartTotalCaption => 'TOPLAM';

  @override
  String get shrineCartSubtotalCaption => 'Alt toplam:';

  @override
  String get shrineCartShippingCaption => 'Gönderim:';

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

  @override
  String get shrineProductVagabondSack => 'Vagabond çanta';

  @override
  String get shrineProductStellaSunglasses => 'Stella güneş gözlüğü';

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

  @override
  String get shrineProductGardenStrand => 'Bahçe teli';

  @override
  String get shrineProductStrutEarrings => 'Strut küpeler';

  @override
  String get shrineProductVarsitySocks => 'Varis çorabı';

  @override
  String get shrineProductWeaveKeyring => 'Örgülü anahtarlık';

  @override
  String get shrineProductGatsbyHat => 'Gatsby şapka';

  @override
  String get shrineProductShrugBag => 'Askılı çanta';

  @override
  String get shrineProductGiltDeskTrio => 'Yaldızlı üçlü sehpa';

  @override
  String get shrineProductCopperWireRack => 'Bakır tel raf';

  @override
  String get shrineProductSootheCeramicSet => 'Rahatlatıcı seramik takım';

  @override
  String get shrineProductHurrahsTeaSet => 'Hurrahs çay takımı';

  @override
  String get shrineProductBlueStoneMug => 'Mavi taş kupa';

  @override
  String get shrineProductRainwaterTray => 'Yağmur gideri';

  @override
  String get shrineProductChambrayNapkins => 'Şambre peçete';

  @override
  String get shrineProductSucculentPlanters => 'Sukulent bitki saksıları';

  @override
  String get shrineProductQuartetTable => 'Dört kişilik masa';

  @override
  String get shrineProductKitchenQuattro => 'Quattro mutfak';

  @override
  String get shrineProductClaySweater => 'Kil kazak';

  @override
  String get shrineProductSeaTunic => 'Deniz tuniği';

  @override
  String get shrineProductPlasterTunic => 'İnce tunik';

  @override
  String get shrineProductWhitePinstripeShirt => 'İnce çizgili beyaz gömlek';

  @override
  String get shrineProductChambrayShirt => 'Patiska gömlek';

  @override
  String get shrineProductSeabreezeSweater => 'Deniz esintisi kazağı';

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

  @override
  String get shrineProductNavyTrousers => 'Lacivert pantolon';

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

  @override
  String get shrineProductSurfAndPerfShirt => '\"Surf and perf\" gömlek';

  @override
  String get shrineProductGingerScarf => 'Kırmızı eşarp';

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

  @override
  String get shrineProductClassicWhiteCollar => 'Klasik beyaz yaka';

  @override
  String get shrineProductCeriseScallopTee => 'Kiraz kırmızısı fistolu tişört';

  @override
  String get shrineProductShoulderRollsTee => 'Açık omuzlu tişört';

  @override
  String get shrineProductGreySlouchTank => 'Gri bol kolsuz tişört';

  @override
  String get shrineProductSunshirtDress => 'Yazlık elbise';

  @override
  String get shrineProductFineLinesTee => 'İnce çizgili tişört';

  @override
  String get shrineTooltipSearch => 'Ara';

  @override
  String get shrineTooltipSettings => 'Ayarlar';

  @override
  String get shrineTooltipOpenMenu => 'Menüyü aç';

  @override
  String get shrineTooltipCloseMenu => 'Menüyü kapat';

  @override
  String get shrineTooltipCloseCart => 'Alışveriş sepetini kapat';

  @override
  String shrineScreenReaderCart(int quantity) {
    return intl.Intl.pluralLogic(
      quantity,
      locale: localeName,
      zero: 'Alışveriş sepeti, ürün yok',
      one: 'Alışveriş sepeti, 1 ürün',
      other: 'Alışveriş sepeti, ${quantity} ürün',
    );
  }

  @override
  String get shrineScreenReaderProductAddToCart => 'Sepete ekle';

  @override
  String shrineScreenReaderRemoveProductButton(Object product) {
    return '${product} ürününü kaldır';
  }

  @override
  String get shrineTooltipRemoveItem => 'Öğeyi kaldır';

  @override
  String get craneFormDiners => 'Lokanta sayısı';

  @override
  String get craneFormDate => 'Tarih Seçin';

  @override
  String get craneFormTime => 'Saat Seçin';

  @override
  String get craneFormLocation => 'Konum Seçin';

  @override
  String get craneFormTravelers => 'Yolcu sayısı';

  @override
  String get craneFormOrigin => 'Kalkış Noktası Seçin';

  @override
  String get craneFormDestination => 'Varış Noktası Seçin';

  @override
  String get craneFormDates => 'Tarihleri Seçin';

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

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

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

  @override
  String get craneFly => 'UÇUŞ';

  @override
  String get craneSleep => 'UYKU';

  @override
  String get craneEat => 'YEME';

  @override
  String get craneFlySubhead => 'Varış Noktasına Göre Uçuş Araştırma';

  @override
  String get craneSleepSubhead => 'Varış Noktasına Göre Mülk Araştırma';

  @override
  String get craneEatSubhead => 'Varış Noktasına Göre Restoran Araştırma';

  @override
  String craneFlyStops(int numberOfStops) {
    return intl.Intl.pluralLogic(
      numberOfStops,
      locale: localeName,
      zero: 'Aktarmasız',
      one: '1 aktarma',
      other: '${numberOfStops} aktarma',
    );
  }

  @override
  String craneSleepProperties(int totalProperties) {
    return intl.Intl.pluralLogic(
      totalProperties,
      locale: localeName,
      zero: 'Müsait Mülk Yok',
      one: 'Kullanılabilir 1 Özellik',
      other: 'Kullanılabilir ${totalProperties} Özellik',
    );
  }

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

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

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

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

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

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

  @override
  String get craneFly5 => 'Vitznau, İsviçre';

  @override
  String get craneFly6 => 'Mexico City, Meksika';

  @override
  String get craneFly7 => 'Rushmore Dağı, ABD';

  @override
  String get craneFly8 => 'Singapur';

  @override
  String get craneFly9 => 'Havana, Küba';

  @override
  String get craneFly10 => 'Kahire, Mısır';

  @override
  String get craneFly11 => 'Lizbon, Portekiz';

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

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

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

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

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

  @override
  String get craneSleep3 => 'Havana, Küba';

  @override
  String get craneSleep4 => 'Vitznau, İsviçre';

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

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

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

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

  @override
  String get craneSleep9 => 'Lizbon, Portekiz';

  @override
  String get craneSleep10 => 'Kahire, Mısır';

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

  @override
  String get craneEat0 => 'Napoli, İtalya';

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

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

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

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

  @override
  String get craneEat5 => 'Seul, Güney Kore';

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

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

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

  @override
  String get craneEat9 => 'Madrid, İspanya';

  @override
  String get craneEat10 => 'Lizbon, Portekiz';

  @override
  String get craneFly0SemanticLabel =>
      'Yaprak dökmeyen ağaçların bulunduğu karla kaplı bir arazideki şale';

  @override
  String get craneFly1SemanticLabel => 'Bir arazideki çadır';

  @override
  String get craneFly2SemanticLabel => 'Karlı dağ önünde dua bayrakları';

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

  @override
  String get craneFly4SemanticLabel => 'Su üzerinde bungalovlar';

  @override
  String get craneFly5SemanticLabel => 'Dağların yamacında, göl kenarında otel';

  @override
  String get craneFly6SemanticLabel =>
      'Güzel Sanatlar Sarayı\'nın havadan görünüşü';

  @override
  String get craneFly7SemanticLabel => 'Rushmore Dağı';

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

  @override
  String get craneFly9SemanticLabel => 'Mavi antika bir arabaya dayanan adam';

  @override
  String get craneFly10SemanticLabel =>
      'Gün batımında El-Ezher Camisi\'nin minareleri';

  @override
  String get craneFly11SemanticLabel => 'Denizde tuğla deniz feneri';

  @override
  String get craneFly12SemanticLabel => 'Palmiye ağaçlarıyla havuz';

  @override
  String get craneFly13SemanticLabel => 'Palmiye ağaçlı deniz kenarı havuzu';

  @override
  String get craneSleep0SemanticLabel => 'Su üzerinde bungalovlar';

  @override
  String get craneSleep1SemanticLabel =>
      'Yaprak dökmeyen ağaçların bulunduğu karla kaplı bir arazideki şale';

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

  @override
  String get craneSleep3SemanticLabel => 'Mavi antika bir arabaya dayanan adam';

  @override
  String get craneSleep4SemanticLabel =>
      'Dağların yamacında, göl kenarında otel';

  @override
  String get craneSleep5SemanticLabel => 'Bir arazideki çadır';

  @override
  String get craneSleep6SemanticLabel => 'Palmiye ağaçlarıyla havuz';

  @override
  String get craneSleep7SemanticLabel =>
      'Ribeira Meydanı\'nda renkli apartmanlar';

  @override
  String get craneSleep8SemanticLabel =>
      'Sahilin üst tarafında falezdeki Maya kalıntıları';

  @override
  String get craneSleep9SemanticLabel => 'Denizde tuğla deniz feneri';

  @override
  String get craneSleep10SemanticLabel =>
      'Gün batımında El-Ezher Camisi\'nin minareleri';

  @override
  String get craneSleep11SemanticLabel => 'Taipei 101 gökdeleni';

  @override
  String get craneEat0SemanticLabel => 'Odun fırınında pişmiş pizza';

  @override
  String get craneEat1SemanticLabel => 'Restoran tarzı taburelerle boş bar';

  @override
  String get craneEat2SemanticLabel => 'Burger';

  @override
  String get craneEat3SemanticLabel => 'Kore takosu';

  @override
  String get craneEat4SemanticLabel => 'Çikolatalı tatlı';

  @override
  String get craneEat5SemanticLabel => 'Gösterişli restoran oturma alanı';

  @override
  String get craneEat6SemanticLabel => 'Karides yemeği';

  @override
  String get craneEat7SemanticLabel => 'Fırın girişi';

  @override
  String get craneEat8SemanticLabel => 'Kerevit tabağı';

  @override
  String get craneEat9SemanticLabel => 'Pastalarla kafe tezgahı';

  @override
  String get craneEat10SemanticLabel => 'Büyük pastırmalı sandviç tutan kadın';

  @override
  String get fortnightlyMenuFrontPage => 'Ön Sayfa';

  @override
  String get fortnightlyMenuWorld => 'Dünya';

  @override
  String get fortnightlyMenuUS => 'ABD';

  @override
  String get fortnightlyMenuPolitics => 'Siyaset';

  @override
  String get fortnightlyMenuBusiness => 'İş Dünyası';

  @override
  String get fortnightlyMenuTech => 'Teknoloji';

  @override
  String get fortnightlyMenuScience => 'Bilim';

  @override
  String get fortnightlyMenuSports => 'Spor';

  @override
  String get fortnightlyMenuTravel => 'Seyahat';

  @override
  String get fortnightlyMenuCulture => 'Kültür';

  @override
  String get fortnightlyTrendingTechDesign => 'TechDesign';

  @override
  String get fortnightlyTrendingReform => 'Reform';

  @override
  String get fortnightlyTrendingHealthcareRevolution => 'HealthcareRevolution';

  @override
  String get fortnightlyTrendingGreenArmy => 'GreenArmy';

  @override
  String get fortnightlyTrendingStocks => 'Hisse senetleri';

  @override
  String get fortnightlyLatestUpdates => 'Son Güncellemeler';

  @override
  String get fortnightlyHeadlineHealthcare =>
      'Sessiz, Ancak Güçlü Bir Sağlık Reformu';

  @override
  String get fortnightlyHeadlineWar =>
      'Amerikalıların Savaş Sırasında Bölünmüş Yaşamları';

  @override
  String get fortnightlyHeadlineGasoline => 'Benzinin Geleceği';

  @override
  String get fortnightlyHeadlineArmy => 'Green Army\'yi İçeriden Değiştirme';

  @override
  String get fortnightlyHeadlineStocks =>
      'Hisse Senetleri Piyasası Durgunlaştıkça Çoğu Yatırımcı Dövize Yöneliyor';

  @override
  String get fortnightlyHeadlineFabrics =>
      'Tasarımcılar Modern Fabrikalar İnşa Etmek için Teknolojiden Yararlanıyorlar';

  @override
  String get fortnightlyHeadlineFeminists =>
      'Partizanlıkta Feministler Öne Çıkıyor';

  @override
  String get fortnightlyHeadlineBees => 'Çiftlik Arılarında Azalma';
}
