<p>Turizme tahsis edilen arazilerin tahsis süresinin 49 yıla uzatılması veya satın alınmasını ilişkin yönetmelik Resmi Gazete’de yayımlandı.</p><p><strong>KAMU TAŞINMAZLARI ÜZERİNDEKİ TURİZM YATIRIMLARININ</strong></p><p><strong>SÜRELERİNİN UZATILMASI İLE SATIŞINA İLİŞKİN YÖNETMELİK</strong></p><p><strong>BİRİNCİ BÖLÜM</strong></p><p><strong>Amaç, Kapsam, Dayanak ve Tanımlar</strong></p><p><strong>Amaç</strong></p><p><strong>MADDE 1 –</strong> (1) Bu Yönetmeliğin amacı; ilgili mevzuatı uyarınca kamu taşınmazları üzerinde kıyı yapıları dâhil turizm yatırımı gerçekleştirilmek amacıyla Kültür ve Turizm Bakanlığı, Orman ve Su İşleri Bakanlığı ve Maliye Bakanlığı tarafından yatırımcı ve işletmecilere verilen kesin tahsis, kesin izin, kullanma izni ve irtifak hakkı sürelerinin kırkdokuz yıla uzatılmasına, Orman ve Su İşleri Bakanlığınca milli park ve tabiat parklarında konaklama amaçlı turizm yatırımı gerçekleştirilmek amacıyla yirmidokuz yıla kadar yapılan kira sözleşmelerinin ise yirmidokuzyıla ya da irtifak hakkına dönüştürülmek suretiyle kırkdokuz yıla uzatılmasına, sözleşme bedelinin belirlenmesine, ödeme şekli ve süresine, yatırımcının veya işletmecinin hak ve yükümlülüklerine, sözleşmeye konu alan üzerinde yapılabilecek yapı ve tesislerin nevi ve miktarına ilişkin hususlara ve kesin tahsis yapılan veya irtifak hakkı tesis edilen taşınmazların yatırımcı ve işletmecilerine satılmasına ilişkin usul ve esasları belirlemektir.</p><p><strong>Kapsam</strong></p><p><strong>MADDE 2 –</strong> (1) Bu Yönetmelik; ilgili mevzuatı uyarınca kamu taşınmazları üzerinde Kültür ve Turizm Bakanlığı, Orman ve Su İşleri Bakanlığı ve Maliye Bakanlığı tarafından, kesin tahsis, kesin izin, kullanma izni, kiralama ve irtifak hakkı verilen kıyı yapıları dâhil turizm yatırımlarını kapsar.</p><p><strong>Dayanak</strong></p><p><strong>MADDE 3 –</strong> (1) Bu Yönetmelik, 29/6/2001 tarihli ve 4706 sayılı Hazineye Ait Taşınmaz Malların Değerlendirilmesi ve Katma Değer Vergisi Kanununda Değişiklik Yapılması Hakkında Kanunun geçici 23 üncü maddesine dayanılarak hazırlanmıştır.</p><p><strong>Tanımlar</strong></p><p><strong>MADDE 4 –</strong> (1) Bu Yönetmelikte geçen;</p><p>a) Devletin hüküm ve tasarrufu altındaki yer: Türk Medenî Kanunu ile diğer kanunlarda Devletin hüküm ve tasarrufu altında olduğu belirtilen yerleri,</p><p>b) Hazine taşınmazı: Hazinenin özel mülkiyetindeki taşınmazlar ile Devletin hüküm ve tasarrufu altındaki yerleri,</p><p>c) İdare: İlgili mevzuatı uyarınca bu Yönetmelik kapsamında kalan iş ve işlemleri yapmakla yetkili ve görevli idareyi,</p><p>ç) İrtifak hakkı: Bir taşınmaz üzerinde yararlanmaya ve kullanıma rıza göstermeyi veya mülkiyete ilişkin bazı hakların kullanılmasından vazgeçmeyi kapsayan ve diğer bir taşınmaz veya kişi lehine aynî hak olarak kurulan yükümlülüğü,</p><p>d) Kamu taşınmazı: Orman vasıflı taşınmazlar ile tapuda orman vasfıyla kayıtlı olanlar dâhil Hazine taşınmazlarını,</p><p>e) Kesin izin: Kamu taşınmazı üzerinde turizm yatırımı gerçekleştirilmek amacıyla Orman ve Su İşleri Bakanlığınca yatırımcı ve işletmeciler adına verilen izni,</p><p>f) Kesin tahsis: Kamu taşınmazı üzerinde turizm yatırımı gerçekleştirilmek amacıyla bağımsız ve sürekli nitelikli üst hakları da dâhil olmak üzere irtifak hakkı tesisi veya kullanma izni verilmesi suretiyle Kültür ve Turizm Bakanlığınca yatırımcılar adına kullanma hakkı verilmesini,</p><p>g) Kiralama: 31/8/1956 tarihli ve 6831 sayılı Orman Kanununun ek 8 inci maddesi hükmü uyarınca, 6831 sayılı Orman Kanunu ile 9/8/1983 tarihli ve 2873 sayılı Millî Parklar Kanununa tâbi alanlar üzerinde bulunan yapı ve tesislerin Orman ve Su İşleri Bakanlığınca konaklama amaçlı turizm yatırımı gerçekleştirilmek üzere kiraya verilmesini,</p><p>ğ) Kullanma izni: Devletin hüküm ve tasarrufu altında bulunan yerler üzerinde kişiler lehine Maliye Bakanlığınca verilen izni,</p><p>h) Sözleşme değişikliği: Bu Yönetmelikte belirtilen hakların kurulması dâhil sözleşmeye konu alan üzerinde yapılabilecek yapı ve tesislerin nevi ve miktarına ilişkin olarak yapılacak değişiklikleri,</p><p>ı) Süre uzatımı: Kesin izin, kesin tahsis, kullanma izni ve üst hakkı dâhil irtifak hakkı sürelerinin kırkdokuzyıla, kiralama sürelerinin yirmidokuz yıla ya da irtifak hakkına dönüştürülmek suretiyle kırkdokuz yıla uzatılmasını,</p><p>i) Toplam yatırım maliyeti: Kültür ve Turizm Bakanlığınca yatırım türleri için her yıl belirlenecek birim maliyetlere göre hesaplanacak toplam yatırım tutarını,</p><p>j) Turizm amaçlı kıyı tesisi: Turizm yatırımı kapsamında bulunan veya turizm işletmesi faaliyetinin yapıldığı, münhasıran deniz turizmi araçlarına güvenli bağlama, karaya çekme, bakım, onarım hizmetleri, bu araçlarla gelen yolculara yeme, içme, dinlenme, eğlence, konaklama gibi hizmetlerden birkaçını veya tamamını sunan kruvaziyer gemi limanı, yat limanı, yat çekek yeri gibi turizm tesislerini,</p><p>k) Turizm belgesi: Turizm yatırımı belgesi, turizm işletmesi belgesi veya kısmi turizm işletmesi belgesini,</p><p>l) Turizm işletmecisi: Turizm tesisleri veya kıyı tesislerini işleten gerçek veya tüzel kişiyi,</p><p>m) Turizm tesisi: 10/5/2005 tarihli ve 2005/8948 sayılı Bakanlar Kurulu Kararı ile yürürlüğe konulan Turizm Tesislerinin Belgelendirilmesine ve Niteliklerine İlişkin Yönetmelikte genel nitelikleri ve türleri belirtilen, turizm yatırımı kapsamında bulunan veya turizm işletmesi faaliyetinin yapıldığı tesisleri ve bunların ayrıntıları ile tamamlayıcı unsurlarını,</p><p>n) Turizm yatırımcısı: İlgili mevzuatı uyarınca kıyı yapıları dâhil turizm yatırımı gerçekleştirilmek amacıyla kesin tahsis, kesin izin, irtifak hakkı, kullanma izni veya kiralama yapılmak suretiyle İdare tarafından adına kamu taşınmazı tahsis edilen gerçek veya tüzel kişiyi,</p><p>o) Turizm yatırımı: Kamu taşınmazı üzerinde turizm tesisi veya turizm amaçlı kıyı tesisi gerçekleştirilmek amacıyla yapılan yatırımları,</p><p>ö) Yararlanma bedeli: Süre uzatımı yapılması nedeniyle mevcut sözleşme hükümleri uyarınca tahsil edilen bedelden ayrı ve buna ek olarak İdarece bir defaya mahsus olmak üzere alınacak bedeli,</p><p>ifade eder.</p><p><strong>İKİNCİ BÖLÜM</strong></p><p><strong>Yararlanma Şartları, Başvuru ve Başvurunun Değerlendirilmesi</strong></p><p><strong>Yararlanma şartları</strong></p><p><strong>MADDE 5 –</strong> (1) Turizm yatırımcısı ve işletmecisi tarafından süre uzatımı veya sözleşme değişikliğinden yararlanılabilmesi ya da satın alma talebinde bulunulabilmesi için, başvuru tarihi itibariyle;</p><p>a) 12/3/1982 tarihli ve 2634 sayılı Turizmi Teşvik Kanunu, 21/7/2006 tarihli ve 26235 sayılı Resmî Gazete’de yayımlanan Kamu Taşınmazlarının Turizm Yatırımlarına Tahsisi Hakkında Yönetmelik ve işlemin yapıldığı tarihte geçerli olanlar dâhil (mülga Kamu Arazisinin Turizm Yatırımlarına Tahsisi Hakkında Yönetmelik vb.) diğer ilgili mevzuatı uyarınca üzerinde turizm yatırımı yapılmak üzere Kültür ve Turizm Bakanlığınca adlarına kamu taşınmazının kesin tahsisinin yapılması veya bu kesin tahsise dayanılarak Maliye Bakanlığı tarafından lehlerine irtifak hakkı tesis edilmiş veya adlarına kullanma izni verilmiş olması ve kesin tahsis işlemlerinin İdare nezdinde halen geçerliliğini koruması ve iptal edilmemiş olması,</p><p>b) 6831 sayılı Orman Kanunu, 2873 sayılı Milli Parklar Kanunu ile 18/4/2014 tarihli ve 28976 sayılı Resmî Gazete’de yayımlanan Orman Kanununun 17/3 ve 18 inci Maddelerinin Uygulama Yönetmeliği ve 12/12/1986 tarihli ve 19309 sayılı Resmî Gazete’de yayımlanan Milli Parklar Yönetmeliği ile işlemin yapıldığı tarihte geçerli olanlar dâhil (mülga 6831 sayılı Orman Kanununun 16, 17, 18 ve 115 inci Maddeleri Gereğince Yapılacak Arazi Tahsisleri ve Verilecek İzinlere Ait Yönetmelik, Orman Arazilerinin Tahsisi Hakkında Yönetmelik, Orman Sayılan Alanlarda Verilecek İzinler Hakkında Yönetmelik, Orman Kanununun 17 ve 18 inci Maddelerinin Uygulama Yönetmeliği, Milli Parkların Ayrılma, Planlama Uygulama ve Yönetimine Ait Yönetmelik vb.) diğer ilgili mevzuat hükümleri uyarınca ormanlık alanlar üzerinde turizm yatırımı yapılmak amacıyla Orman ve Su İşleri Bakanlığınca adlarına kesin izin verilmiş olması veya bu kesin izne dayanılarak Maliye Bakanlığı tarafından lehlerine irtifak hakkı tesis edilmiş veya adlarına kullanma izni verilmiş olması ve kesin izin işlemlerinin İdare nezdinde halen geçerliliğini koruması ve iptal edilmemiş olması,</p><p>c) 6831 sayılı Orman Kanunu ve 2873 sayılı Milli Parklar Kanunu ile Milli Parklar Yönetmeliği ile işlemin yapıldığı tarihte geçerli olanlar dâhil (Milli Parkların Ayrılma, Planlama Uygulama ve Yönetimine Ait Yönetmelik vb.) diğer ilgili mevzuat hükümleri uyarınca 6831 sayılı Orman Kanunu ve 2873 sayılı Milli Parklar Kanununa tâbi alanlar üzerinde bulunan yapı ve tesislerin konaklama amaçlı turizm yatırımı gerçekleştirmek veya işlettirilmek üzere Orman ve Su İşleri Bakanlığınca kiralama yapılmış olması ve kiralama işlemlerinin İdare nezdinde halen geçerliliğini koruması ve iptal edilmemiş olması,</p><p>ç) 8/9/1983 tarihli ve 2886 sayılı Devlet İhale Kanunu, 4706 sayılı Hazineye Ait Taşınmaz Malların Değerlendirilmesi ve Katma Değer Vergisi Kanununda Değişiklik Yapılması Hakkında Kanun, 29/1/2004 tarihli ve 5084 sayılı Yatırımların ve İstihdamın Teşviki ile Bazı Kanunlarda Değişiklik Yapılması Hakkında Kanun, 19/6/2007 tarihli ve 26557 sayılı Resmî Gazete’de yayımlanan Hazine Taşınmazlarının İdaresi Hakkında Yönetmelik ve işlemin yapıldığı tarihte geçerli olanlar dâhil (mülga Devlete Ait Taşınmaz Mal Satış, Trampa, Kiraya Verme, Mülkiyetin Gayri Aynî Hak Tesis, Ecrimisil ve Tahliye Yönetmeliği, vb.) diğer ilgili mevzuatı uyarınca üzerinde turizm yatırımı yapılmak üzere Hazine taşınmazları üzerinde Maliye Bakanlığınca lehlerine irtifak hakkı tesis edilmiş veya adlarına kullanma izni verilmiş olması ve irtifak hakkı veya kullanma izni sözleşmelerinin İdare nezdinde halen geçerliliğini koruması ve iptal veya tapudan terkin edilmemiş olması,</p><p>d) 8/6/1994 tarihli ve 3996 sayılı Bazı Yatırım ve Hizmetlerin Yap-İşlet-Devret Modeli Çerçevesinde Yaptırılması Hakkında Kanun hükümleri uyarınca Hazine taşınmazları üzerinde turizm yatırımı yapılmak amacıyla Maliye Bakanlığınca lehlerine irtifak hakkı tesis edilmiş veya adlarına kullanma izni verilmiş olması ve irtifak hakkı veya kullanma izni sözleşmelerinin İdare nezdinde halen geçerliliğini koruması ve iptal veya tapudan terkin edilmemiş olması,</p><p>e) Bu fıkra uyarınca adına kamu taşınmazı tahsis edilen turizm yatırımcıları ve işletmecilerinin bu kesin tahsis, kesin izin, irtifak hakkı veya kullanma izni ya da kiralama işleminden dolayı ilgili idareler aleyhine açılan ve halen devam eden davalardan tüm yargılama giderleri üstlenilerek kayıtsız ve şartsız olarak feragat edilmesi ve bunlara ilişkin olarak ödenmesi gereken borcunun bulunmaması,</p><p>şarttır.</p><p>(2) Birinci fıkrada belirtilen yatırımcı veya işletmeciler adına Kültür ve Turizm Bakanlığı tarafından düzenlenen ve halen geçerli olan (Kültür ve Turizm Bakanlığı tarafından belgesi iptal edilmesine rağmen, yeni belge alması için ilgili idarece süre verilen ve süresi henüz dolmayanlar dâhil) turizm belgesine sahip olmaları gerekir. Ancak, adına kiralama yapılan yatırımcı ve işletmeciler ile turizm amaçlı kıyı tesisi yatırımcı ve işletmecileri için turizm belgesi şartı aranmaz.</p><p><strong>Başvuru</strong></p><p><strong>MADDE 6 – </strong>(1) Süre uzatımından veya sözleşme değişikliğinden faydalanabilmek için turizm yatırımcılarından;</p><p>a) Kültür ve Turizm Bakanlığı tarafından adlarına kesin tahsis yapılan veya bu kesin tahsise dayanılarak lehlerine Maliye Bakanlığı tarafından irtifak hakkı tesis edilen veya adlarına kullanma izni verilenlerin Kültür ve Turizm Bakanlığına,</p><p>b) Orman ve Su İşleri Bakanlığı tarafından adlarına kesin izin verilen veya bu kesin izne dayanılarak lehlerine Maliye Bakanlığı tarafından irtifak hakkı tesis edilen veya adlarına kullanma izni verilenlerin Orman ve Su İşleri Bakanlığına,</p><p>c) Orman ve Su İşleri Bakanlığı tarafından adlarına kiralama yapılanların Orman ve Su İşleri Bakanlığına,</p><p>ç) Maliye Bakanlığı tarafından lehlerine irtifak hakkı tesis edilen veya adlarına kullanma izni verilenlerin Maliye Bakanlığına,</p><p>d) 3996 sayılı Kanun kapsamında turizm amaçlı kıyı tesisi yapılmak amacıyla Maliye Bakanlığı tarafından lehlerine irtifak hakkı tesis edilen veya adlarına kullanma izni verilenlerin Ulaştırma, Denizcilik ve Haberleşme Bakanlığına,</p><p>5/12/2018 tarihine kadar başvurmaları gerekmektedir.</p><p>(2) Ayrıca kesin tahsis yapılan veya irtifak hakkı tesis edilen taşınmazlar için aynı süre içerisinde Maliye Bakanlığına satın alma başvurusunda bulunulması gerekmektedir.</p><p><strong>Başvurunun değerlendirilmesi</strong></p><p><strong>MADDE 7 –</strong> (1) Süre uzatımından veya sözleşme değişikliğinden faydalanma başvurusu, ilgili idare tarafından turizm yatırımcısının bu Yönetmelikte yer alan koşul ve şartları taşıyıp taşımadığı hususu da dikkate alınmak suretiyle ilgili mevzuatı ve mevcut kesin tahsis koşulları, kesin izin taahhüt senedi ile irtifak hakkı, kullanma izni ve kiralama sözleşmeleri çerçevesinde ve resen göz önünde bulundurulacak diğer hususlarla birlikte başvuru tarihinden itibaren en geç 3 ay içerisinde değerlendirilir.</p><p>(2) Yapılan değerlendirme sonucunda;</p><p>a) Başvurunun uygun görülmesi halinde, başvurunun uygun görüldüğü ile buna ilişkin olarak yerine getirilmesi istenilen yükümlülükler ve kesin izin, kesin tahsis, kiralama, irtifak hakkı, kullanma izni koşulları başvuru sahibi turizm yatırımcısına,</p><p>b) İrtifak hakkı ve kullanma izni sözleşmelerinde süre uzatımı veya sözleşme değişikliklerinin yapılabilmesi amacıyla da gerekli bilgi ve belgeler ile koşullar ayrıca Maliye Bakanlığına,</p><p>c) Turizm yatırımcısının şartları taşımadığının anlaşılması veya başvurunun uygun görülmemesi halinde bu durum başvuru sahibi turizm yatırımcısına,</p><p>bildirilir.</p><p>(3) Satın alma başvuruları 13 üncü madde hükümleri uyarınca Maliye Bakanlığınca değerlendirilir.</p><p><strong>ÜÇÜNCÜ BÖLÜM</strong></p><p><strong>Uzatılacak Süre, Sözleşme Değişikliği, Yararlanma ve Sözleşme Bedeli,</strong></p><p><strong>Ödeme Şekli ve Süresi ile Tesislerin Yenilenmesi</strong></p><p><strong>Uzatılacak süre</strong></p><p><strong>MADDE 8 –</strong> (1) İlgili idare tarafından turizm yatırımcısına verilen;</p><p>a) Kesin tahsis, kesin izin, irtifak hakkı veya kullanma izni süresinin kalan kısmının, süre uzatımının yapılacağı tarih itibariyle kırkdokuz yıla olan farkı kadar süre,</p><p>b) Kiralama süresinin kalan kısmının, kiralama olarak devam edilmesi durumunda süre uzatımının yapılacağı tarih itibariyle yirmidokuz yıla olan farkı kadar süre, kiralama işleminin irtifak hakkına dönüştürülmesi durumunda ise süre uzatımının yapılacağı tarih itibariyle kırkdokuz yıla olan farkı kadar süre,</p><p>uzatılacak süre olarak tespit edilir.</p><p><strong>Sözleşme değişikliği talepleri</strong></p><p><strong>MADDE 9 –</strong> (1) Kesin tahsis, kesin izin, kullanma izni verilen ya da irtifak hakkı tesis edilen turizm yatırımcıları tarafından sadece sözleşme değişikliği talebinde bulunulması durumunda söz konusu talep, idareler tarafından ilgili mevzuat hükümleri çerçevesinde değerlendirilerek sonuçlandırılır.</p><p>(2) Turizm Tesislerinin Belgelendirilmesine ve Niteliklerine İlişkin Yönetmelik kapsamında Kültür ve Turizm Bakanlığınca turizm işletmesi belgesi düzenlenmesi, tahsis süresiyle sınırlı olmak ve ana tesisle birlikte işletilmek şartıyla sözleşme değişikliği taleplerinde; orman vasıflı taşınmazlar ile tapuda orman vasfıyla kayıtlı olanlar hariç kamu taşınmazları üzerine bağımsız ve sürekli nitelikli olarak tescil edilen hak üzerinde kat mülkiyeti veya kat irtifakı tesis edilebilir. Bu durumda tesisin kat mülkiyeti veya kat irtifakına konu edilen kısmının son tür, sınıf ve kapasitesi üzerinden işlemin yapılacağı yıl itibariyle belirlenen toplam yatırım maliyet bedelinin yüzde onu tutarında ilave yararlanma bedeli alınır ve bu bedel 11 inci madde hükümlerine göre tahsil edilir.</p><p>(3) Sözleşme değişikliği ve süre uzatımına ilişkin işlemin birlikte talep edilmesi halinde, sözleşme değişiklik bedeli ile yararlanma bedeli gerçekleştirilmesi planlanan tesisin son tür, sınıf ve kapasitesi üzerinden belirlenir. Tesisin tür, sınıf veya kapasitesinin düşürülmesi durumunda bu madde uyarınca hesaplanan bedellerde indirime gidilmez, tahsil edilenler iade edilmez.</p><p><strong>Yararlanma ve sözleşme bedelinin tespiti</strong></p><p><strong>MADDE 10 – </strong>(1) Yararlanma bedeli, tesisin ilgili idare tarafından uygun görülen veya turizm belgesine esas son tür, sınıf ve kapasitesi üzerinden cari yıl için belirlenen toplam yatırım maliyet bedelinin turizm tesisleri için peşin ödeme halinde binde dördü, taksitle ödeme halinde ise binde beşi, termal ve kış turizmi amaçlı turizm tesisleri için ise bu oranların yarısı ile uzatılan sürenin çarpımı suretiyle hesaplanır. Ancak hesaplanan bu bedel, mevcut sözleşme bedeli uyarınca hesaplanan cari yıl bedelinden az olamaz.</p><p>(2) Orman ve Su İşleri Bakanlığınca milli park ve tabiat parklarında yapılan konaklama amaçlı kiralamaların irtifak hakkına dönüştürülmek suretiyle kırk dokuz yıla uzatılmasında ise yararlanma bedeli; birinci fıkra uyarınca turizm tesisleri için belirlenen oranın yüzde yirmi beş fazlası üzerinden hesaplanır.</p><p>(3) Süre uzatımı yapılması halinde, turizm tesisleri ile 2886 sayılı Kanun ve 6831 sayılı Kanun kapsamında kalan turizm amaçlı kıyı tesislerinde mevcut kesin tahsis, kesin izin, kullanma izni, kiralama veya irtifak hakkı süresine uzatılacak sürenin eklenmesiyle yeni sözleşme süresi belirlenir ve sözleşmelerin süre uzatımına ilişkin maddelerinde; süre uzatımına ilişkin olarak ilgili idare tarafından belirlenen tüm yükümlülüklerin yerine getirileceğine ilişkin hususlar da belirtilmek suretiyle gerekli değişiklikler yapılır.</p><p>(4) Belirlenen sözleşme süresi boyunca mevcut sözleşme veya kesin izin/tahsis koşullarında belirtilen bedel ve oranlar üzerinden kesin izin, kesin tahsis, irtifak hakkı, kullanma izni veya kira bedeli ile hasılat payı alınmasına devam edilir.</p><p>(5) Ancak, 3996 ve 2634 sayılı Kanunlar kapsamında turizm amaçlı kıyı tesisi yapılmak amacıyla tesis edilen irtifak hakları veya verilen kullanma izinlerine ilişkin düzenlenecek yeni sözleşmelerde sözleşme bedeli, kullanma izni veya irtifak hakkı süresinin kalan kısmı için mevcut sözleşme hükümlerine göre tahsil edilmeye devam edilir. Turizm amaçlı kıyı tesislerinde yararlanma bedeli ve 3996 ve 2634 sayılı Kanunlar kapsamında turizm amaçlı kıyı tesislerinde uzatılan süre için sözleşme bedeli tesisin; bulunduğu yer, kapasitesi, sunduğu hizmet çeşitliliği, fiziksel konumu, yüzölçümü, geri saha ve kullanım durumu, toplam yatırım maliyeti, mevcut sözleşme bedeli, getirebileceği gelir miktarı ile günün emsal ve rayiçleri de göz önünde bulundurulmak suretiyle Ulaştırma, Denizcilik ve Haberleşme Bakanlığı tarafından belirlenir. Uzatılacak sürenin başlangıç yılı bedeli, bu fıkra kapsamında belirlenen sözleşme bedelinin Türkiye İstatistik Kurumunca yayımlanan Yurt İçi Üretici Fiyat Endeksi (Yİ-ÜFE – bir önceki yılın aynı ayına göre yüzde değişim) oranında her yıl güncellenmesi suretiyle hesaplanır. Uzatılan süre için taşınmazların üzerinde yer alan tesislerin işletilmesinden elde edilen toplam yıllık hasılattan yüzde bir oranında pay alınacağına ilişkin sözleşmelerine hüküm konulur.</p><p>(6) Turizm yatırımcısının, süre uzatımı yapıldıktan sonra tesisin tür, sınıf veya kapasitesinde herhangi bir artış gerçekleştirmesi halinde ilave yararlanma bedeli; uzatma işleminin tesis edildiği tarihten itibaren kalan uzatma süresi, artan tür, sınıf veya kapasiteye ilişkin olarak işlemin yapılacağı yıl itibariyle belirlenen toplam yatırım maliyet bedeli ile birinci fıkra uyarınca belirlenen oranın çarpımı suretiyle hesaplanır.</p><p>(7) Turizm amaçlı kıyı tesislerinde ise ilave yararlanma bedeli; yıllık uzatma bedelinin yat başı birim tutarının Türkiye İstatistik Kurumunca yayımlanan Yurt İçi Üretici Fiyat Endeksi (Yİ-ÜFE – bir önceki yılın aynı ayına göre yüzde değişim) oranında her yıl güncellenen değeri ile artan kapasite ve uzatma işleminin tesis edildiği tarihten itibaren kalan uzatma süresiyle çarpımı suretiyle hesaplanır.</p><p>(8) Tesisin tür, sınıf veya kapasitesinin düşürülmesi durumunda bu madde uyarınca hesaplanan bedellerde indirime gidilmez, tahsil edilenler iade edilmez.</p><p>(9) Hesaplanan ilave yararlanma bedelleri 11 inci madde hükümlerine göre tahsil edilir.</p><p><strong>Yararlanma bedelinin ödenme şekli ve süresi</strong></p><p><strong>MADDE 11 –</strong> (1) Yararlanma bedeli, peşin veya taksitle ödenebilir. Taksitle ödemenin talep edilmesi halinde yararlanma bedeli biri peşin olmak üzere dört eşit taksitle ve birer yıllık dilimler halinde, taksitlere kanunî faiz uygulanmak suretiyle ödenir.</p><p>(2) Başvuru yapan turizm yatırımcısı tarafından, kesin izin taahhüt senedi, kamu taşınmazı kesin tahsis belgesi, irtifak hakkı senedi, kullanma izni veya kira sözleşmesi düzenlenmeden önce; peşin ödemede yararlanma bedelinin tamamı, taksitli ödemede ise yararlanma bedelinin yüzde yirmi beşi ilgili idarenin hesaplarına yatırılır.</p><p>(3) Vadesinde ödenmeyen taksit tutarlarına 21/7/1953 tarihli ve 6183 sayılı Amme Alacaklarının Tahsil Usulü Hakkında Kanunun 51 inci maddesine göre belirlenen oranda gecikme faizi uygulanır. Üst üste iki taksitin ödenmemesi durumunda, turizm yatırımcısına borcunu ödeme tarihine kadar tahakkuk edecek gecikme faizi ile birlikte 15 gün içinde ödemesi, aksi takdirde kesin izin, kesin tahsis, kullanma izni, irtifak hakkı veya kiralama sözleşmesinin uzatma işlemine ilişkin kısmının iptal edileceği bildirilir.</p><p>(4) Yapılan bildirim üzerine de borcun ödenmemesi halinde ise ilgili idare tarafından kesin izin, kesin tahsis, kullanma izni, irtifak hakkı veya kiralama sözleşmesinin uzatma işlemine ilişkin kısmı iptal edilir. Tahsil edilmiş olan yararlanma bedelinin, uzatılan sürenin geçen kısmı ile varsa sözleşmeden doğan diğer borçlarına mahsup edilmesi sonucu geriye kalan kısmı iptal işleminin gerçekleştirilmesine müteakip faizsiz olarak iade edilir.</p><p>(5) Kesin tahsisin, kesin iznin, irtifak hakkının, kullanma izninin veya kiralama sözleşmesinin süresinin bitmesi veya herhangi bir sebeple süresinden önce sona ermesi ya da dördüncü fıkrada belirtilen gerekçe dışındaki bir sebeple iptal edilmesi halinde tahsil edilen yararlanma bedeli iade edilmez, varsa kalan taksit ve kanuni faizleri yasal yollara da başvurulmak suretiyle tahsil edilir. Bundan dolayı turizm yatırımcısı ve işletmecisi veya üçüncü kişilerce herhangi bir hak ve talepte bulunulamaz.</p><p>(6) Sözleşmenin devri halinde ise yararlanma bedeline ilişkin kalan taksitlerin tamamı peşin ödenir ya da sözleşmeyi devralan gerçek veya tüzel kişiden, kalan taksit ve kanuni faizlerinin düzenlenen ödeme planı çerçevesinde ödeneceğine ilişin noter onaylı taahhütname alınır.</p><p><strong>Tesislerin yenilenmesi halinde yararlanma bedelinin ödeme şekli ve süresi ile yükümlülükler</strong></p><p><strong>MADDE 12 –</strong> (1) Turizm yatırımcısı tarafından yeni sözleşme tarihinden itibaren en fazla dört yıl içerisinde turizm tesisinin tamamının yıkılarak yeniden inşa edilmesinin taahhüt edilmesi ve aynı süre içerisinde Kültür ve Turizm Bakanlığından turizm işletme belgesi alınması halinde, peşin ödemede yararlanma bedelinin yüzde yirmi beşi, taksitli ödemede ise son taksiti turizm işletme belgesi alınmasını müteakip yatırımcının sözleşmesinden doğan mevcut veya ileride doğacak borçlarına mahsup edilir.</p><p>(2) Kamu taşınmazı üzerinde yer alan tesisin tamamının veya bir kısmının yıkılması halinde turizm yatırımcısından, bahsi geçen yapıların mevcut değeri kadar teminat mektubu alınır ayrıca bunların yıkılması sonrasında yerlerine yapılacak yeni bina ve tesislerin değerinin yıkılan yapılardan az olmayacağı, herhangi bir nedenle bunların değerinin yıkılacak yapıların değerinden az olması durumunda aradaki farkın Hazineye ödeneceğine ilişkin olarak da noter onaylı taahhütname alınır.</p><p>(3) Yeni yapılan tesisin değerinin yıkılan tesisten daha az olması halinde aradaki fark teminat mektubu paraya çevrilmek suretiyle tahsil edilir.</p><p>(4) İdarece verilen süre içerisinde yıkılan tesisin yerine yeni tesislerin yapılmaması veya yapılamaması halinde alınan teminat mektubu paraya çevrilmek suretiyle idareye irat kaydedilir ve ayrıca kesin tahsis, kesin izin, kullanma izni, irtifak hakkı ve kiralama sözleşmesi iptal edilir.</p><p><strong>DÖRDÜNCÜ BÖLÜM</strong></p><p><strong>Satış ve Satış Bedelinin Tespiti, Ödeme Şekli ve Süresi ile Diğer Hususlar</strong></p><p><strong>Satış ve satış bedelinin tespiti ile ödeme şekli ve süresi</strong></p><p><strong>MADDE 13 –</strong> (1) Kesin tahsis yapılan veya irtifak hakkı tesis edilen taşınmazlardan tapuda Hazine adına kayıtlı olanlar dâhil orman vasıflı taşınmazlar ile 3621 sayılı Kıyı Kanununa göre kıyıda kalan yerler hariç olmak üzere ilgili mevzuat hükümleri ile taşınmazın hukuki ve fiili durumu itibariyle satışında engel bulunmayanlardan idarece uygun görülen taşınmazlar, turizm yatırımı amaçlı kullanılmaya devam edilmesi kaydıyla yatırımcı ve işletmecilere satılabilir.</p><p>(2) Satış bedeli, taşınmazın zemininin rayiç değeri ile üzerindeki yapı, bina ve tesislerin Hazineye geçmesi gereken kısmının enkaz bedeli üzerinden tespit edilir. Ancak, yatırımcı tarafından satış işleminin gerçekleştiği tarihten itibaren beş yıl içerisinde tesisin tamamının yıkılıp yeniden inşa edilmesinin taahhüt edilmesi halinde satış bedeline yüzde yirmi beş oranında indirim uygulanır. Süresi içerisinde tesisin yenilenmemesi halinde ise satış bedeline yapılan indirim satış tarihinden itibaren hesaplanacak gecikme faiziyle birlikte tahsil edilir.</p><p>(3) İkinci fıkra uyarınca tespit edilecek satış bedeli, peşin veya en az yüzde otuzu peşin, kalanı beş yılda, on taksitle ve kanunî faizi ile birlikte taksitle de ödenebilir.</p><p>(4) Satışı gerçekleştirilen taşınmazların tapu kütüğüne taşınmazın turizm amacı dışında kullanılamayacağına ilişkin belirtme konulur.</p><p>(5) Bu maddede belirtilenler dışında satışa ilişkin diğer hususlarda 29/6/2001 tarihli ve 4706 sayılı Hazineye Ait Taşınmaz Malların Değerlendirilmesi ve Katma Değer Vergisi Kanununda Değişiklik Yapılması Hakkında Kanuna göre işlem tesis edilir.</p><p><strong>Diğer hususlar</strong></p><p><strong>MADDE 14 –</strong> (1) Bu Yönetmelikte düzenlenen hususlar dışında kesin tahsis, kesin izin, kullanma izni, irtifak hakkı ve kiralama işlemlerine ilişkin olarak ilgisine göre; 12/3/1982 tarihli ve 2634 sayılı Turizmi Teşvik Kanunu ve 21/7/2006 tarihli ve 26235 sayılı Resmî Gazete’de yayımlanan Kamu Taşınmazlarının Turizm Yatırımlarına Tahsisi Hakkında Yönetmelik, 31/8/1956 tarihli ve 6831 sayılı Orman Kanunu, 9/8/1983 tarihli ve 2873 sayılı Milli Parklar Kanunu ile 18/4/2014 tarihli ve 28976 sayılı Resmî Gazete’de yayımlanan Orman Kanununun 17/3 ve 18 inci Maddelerinin Uygulama Yönetmeliği ve 12/12/1986 tarihli ve 19309 sayılı Resmî Gazete’de yayımlanan Milli Parklar Yönetmeliği, 8/9/1983 tarihli ve 2886 sayılı Devlet İhale Kanunu, 29/6/2001 tarihli ve 4706 sayılı Hazineye Ait Taşınmaz Malların Değerlendirilmesi ve Katma Değer Vergisi Kanununda Değişiklik Yapılması Hakkında Kanun, 5084 sayılı Yatırımların ve İstihdamın Teşviki ile Bazı Kanunlarda Değişiklik Yapılması Hakkında Kanun, 19/6/2007 tarihli ve 26557 sayılı Resmî Gazete’de yayımlanan Hazine Taşınmazlarının İdaresi Hakkında Yönetmelik, 8/6/1994 tarihli ve 3996 sayılı Bazı Yatırım ve Hizmetlerin Yap-İşlet-Devret Modeli Çerçevesinde Yaptırılması Hakkında Kanun ile mevcut kesin tahsis ve kesin izin koşulları kullanma izni irtifak hakkı ve kiralama sözleşmelerinde yer alan hükümler uyarınca işlem tesis edilmeye devam edilir.</p><p>(2) Düzenlenecek sözleşmelere, süre uzatımına ilişkin olarak ilgili idare tarafından belirlenen tüm yükümlülüklerin yerine getirileceği yararlanma bedelinin ödeneceği ile bunların yerine getirilmemesi halinde kesin tahsis, kesin izin, kullanma izni, irtifak hakkı veya kiralama işleminin uzatma işlemine ilişkin kısmının iptal edileceğine ilişkin hüküm konulur.</p><p><strong>Yürürlük</strong></p><p><strong>MADDE 15 –</strong> (1) Maliye Bakanlığı, Kültür ve Turizm Bakanlığı, Orman ve Su İşleri Bakanlığı ile Ulaştırma, Denizcilik ve Haberleşme Bakanlığı tarafından müştereken belirlenen bu Yönetmelik yayımı tarihinde yürürlüğe girer.</p><p><strong>Yürütme</strong></p><p><strong>MADDE 16 –</strong> (1) Bu Yönetmelik hükümlerini Maliye Bakanı yürütür.</p>