diff --git a/erpnext/translations/tr.csv b/erpnext/translations/tr.csv
index dfb507a..047ef85 100644
--- a/erpnext/translations/tr.csv
+++ b/erpnext/translations/tr.csv
@@ -1,49 +1,49 @@
- (Half Day), (Half Day)
- and year: , and year: 
-""" does not exists","""Mevcut değildir"
-%  Delivered,% Ulaştırıldı
-% Amount Billed,%Faturalı Tutar
-% Billed,% Faturalı
-% Completed,% Tamamlandı
-% Delivered,% Teslim Edildi
-% Installed,% Yüklendi
+ (Half Day), (Yarım Gün)
+ and year: ,ve yıl
+""" does not exists","""Mevcut Değildir"
+%  Delivered,% Teslim Edilen
+% Amount Billed,% Faturalanan Tutar
+% Billed,% Faturalanan
+% Completed,% Tamamlanan
+% Delivered,% Teslim Edilen
+% Installed,% Montajlanan
 % Received,% Alınan
-% of materials billed against this Purchase Order.,% Malzemeler bu Satınalma Siparişina göre faturalandırılır.
-% of materials billed against this Sales Order,% Malzemeler bu Satış Siparişine göre faturalandırılır
-% of materials delivered against this Delivery Note,% Bu İrsaliyeye göre teslim edilen malzeme
-% of materials delivered against this Sales Order,% Bu Satış Siparişine göre teslim edilen malzeme
-% of materials ordered against this Material Request,Bu Malzeme Request karşı emretti malzemelerin%
-% of materials received against this Purchase Order,% Malzemelerin bu Satınalma Siparişi karşı alınan
+% of materials billed against this Purchase Order.,"Malzeme%, bu Satın Alma Emri karşılığı faturalandı"
+% of materials billed against this Sales Order,"Malzeme%, bu Satış Emri karşılığı faturalandı"
+% of materials delivered against this Delivery Note,"Malzemelerin%, bu İrsaliye karşılığı teslim edildi"
+% of materials delivered against this Sales Order,"Malzemelerin%, bu Satış Emri karşılığı teslim edildi"
+% of materials ordered against this Material Request,"Malzemelerin%, bu Malzeme Talebi karşılığı sipariş edildi"
+% of materials received against this Purchase Order,"Malzemelerin%, bu Satın Alma Emri karşılığı teslim alındı"
 'Actual Start Date' can not be greater than 'Actual End Date',"'Fiili Başlangıç ​​Tarihi', 'Gerçek Bitiş Tarihi' den büyük olamaz"
-'Based On' and 'Group By' can not be same,'Dayalı' ve 'Grup tarafından' aynı olamaz
-'Days Since Last Order' must be greater than or equal to zero,'Son Sipariş yana Gün' den büyük veya sıfıra eşit olmalıdır
-'Entries' cannot be empty,'Yazılar' boş olamaz
+'Based On' and 'Group By' can not be same,'Dayalıdır' ve 'Grubundadır' aynı olamaz
+'Days Since Last Order' must be greater than or equal to zero,'Son Siparişten bu yana geçen süre' sıfırdan büyük veya sıfıra eşit olmalıdır
+'Entries' cannot be empty,'Girdiler' boş olamaz
 'Expected Start Date' can not be greater than 'Expected End Date',"'Beklenen Başlangıç ​​Tarihi', 'Beklenen Bitiş Tarihi' den büyük olamaz"
-'From Date' is required,'Date' gereklidir
-'From Date' must be after 'To Date','Tarihten itibaren' Tarihi 'sonra olmalıdır
-'Has Serial No' can not be 'Yes' for non-stock item,'Seri No Has' non-stok kalemi için 'Evet' olamaz
-'Notification Email Addresses' not specified for recurring invoice,Faturayı yinelenen için belirlenen 'Bildirim E-posta Adresleri'
-'Profit and Loss' type account {0} not allowed in Opening Entry,'Kar ve Zarar' tipi hesap {0} kaydı Açılış izin yok
-'To Case No.' cannot be less than 'From Case No.','Dava No To' 'Dava No Kimden' den az olamaz
-'To Date' is required,'Tarihi' gereklidir
-'Update Stock' for Sales Invoice {0} must be set,Satış Fatura için 'Güncelle Stok' {0} ayarlanması gerekir
-* Will be calculated in the transaction.,* Işlem hesaplanır olacak.
-1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent
-1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. To maintain the customer wise item code and to make them searchable based on their code use this option
-"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Ekle / Düzenle </ a>"
-"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Ekle / Düzenle </ a>"
-"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Ekle / Düzenle </ a>"
-"<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>","<h4> Standart Şablon </ h4>  <p> <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja Şablon Oluşturma </ a> ve Adres tüm alanları (kullanır Özel alanlar varsa) dahil olmak üzere mevcut olacaktır </ p>  <pre> <code> {{}} address_line1 <br>  {% if address_line2%} {{}} address_line2 <br> { % endif -%}  {{şehir}} <br>  {% eğer devlet%} {{}} devlet <br> {% endif -%}  {% if pinkodu%} PIN: {{}} pinkodu <br> {% endif -%}  {{ülke}} <br>  {% if telefon%} Telefon: {{}} telefon <br> { % endif -%}  {% if%} faks Faks: {{}} faks <br> {% endif -%}  {% email_id%} E-posta ise: {{}} email_id <br> ; {% endif -%}  </ code> </ pre>"
+'From Date' is required,'Tarihten itibaren' gereklidir
+'From Date' must be after 'To Date','Tarihten itibaren' Tarihine Kadardan'sonra olmalıdır
+'Has Serial No' can not be 'Yes' for non-stock item,'Seri No' Stokta olmayan Malzeme için 'Evet' olamaz
+'Notification Email Addresses' not specified for recurring invoice,Yinelenen fatura için 'Bildirim E-mail Adresleri' belirtilmemiştir
+'Profit and Loss' type account {0} not allowed in Opening Entry,'Kar ve Zarar' tipi hesaba {0} izin verilmez
+'To Case No.' cannot be less than 'From Case No.','Ambalaj No' ya Kadar 'Ambalaj Nodan İtibaren'den az olamaz
+'To Date' is required,'Tarihine Kadar' gereklidir
+'Update Stock' for Sales Invoice {0} must be set,Satış Faturası {0} için 'Stok Güncelleme' ayarlanmalıdır
+* Will be calculated in the transaction.,* İşlemde hesaplanacaktır.
+1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 Döviz = [?] Kesir Örneğin 1 USD = 100 Cent gibi
+1. To maintain the customer wise item code and to make them searchable based on their code use this option,1.Müşteriye bilgilendirme sağlamak için Malzeme kodu ve bu seçenek kullanılarak onları kodları ile araştırılabilir yapmak
+"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Satış Arama/Müşteri Grubu""> Ekle / Düzenle </a>"
+"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Satış Arama/Ürün Grubu""> Ekle / Düzenle </a>"
+"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Satış Arama/Bölge> Ekle / Düzenle </a>"""
+"<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>","<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>"
 A Customer Group exists with same name please change the Customer name or rename the Customer Group,Aynı adda bir Müşteri Grubu bulunmaktadır. Lütfen Müşteri Grubu ismini değiştirin.
 A Customer exists with same name,Bir Müşteri aynı adla
 A Lead with this email id should exist,Bu e-posta sistemde zaten kayıtlı
 A Product or Service,Ürün veya Hizmet
 A Supplier exists with same name,Aynı isimli bir Tedarikçi mevcuttur.
-A symbol for this currency. For e.g. $,Bu para birimi için bir sembol. örn. $
-AMC Expiry Date,AMC Expiry Date
+A symbol for this currency. For e.g. $,Bu para için bir sembol mesela $ için
+AMC Expiry Date,AMC Bitiş Tarihi
 Abbr,Kısaltma
 Abbreviation cannot have more than 5 characters,Kısaltma 5 karakterden fazla olamaz.
-Above Value,Değer Üstü
+Above Value,Değerin üstünde
 Absent,Eksik
 Acceptance Criteria,Onaylanma Kriterleri
 Accepted,Onaylanmış
@@ -74,16 +74,16 @@
 Account {0} is frozen,Hesap {0} donduruldu
 Account {0} is inactive,Hesap {0} etkin değil
 Account {0} is not valid,Hesap {0} geçerli değil
-Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Öğe {1} bir Varlık Öğe olduğu gibi hesap {0} türündeki 'Demirbaş' olmalı
+Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Hesap {0} Madde {1} Varlık Maddesi olmak üzere 'Sabit Varlık' türünde olmalıdır
 Account {0}: Parent account {1} can not be a ledger,Hesap {0}: Ana hesap {1} bir defter olamaz
 Account {0}: Parent account {1} does not belong to company: {2},Hesap {0}: Ana hesap {1} şirkete ait değil: {2}
 Account {0}: Parent account {1} does not exist,Hesap {0}: Ana hesap {1} yok
-Account {0}: You can not assign itself as parent account,Hesap {0}: Hesabınız ana hesabı olarak atanamıyor.
+Account {0}: You can not assign itself as parent account,Hesap {0}: Kendisini bir ana hesap olarak atayamazsınız
 Account: {0} can only be updated via \					Stock Transactions,Hesap: {0} sadece stok işlemler aracılığıyla güncellenebilir
 Accountant,Muhasebeci
 Accounting,Muhasebe
-"Accounting Entries can be made against leaf nodes, called",Muhasebe girişleri yaprak düğümlere karşı yapılabilir.
-"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Muhasebe girişi bu tarihe kadar dondurulmuş, kimse / aşağıda belirtilen görevliler dışında bir girdi değiştiremez."
+"Accounting Entries can be made against leaf nodes, called",Muhasebe girdileri yaprak nodlar karşılığı yapılabilir
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Muhasebe entry bu tarihe kadar dondurulmuş, kimse / aşağıda belirtilen rolü dışında girdisini değiştirin yapabilirsiniz."
 Accounting journal entries.,Muhasebe günlük girişleri.
 Accounts,Hesaplar
 Accounts Browser,Hesap Tarayıcı
@@ -115,204 +115,204 @@
 Add Child,Alt öğe ekle
 Add Serial No,Seri No ekle
 Add Taxes,Vergi Ekle
-Add Taxes and Charges,Vergi ve Masraflar ekle
-Add or Deduct,Ekle veya Azalt
-Add rows to set annual budgets on Accounts.,Hesaplardaki yıllık bütçeler ayarlamak için satırları ekleyin.
+Add Taxes and Charges,Vergi ve Masrafları ekle
+Add or Deduct,Ekle veya Çıkar
+Add rows to set annual budgets on Accounts.,Hesaplarda yıllık bütçeleri ayarlamak için kolon ekle.
 Add to Cart,Sepete ekle
-Add to calendar on this date,Bu tarihte Takvime ekle
-Add/Remove Recipients,Alıcıları Ekle / Kaldır 
-Address,Adres
-Address & Contact,Adres ve İletişim
-Address & Contacts,Adres ve İletişim
-Address Desc,Adres Detaylar
+Add to calendar on this date,Bu tarihe Takvime ekle
+Add/Remove Recipients,Alıcı Ekle/Kaldır
+Address,İletişim
+Address & Contact,Adres ve İrtibat
+Address & Contacts,Adres ve İrtibat
+Address Desc,DESC Adresi
 Address Details,Adres Bilgileri
-Address HTML,HTML Adres
+Address HTML,Adres HTML
 Address Line 1,Adres Satırı 1
 Address Line 2,Adres Satırı 2
-Address Template,Adres Şablon
+Address Template,Adres Şablonu
 Address Title,Adres Başlığı
-Address Title is mandatory.,Adres Başlık zorunludur.
-Address Type,Adres Türü
-Address master.,Adres usta.
+Address Title is mandatory.,Adres Başlığı zorunludur.
+Address Type,Adres Tipi
+Address master.,Asıl adres.
 Administrative Expenses,Yönetim Giderleri
 Administrative Officer,İdari Memur
 Advance Amount,Avans Tutarı
 Advance amount,Avans miktarı
 Advances,Avanslar
-Advertisement,Reklam
+Advertisement,Reklâm
 Advertising,Reklamcılık
-Aerospace,Havacılık ve Uzay
-After Sale Installations,Satış Tesisatları Sonrası
-Against,Against
-Against Account,Against Account
-Against Bill {0} dated {1},Bill {0} tarihli karşı {1}
-Against Docname,Against Docname
-Against Doctype,Against Doctype
-Against Document Detail No,Against Document Detail No
-Against Document No,Against Document No
-Against Expense Account,Against Expense Account
-Against Income Account,Against Income Account
-Against Journal Voucher,Against Journal Voucher
-Against Journal Voucher {0} does not have any unmatched {1} entry,Dergi Çeki karşı {0} herhangi bir eşsiz {1} girdi yok
-Against Purchase Invoice,Against Purchase Invoice
-Against Sales Invoice,Against Sales Invoice
-Against Sales Order,Satış Siparişi karşı
-Against Voucher,Against Voucher
-Against Voucher Type,Against Voucher Type
+Aerospace,Havacılık ve Uzay;
+After Sale Installations,Satış Sonrası Montaj
+Against,Karşı
+Against Account,Hesap karşılığı
+Against Bill {0} dated {1},Fatura karşılığı {0} {1} tarihli
+Against Docname,Belge adı karşılığı
+Against Doctype,Belge Tipi Karşılığı
+Against Document Detail No,Belge Detay No Karşılığı
+Against Document No,Belge No Karşılığı
+Against Expense Account,Gider Hesabı Karşılığı
+Against Income Account,Gelir Hesabı Karşılığı
+Against Journal Voucher,Dekont Karşılığı
+Against Journal Voucher {0} does not have any unmatched {1} entry,Dekont Karşılığı {0} eşleşmemiş {1} girdi yok
+Against Purchase Invoice,Satın Alma Faturası Karşılığı
+Against Sales Invoice,Satış Faturası Karşılığı
+Against Sales Order,Satış Emri Karşılığı
+Against Voucher,Dekont Karşılığı
+Against Voucher Type,Dekont  Tipi Karşılığı
 Ageing Based On,Dayalı Yaşlanma
-Ageing Date is mandatory for opening entry,Üyelik Yaşlanma girişi açılması için zorunludur
-Ageing date is mandatory for opening entry,Tarih Yaşlanma girişi açılması için zorunludur
-Agent,Acente
-Aging Date,Tarih Yaşlanma
-Aging Date is mandatory for opening entry,Üyelik Yaşlanma girişi açılması için zorunludur
+Ageing Date is mandatory for opening entry,Açılış Girdisi için Yaşlanma Tarihi zorunludur
+Ageing date is mandatory for opening entry,Açılış Girdisi için Yaşlanma Tarihi zorunludur
+Agent,Temsilci
+Aging Date,Yaşlanma Tarihi
+Aging Date is mandatory for opening entry,Açılış Girdisi için Yaşlanma Tarihi zorunludur
 Agriculture,Tarım
 Airline,Havayolu
 All Addresses.,Tüm adresler.
-All Contact,Tüm Kişiler.
+All Contact,Tüm İrtibatlar
 All Contacts.,Tüm Kişiler.
-All Customer Contact,Tüm Müşteri İletişim
-All Customer Groups,Tüm Müşteri Grupları
-All Day,Tüm Gün
-All Employee (Active),Tüm Çalışan (Aktif)
-All Item Groups,Tüm Ürün Grupları
-All Lead (Open),Tüm Liderler (Açık)
-All Products or Services.,Tüm Ürünler ve Hizmetler.
-All Sales Partner Contact,Tüm Satış Ortağı İletişim
-All Sales Person,Tüm Satış Elemanı
-All Supplier Contact,Tüm Tedarikçi İletişim
-All Supplier Types,Tüm Tedarikçi Türleri
-All Territories,Tüm Bölgeleri
-"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Para, dönüşüm oranı, ihracat, toplam ihracat genel toplam vb gibi tüm ihracat ile ilgili alanlar İrsaliye, POS, Teklifi, Satış Fatura, Satış Siparişi vb mevcuttur"
-"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Para, dönüşüm oranı, ithalat, toplam ithalat genel toplam vb gibi tüm ithalat ile ilgili alanlar Satın Alındı, Tedarikçi Teklifi, Satınalma Fatura, Sipariş vb mevcuttur"
-All items have already been invoiced,Tüm öğeler zaten faturalı edilmiştir
-All these items have already been invoiced,Tüm bu öğeler zaten faturalı edilmiştir
-Allocate,Dağıtım
-Allocate leaves for a period.,Bir süre için yaprakları ayırın.
-Allocate leaves for the year.,Yıl boyunca yaprakları ayırın.
-Allocated Amount,Dağıtılan Tutar
-Allocated Budget,Dağıtılan Bütçe
+All Customer Contact,Bütün Müşteri İrtibatları
+All Customer Groups,Bütün Müşteri Grupları
+All Day,Bütün Gün
+All Employee (Active),Bütün Çalışanlar (Aktif)
+All Item Groups,Bütün Ürün Grupları
+All Lead (Open),Bütün Başlıklar (Açık)
+All Products or Services.,Bütün Ürünler veya Hizmetler.
+All Sales Partner Contact,Bütün Satış Ortakları İrtibatları
+All Sales Person,Bütün Satış Kişileri
+All Supplier Contact,Bütün Tedarikçi Kişiler
+All Supplier Types,Bütün Tedarikçi Tipleri
+All Territories,Bütün Bölgeler
+"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Para birimi, kur oranı,ihracat toplamı, bütün ihracat toplamı vb. İrsaliye'de, POS'da Fiyat Teklifinde, Satış Faturasında, Satış Emrinde vb. mevcuttur."
+"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Para birimi, kur oranı,ithalat toplamı, bütün ithalat toplamı vb. Satın Alma Fişinde, Tedarikçi Fiyat Teklifinde, Satış Faturasında, Alım Emrinde vb. mevcuttur."
+All items have already been invoiced,Bütün Ürünler zaten faturalandırılmıştır
+All these items have already been invoiced,Bütün Ürünler zaten faturalandırılmıştır
+Allocate,Tahsis
+Allocate leaves for a period.,Bir dönemlik tahsis izni.
+Allocate leaves for the year.,Yıllık tahsis izni.
+Allocated Amount,Tahsis edilen miktar
+Allocated Budget,Tahsis edilen bütçe
 Allocated amount,Ayrılan miktarı
-Allocated amount can not be negative,Ayrılan miktar negatif olamaz
-Allocated amount can not greater than unadusted amount,Ayrılan miktarı unadusted değerinden daha yüksek olamaz
-Allow Bill of Materials,Malzeme Faturasına İzin ver
-Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,"Malzeme Bill 'Evet' olmalıdır izin verir. Çünkü, bir veya bu öğe için mevcut pek çok aktif BOMs"
-Allow Children,Çocuklara izin
-Allow Dropbox Access,Dropbox erişime izin
-Allow Google Drive Access,Google Drive erişimine izin
-Allow Negative Balance,Negatif Denge izin
-Allow Negative Stock,Negatif Stoğa İzin ver
-Allow Production Order,Üretim Siparişine izin ver
-Allow User,Kullanıcıya izin
-Allow Users,Kullanıcılar izin
-Allow the following users to approve Leave Applications for block days.,Aşağıdaki kullanıcılar blok gün boyunca bırak Uygulamaları onaylamak için izin verir.
-Allow user to edit Price List Rate in transactions,Kullanıcı işlemlerinde Fiyat Listesi Oranı düzenlemek için izin
-Allowance Percent,İzin Verilen Yüzde
-Allowance for over-{0} crossed for Item {1},Ödeneği fazla {0} Ürün için geçti için {1}
-Allowance for over-{0} crossed for Item {1}.,Ödeneği fazla {0} Ürün için geçti için {1}.
-Allowed Role to Edit Entries Before Frozen Date,Dondurulmuş Tarihten Önce Düzenle Girişlerine İzin Rolü
-Amended From,Değişiliği yapan
-Amount,Miktar
+Allocated amount can not be negative,Tahsis edilen miktar negatif olamaz
+Allocated amount can not greater than unadusted amount,Tahsis edilen miktar ayarlanmamış miktardan fazla olamaz
+Allow Bill of Materials,Malzeme faturasına(BOM) izin ver
+Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Malzemelerin izin faturası(BOM) 'Evet' olmalıdır. Çünkü bu Malzeme için bir veya birden fazla BOM mevcuttur
+Allow Children,Çocuk İzni
+Allow Dropbox Access,Dropbox erişim izni
+Allow Google Drive Access,Google Drive erişim izni
+Allow Negative Balance,Negatif Bakiye izni
+Allow Negative Stock,Negatif Stok izni
+Allow Production Order,Üretim Emri izni
+Allow User,Kullanıcı izni
+Allow Users,Kullanıcılar izni
+Allow the following users to approve Leave Applications for block days.,Blok günleri için aşağıdaki kullanıcıların izin uygulamalarını onaylamasına izin ver.
+Allow user to edit Price List Rate in transactions,Kullanıcıya işlemlerdeki Fiyat Listesi Oranını düzenlemek için izin ver
+Allowance Percent,Ödenek Yüzdesi
+Allowance for over-{0} crossed for Item {1},{1} den fazla Ürün için {0} üzerinde ödenek
+Allowance for over-{0} crossed for Item {1}.,{1} den fazla Ürün için {0} üzerinde ödenek
+Allowed Role to Edit Entries Before Frozen Date,Dondurulma Tarihinden önce Girdileri düzenlemek için role izin ver
+Amended From,İtibaren değiştirilmiş
+Amount,Tutar
 Amount (Company Currency),Tutar (Şirket Para Birimi)
-Amount Paid,Ödenen Tutar
-Amount to Bill,Bill tutarı
-An Customer exists with same name,Bir Müşteri aynı adla
-"An Item Group exists with same name, please change the item name or rename the item group","Bir Ürün Grubu aynı adla, öğe adını değiştirmek veya madde grubu yeniden adlandırmak lütfen"
-"An item exists with same name ({0}), please change the item group name or rename the item","Bir öğe ({0}), madde grubu adını değiştirmek veya öğeyi yeniden adlandırmak lütfen aynı adla"
+Amount Paid,Ödenen Tutar;
+Amount to Bill,Faturalanacak Tutar
+An Customer exists with same name,Aynı isimle bulunan bir müşteri
+"An Item Group exists with same name, please change the item name or rename the item group","Bir Ürün grubu aynı isimle bulunuyorsa, lütfen Ürün veya Ürün grubu adını değiştirin"
+"An item exists with same name ({0}), please change the item group name or rename the item","Bir Ürün aynı isimle bulunuyorsa ({0}), lütfen madde grubunun veya maddenin adını değiştirin"
 Analyst,Analist
 Annual,Yıllık
-Another Period Closing Entry {0} has been made after {1},Başka Dönem Kapanış Giriş {0} sonra yapılmış olan {1}
-Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Başka Maaş Yapısı {0} çalışan için aktif olan {0}. Devam etmek durumunu 'Etkin' olun.
-"Any other comments, noteworthy effort that should go in the records.","Başka yorum, kayıtları gitmek gerekir kayda değer bir çaba."
+Another Period Closing Entry {0} has been made after {1},{1} den sonra başka bir dönem kapatma girdisi {0} yapılmıştır
+Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Çalışan {0} için başka bir maaş yapısı {0} etkin. Lütfen ilerlemek için durumunu 'aktif değil' olarak değiştirin.
+"Any other comments, noteworthy effort that should go in the records.","Diğer yorumlar, kayıtlara girebilecek çabalar"
 Apparel & Accessories,Giyim ve Aksesuar
 Applicability,Uygulanabilirlik
-Applicable For,İçin Uygulanabilir
+Applicable For,İçin Uygulanabilir;;
 Applicable Holiday List,Uygulanabilir Tatil Listesi
-Applicable Territory,Uygulanabilir Territory
-Applicable To (Designation),Için Uygulanabilir (adlandırması)
-Applicable To (Employee),Için Uygulanabilir (Çalışan)
-Applicable To (Role),Için Uygulanabilir (Role)
-Applicable To (User),Için Uygulanabilir (Kullanıcı)
-Applicant Name,Başvuranın Adı
-Applicant for a Job.,Bir iş için Başvuru.
-Application of Funds (Assets),Fon uygulaması (Varlıklar)
-Applications for leave.,Izni için başvurular.
-Applies to Company,Şirket için geçerlidir
-Apply On,On Uygula
-Appraisal,Değerlendirme
-Appraisal Goal,Değerleme Hedefi
-Appraisal Goals,Değerleme Hedefleri
-Appraisal Template,Değerleme Şablon
-Appraisal Template Goal,Değerleme Şablon Hedefi
-Appraisal Template Title,Değerleme Şablon Başlığı
-Appraisal {0} created for Employee {1} in the given date range,Değerleme {0} {1} verilen tarih aralığında Çalışan için oluşturulan
+Applicable Territory,Uygulanabilir Bölge
+Applicable To (Designation),(Görev) için Uygulanabilir
+Applicable To (Employee),(Çalışana) Uygulanabilir
+Applicable To (Role),(Role) Uygulanabilir 
+Applicable To (User),(Kullanıcıya) Uygulanabilir
+Applicant Name,Başvuru sahibinin adı
+Applicant for a Job.,Bir iş için başvuran.
+Application of Funds (Assets),Fon (varlık) başvurusu
+Applications for leave.,İzin başvuruları.
+Applies to Company,Şirket için geçerli
+Apply On,Uygula
+Appraisal,Appraisal:Değerlendirme
+Appraisal Goal,Değerlendirme Hedefi
+Appraisal Goals,Değerlendirme Hedefleri
+Appraisal Template,Değerlendirme Şablonu
+Appraisal Template Goal,Değerlendirme Şablonu Hedefi
+Appraisal Template Title,Değerlendirme Şablonu Başlığı
+Appraisal {0} created for Employee {1} in the given date range,Verilen aralıkta Çalışan {1} için oluşturulan değerlendirme {0}
 Apprentice,Çırak
 Approval Status,Onay Durumu
-Approval Status must be 'Approved' or 'Rejected',Onay Durumu 'Onaylandı' veya 'Reddedildi' olmalı
-Approved,Onaylı
+Approval Status must be 'Approved' or 'Rejected',Onay Durumu 'Onaylandı' veya 'Reddedildi' olmalıdır
+Approved,Onaylandı
 Approver,Onaylayan
-Approving Role,Rol Onaylanıyor
-Approving Role cannot be same as role the rule is Applicable To,Rolü Onaylanmasının kural Uygulanabilir olduğu rol olarak aynı olamaz
-Approving User,Kullanıcı Onaylanıyor
-Approving User cannot be same as user the rule is Applicable To,Kullanıcı Onaylanmasının kural Uygulanabilir olduğu kullanıcı olarak aynı olamaz
-Are you sure you want to STOP ,Are you sure you want to STOP 
-Are you sure you want to UNSTOP ,Are you sure you want to UNSTOP 
-Arrear Amount,Geciken Tutar
-"As Production Order can be made for this item, it must be a stock item.","Üretim Sipariş Bu öğe için yapılabilir gibi, bir stok kalemi olmalıdır."
-As per Stock UOM,Stok Ölçü Birimi (ÖB) başı olarak
-"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Bu öğe için mevcut hisse senedi işlemleri olduğu gibi, sen 'Seri No Has' değerlerini değiştiremez, ve 'Değerleme Yöntemi' Stok Ürün mı '"
+Approving Role,Onaylama Rolü
+Approving Role cannot be same as role the rule is Applicable To,Onaylama Rolü kuralın uygulanabilir olduğu rolle aynı olamaz
+Approving User,Onaylayan Kullanıcı
+Approving User cannot be same as user the rule is Applicable To,Onaylayan Kullanıcı kuralın uygulanabilir olduğu kullanıcı ile aynı olamaz
+Are you sure you want to STOP ,Durmak istediğinizden emin misiniz
+Are you sure you want to UNSTOP ,Devam etmek istediğinizden emin misiniz
+Arrear Amount,Bakiye Tutarı
+"As Production Order can be made for this item, it must be a stock item.","Bu Ürün içim Üretim Emri verilebilmesi için, Ürün stok Ürünü olmalıdır."
+As per Stock UOM,Stok UOM gereğince
+"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Bu Ürün için mevcut stok işlemleri olduğundan 'Seri No', 'Stok Ürünleri' ve 'Değerleme Yöntemi' değerlerini değiştiremezsiniz"
 Asset,Varlık
 Assistant,Asistan
 Associate,Ortak
-Atleast one of the Selling or Buying must be selected,Satış veya Alış en az biri seçilmelidir
+Atleast one of the Selling or Buying must be selected,Satış veya Alıştan en az biri seçilmelidir
 Atleast one warehouse is mandatory,En az bir depo zorunludur
-Attach Image,Resmi takın
-Attach Letterhead,Antetli takın
-Attach Logo,Logo takın
-Attach Your Picture,Kişisel Resim takın
+Attach Image,Görüntü Ekleyin
+Attach Letterhead,Antetli Kağıt Ekleyin
+Attach Logo,Logo Ekleyin
+Attach Your Picture,Resminizi Ekleyin
 Attendance,Katılım
 Attendance Date,Katılım Tarihi
-Attendance Details,Katılım Detaylar
-Attendance From Date,Bu tarihten itibaren katılım
-Attendance From Date and Attendance To Date is mandatory,Tarihi Tarih ve Katılım itibaren katılım zorunludur
-Attendance To Date,Bu tarihe kadar katılım
-Attendance can not be marked for future dates,Seyirci gelecek tarihler için işaretlenmiş edilemez
-Attendance for employee {0} is already marked,Çalışan Devam {0} zaten işaretlenmiş
-Attendance record.,Katılımcı kayıtları
+Attendance Details,Katılım Detayları
+Attendance From Date,Tarihten itibaren katılım
+Attendance From Date and Attendance To Date is mandatory,tarihinden  Tarihine kadar katılım zorunludur
+Attendance To Date,Tarihine kadar katılım
+Attendance can not be marked for future dates,İlerideki tarihler için katılım işaretlenemez
+Attendance for employee {0} is already marked,Çalışan {0} için devam zaten işaretlenmiştir
+Attendance record.,Katılım kaydı.
 Authorization Control,Yetki Kontrolü
-Authorization Rule,Yetkilendirme Kuralı
+Authorization Rule,Yetki Kuralı
 Auto Accounting For Stock Settings,Stok Ayarları için Otomatik Muhasebe
 Auto Material Request,Otomatik Malzeme Talebi
-Auto-raise Material Request if quantity goes below re-order level in a warehouse,Otomatik zam Malzeme Talebi miktarı bir depoda yeniden sipariş seviyesinin altında giderse
-Automatically compose message on submission of transactions.,Otomatik işlemlerin sunulmasına ilişkin mesaj oluşturabilirsiniz.
-Automatically extract Job Applicants from a mail box ,Automatically extract Job Applicants from a mail box 
-Automatically extract Leads from a mail box e.g.,Otomatik olarak bir posta kutusu örneğin itibaren İlanlar ayıklamak
-Automatically updated via Stock Entry of type Manufacture/Repack,Üretim veya yeniden paketleme stok girişi ile otomatik olarak güncellendi
+Auto-raise Material Request if quantity goes below re-order level in a warehouse,Miktar depodaki yeniden sipariş düzeyinin altına düşerse Malzeme talebini otomatik olarak yükselt
+Automatically compose message on submission of transactions.,İşlemlerin sunulmasında otomatik olarak mesaj oluştur.
+Automatically extract Job Applicants from a mail box ,İş başvurularını mail kutusundan otomatik olarak çıkar
+Automatically extract Leads from a mail box e.g.,Gibi başlıkları mail kutusundan otomatik olarak çıkar.
+Automatically updated via Stock Entry of type Manufacture/Repack,Tip Üretimi/Yeniden Ambalajlaması ile Stok Girdisi yoluyla otomatik olarak güncellenir
 Automotive,Otomotiv
-Autoreply when a new mail is received,Yeni bir posta alındığında Otomatik yanıt ver
+Autoreply when a new mail is received,Yeni bir posta alındığında otomatik olarak yanıtla
 Available,Uygun
-Available Qty at Warehouse,Stoktaki Mevcut Miktar
-Available Stock for Packing Items,Ürünleri Ambalaj Stok kullanılabilir
-"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","BOM, İrsaliye, Fatura Satınalma, Üretim Emri, Sipariş, Satın Alma Makbuzu, Satış Fatura, Satış Siparişi, Stok Girişi, Çizelgesi mevcuttur"
+Available Qty at Warehouse,Depoda mevcut miktar
+Available Stock for Packing Items,Ambalajlama Ürünleri için mevcut stok
+"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","BOM,İrsaliye, Satın Alma Faturası, Satın Alma Makbuzu, Satış Faturası, Satış Emri, Stok Girdisi, Zaman Çizelgesinde Mevcut"
 Average Age,Ortalama Yaş
 Average Commission Rate,Ortalama Komisyon Oranı
 Average Discount,Ortalama İndirim
-Awesome Products,Başar Ürünler
-Awesome Services,Başar Hizmetleri
+Awesome Products,Başarılı Ürünler
+Awesome Services,Başarılı Hizmetler
 BOM Detail No,BOM Detay yok
-BOM Explosion Item,Patlatılmış Malzeme Listesi
+BOM Explosion Item,BOM Patlatılmış Malzemeler
 BOM Item,BOM Ürün
 BOM No,BOM numarası
 BOM No. for a Finished Good Item,Biten İyi Ürün için BOM numarası
 BOM Operation,BOM Operasyonu
 BOM Operations,BOM İşlemleri
 BOM Replace Tool,BOM Aracı değiştirin
-BOM number is required for manufactured Item {0} in row {1},BOM numarası imal edılecek ürün için gereklidir {0} satır{1}
-BOM number not allowed for non-manufactured Item {0} in row {1},Üretilemez ürün için BOM numarası verilmez{0} satır {1}
+BOM number is required for manufactured Item {0} in row {1},Kolon {1} de üretilen Ürün {0} için BOM numarası gerekir
+BOM number not allowed for non-manufactured Item {0} in row {1},Kolon {1} de üretilmeyen Ürün {0} için BOM numarasına izin verilmez
 BOM recursion: {0} cannot be parent or child of {2},BOM özyineleme: {0} ebeveyn veya çocuk olamaz {2}
 BOM replaced,BOM yerine
-BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} öğesi için {1} üste {2} teslim inaktif ya da değildir
+BOM {0} for Item {1} in row {2} is inactive or not submitted,Ürün {1} için kolon {2} BOM {0} teslim edilmemiştir veya aktif değildir
 BOM {0} is not active or not submitted,BOM {0} aktif değil veya eklenmemiş
-BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} teslim veya değildir inaktif BOM Ürün için {1}
+BOM {0} is not submitted or inactive BOM for Item {1},Ürün{1} için BOM {0} teslim edilmemiştir veya aktif değildir
 Backup Manager,Yedek Yöneticisi
 Backup Right Now,Yedek Kullanılabilir
 Backups will be uploaded to,Yedekler yüklenecek
@@ -320,11 +320,11 @@
 Balance Sheet,Bilanço
 Balance Value,Denge Değeri
 Balance for Account {0} must always be {1},Hesap {0} her zaman dengede olmalı {1}
-Balance must be,Hesap olmalı
-"Balances of Accounts of type ""Bank"" or ""Cash""",Banka ve Nakit denge hesapları
+Balance must be,Bakiye şu olmalıdır
+"Balances of Accounts of type ""Bank"" or ""Cash""","""Banka"" veya ""Nakit tipi"" hesapların bakiyeleri"
 Bank,Banka
 Bank / Cash Account,Banka / Kasa Hesabı
-Bank A/C No.,Bank A / C No
+Bank A/C No.,Bank A/C No.
 Bank Account,Banka Hesabı
 Bank Account No.,Banka Hesap No
 Bank Accounts,Banka Hesapları
@@ -339,7 +339,7 @@
 Bank/Cash Balance,Banka / Nakit Dengesi
 Banking,Bankacılık
 Barcode,Barkod
-Barcode {0} already used in Item {1},Barkod {0} zaten öğede kullanılmakta{1}
+Barcode {0} already used in Item {1},Barkod {0} zaten Ürün {1} de kullanılmış
 Based On,Göre
 Basic,Temel
 Basic Info,Temel Bilgiler
@@ -348,20 +348,20 @@
 Basic Rate (Company Currency),Temel oran (Şirket para birimi)
 Batch,Yığın
 Batch (lot) of an Item.,Bir Öğe toplu (lot).
-Batch Finished Date,Günü biten Batch
-Batch ID,Batch ID
+Batch Finished Date,Seri Bitiş Tarihi
+Batch ID,Seri Kimliği
 Batch No,Parti No
 Batch Started Date,Parti başlangıç tarihi
-Batch Time Logs for billing.,Fatura için parti kayıt zamanı
-Batch-Wise Balance History,Toplu-Wise Dengesi Tarihi
-Batched for Billing,Fatura için gruplanmış
+Batch Time Logs for billing.,Fatura için Parti Kayıtları.
+Batch-Wise Balance History,Parti-Bilgi Bakiye Geçmişi
+Batched for Billing,Faturalanmak için partiler haline getirilmiş
 Better Prospects,Iyi Beklentiler
 Bill Date,Fatura tarihi
 Bill No,Fatura No
-Bill No {0} already booked in Purchase Invoice {1},Fatura No {0} Alım faturası zaten kayıtlı {1}
+Bill No {0} already booked in Purchase Invoice {1},Fatura No {0} zaten satın alma faturasında ayrılmış {1}
 Bill of Material,Ürün Ağacı
-Bill of Material to be considered for manufacturing,Üretim için dikkate alınacak Ürün Ağacı
-Bill of Materials (BOM),Ürün Ağacı (BOM)
+Bill of Material to be considered for manufacturing,Üretim için göz önüne alınması gereken Malzeme Faturası
+Bill of Materials (BOM),Malzeme Listesi (BOM)
 Billable,Faturalandırılabilir
 Billed,Faturalanmış
 Billed Amount,Faturalı Tutar
@@ -378,16 +378,16 @@
 Birthday,Doğum günü
 Block Date,Blok Tarih
 Block Days,Blok Gün
-Block leave applications by department.,Departman tarafından engellenen uygulamalar.
+Block leave applications by department.,Departman tarafından blok aralığı uygulamaları.
 Blog Post,Blog postası
 Blog Subscriber,Blog Abone
 Blood Group,Kan grubu
-Both Warehouse must belong to same Company,Her iki Depoda aynı şirkete ait olmalı
+Both Warehouse must belong to same Company,Her iki depo da aynı şirkete ait olmalıdır
 Box,Kutu
 Branch,Şube
 Brand,Marka
 Brand Name,Marka Adı
-Brand master.,Ana Marka.
+Brand master.,Esas marka.
 Brands,Markalar
 Breakdown,Arıza
 Broadcasting,Yayın
@@ -401,22 +401,22 @@
 Budget Distribution Details,Bütçe Dağıtım Detayları
 Budget Variance Report,Bütçe Fark Raporu
 Budget cannot be set for Group Cost Centers,Bütçe Grubu Maliyet Merkezleri için ayarlanamaz
-Build Report,Rapor Oluştur
-Bundle items at time of sale.,Satış sırasında ürünleri birleştir.
+Build Report,Rapor oluşturmak
+Bundle items at time of sale.,Satış zamanı toplam Ürünler.
 Business Development Manager,İş Geliştirme Müdürü
-Buying,Satınalma
-Buying & Selling,Satınalma & Pazarlama
-Buying Amount,Alış Tutarı
+Buying,Satın alma
+Buying & Selling,Alım ve Satım
+Buying Amount,Alım Miktarı
 Buying Settings,Satınalma Ayarları
-"Buying must be checked, if Applicable For is selected as {0}","Uygulanabilir için seçilmiş ise satın alma, kontrol edilmelidir {0}"
+"Buying must be checked, if Applicable For is selected as {0}","Eğer Uygulanabilir {0} olarak seçilirse, alım kontrol edilmelidir."
 C-Form,C-Formu
 C-Form Applicable,Uygulanabilir C-Formu
 C-Form Invoice Detail,C-Form Fatura Ayrıntısı
 C-Form No,C-Form No
 C-Form records,C-Form kayıtları
 CENVAT Capital Goods,CENVAT Sermaye Malı
-CENVAT Edu Cess,CENVAT Edu Cess
-CENVAT SHE Cess,CENVAT SHE Cess
+CENVAT Edu Cess,CENVAT Edu Vergisi
+CENVAT SHE Cess,CENVAT SHE Vergisi
 CENVAT Service Tax,CENVAT Hizmet Vergisi
 CENVAT Service Tax Cess 1,CENVAT Hizmet Vergisi Cess 1
 CENVAT Service Tax Cess 2,CENVAT Hizmet Vergisi Vergisi 2
@@ -428,97 +428,97 @@
 Campaign,Kampanya
 Campaign Name,Kampanya Adı
 Campaign Name is required,Kampanya Adı gereklidir
-Campaign Naming By,Kampanya ... tarafından isimlendirilmiştir.
+Campaign Naming By,Tarafından Kampanya İsimlendirmesi
 Campaign-.####,Kampanya-.####
 Can be approved by {0},{0} tarafından onaylanmış
-"Can not filter based on Account, if grouped by Account","Hesap tarafından gruplandırma yapılmışsa, süzme hesap tabanlı yapılamaz."
-"Can not filter based on Voucher No, if grouped by Voucher","Gruplandırma çek tarafından yapılmışsa, çek numarası tabanlı süzme yapılamaz."
-Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Şarj tipi sadece 'Sıra Önceki Toplamı' ya da 'Sıra Önceki Tutar Açık' ise sıra ile ilgilidir.
-Cancel Material Visit {0} before cancelling this Customer Issue,İptal Malzemesi ziyareti {0} bu Müşteri Sayısının iptalinden önce
-Cancel Material Visits {0} before cancelling this Maintenance Visit,İptal materyali ziyareti {0} tamir ziyaretinden önce iptal edilir.
+"Can not filter based on Account, if grouped by Account","Hesap, olarak gruplandırıldı ise Hesaba dayalı filtreleme yapamaz"
+"Can not filter based on Voucher No, if grouped by Voucher","Dekont, olarak gruplandırıldı ise Makbuz numarasına dayalı filtreleme yapamaz"
+Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Eğer ücret biçimi 'Önceki Ham Miktar' veya 'Önceki Ham Totk' ise referans verebilir
+Cancel Material Visit {0} before cancelling this Customer Issue,Bu Müşteri konusu iptal etmeden önce Malzeme Ziyareti {0} iptal edin
+Cancel Material Visits {0} before cancelling this Maintenance Visit,Bu Bakım Ziyaretini iptal etmeden önce Malzeme Ziyareti {0} iptal edin
 Cancelled,İptal Edilmiş
-Cancelling this Stock Reconciliation will nullify its effect.,"Stok uzlaşma iptali, bunun etkisini geçersiz kılacaktır."
-Cannot Cancel Opportunity as Quotation Exists,Teklif var ise imkan iptal edilemez.
-Cannot approve leave as you are not authorized to approve leaves on Block Dates,Blok Tarihlerde  
+Cancelling this Stock Reconciliation will nullify its effect.,"Bu Stok Uzlaşmasını iptal etmek, sonuçlarını geçersiz kılacaktır."
+Cannot Cancel Opportunity as Quotation Exists,Fiyat teklifi mevcut olduğundan fırsat iptal edilemez
+Cannot approve leave as you are not authorized to approve leaves on Block Dates,Engel tarihlerinde izin onaylamaya yetkiniz olmadığından izin onaylanamaz
 Cannot cancel because Employee {0} is already approved for {1},Çalışan {0} zaten onaylanmış olduğundan iptal edemez {1}
 Cannot cancel because submitted Stock Entry {0} exists,Sunulan Stok Giriş {0} varolduğundan iptal edilemiyor
 Cannot carry forward {0},Ileriye taşıyamaz {0}
 Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Mali Yıl Başlangıç ​​Tarihi ve Mali Yılı kaydedildikten sonra Mali Yıl Sonu Tarihi değiştiremezsiniz.
 "Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Mevcut işlemler olduğundan, şirketin varsayılan para birimini değiştiremezsiniz. İşlemler Varsayılan para birimini değiştirmek için iptal edilmelidir."
-Cannot convert Cost Center to ledger as it has child nodes,Muhasebedeki Maliyet merkezi çocuk düğümlere sahipse değiştirilemez.
-Cannot covert to Group because Master Type or Account Type is selected.,Master Tip veya Hesap Tipi seçildiği için Grup gizlenemez.
-Cannot deactive or cancle BOM as it is linked with other BOMs,Diğer BOMlarla linklenmiş bir BOM iptal edilemez ya da değiştirilemez.
+Cannot convert Cost Center to ledger as it has child nodes,Çocuk nodları olduğundan Maliyet Merkezi ana deftere dönüştürülemez
+Cannot covert to Group because Master Type or Account Type is selected.,Esas Tip veya Hesap seçildiğinden ötürü Gruba geçilemiyor.
+Cannot deactive or cancle BOM as it is linked with other BOMs,Diğer BOMlarla bağlantılı olduğu için BOM iptal edilemiyor veya etkinliği sonlandırılamıyor
 "Cannot declare as lost, because Quotation has been made.","Kayıp olarak Kotasyon yapılmış çünkü, ilan edemez."
-Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Kategori 'Değerleme' veya 'Değerleme ve Toplamı' ise, neticelendirilemez."
-"Cannot delete Serial No {0} in stock. First remove from stock, then delete.",Stoktaki seri no silinemez {0} Önce stoktan kaldırın sonra silin.
-"Cannot directly set amount. For 'Actual' charge type, use the rate field","Doğrudan, miktarını ayarla seçilemez. 'Gerçek' ücret türü için, oran alanını kullanın."
-"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Ürün için {0} bir sırada {0} 1den fazla fiyat yükseltme olamaz {1}. Fiyat yükseltmeye izin vermek için, Stok Ayarlarını değiştirin."
-Cannot produce more Item {0} than Sales Order quantity {1},Daha Öğe üretemez {0} Satış Sipariş miktarı {1}
-Cannot refer row number greater than or equal to current row number for this Charge type,"Bu ödeme türü için satır numarası, mevcut satır numarasından büyük ya da eşit olamaz."
-Cannot return more than {0} for Item {1},Dönüş olamaz {0} öğesi için {1}
-Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Ilk satır için 'Önceki Satır Toplamı', 'Önceki Satır Tutar' şeklinde ödeme türü seçemezsiniz."
-Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,"Değerleme için 'Önceki Satır Toplamında', 'Önceki Satır Tutar Toplamı' gibi ödeme türü seçemezsiniz. Daha önceki satır miktarı veya önceki satır toplamda sadece 'Total' seçeneğini seçebilirsiniz."
-Cannot set as Lost as Sales Order is made.,"Satış yapılmış sipariş, kayıp olarak ayarlanamaz."
-Cannot set authorization on basis of Discount for {0},İndirim bazında yetkilendirme ayarlanamaz {0}
+Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kategori 'Değerleme' veya 'Toplam ve Değerleme' olduğu zaman çıkarılamaz
+"Cannot delete Serial No {0} in stock. First remove from stock, then delete.",Stoktaki {0} Seri No silinemez. Önce stoktan çıkarıni sonra silin.
+"Cannot directly set amount. For 'Actual' charge type, use the rate field",Doğrudan Miktar ayarlanamaz. 'Fiili' ücret tipi için oran alanını kullanın
+"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings",{0} kolonundaki {0} Ürünler için {1} den fazla fatura kesilemez. Fazla fatura kesmek için lütfen Stok Ayarlarını düzenleyiniz.
+Cannot produce more Item {0} than Sales Order quantity {1},Satış Sipariş Miktarı {1} den fazla Ürün {0} üretilemez
+Cannot refer row number greater than or equal to current row number for this Charge type, Kolon numarası bu Ücret tipi için kolon numarasından büyük veya eşit olamaz
+Cannot return more than {0} for Item {1},Ürün {1} için  {0}'dan fazla geri dönülemez
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,İlk satır için ücret tipi 'Önceki satır tutarında' veya 'Önceki satır toplamında' olarak seçilemez
+Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,Değerleme için ücret tipi 'Önceki satır tutarında' veya 'Önceki satır toplamında' olarak seçilemez. Önceki satır tutarı veya önceki satır toplamı için yalnızca 'Toplam' seçeneğini seçebiirsiniz
+Cannot set as Lost as Sales Order is made.,Satış Emri yapıldığında Kayıp olarak ayarlanamaz.
+Cannot set authorization on basis of Discount for {0},{0} için indirim temelinde yetki ayarlanamaz
 Capacity,Kapasite
 Capacity Units,Kapasite Birimleri
 Capital Account,Sermaye hesabı
 Capital Equipments,Sermaye Ekipmanları
 Carry Forward,Nakletmek
 Carry Forwarded Leaves,Yönlendirilen Yapraklar Carry
-Case No(s) already in use. Try from Case No {0},Örnek numaraları zaten kullanılıyor. Örnek numarasından deneyin {0}
-Case No. cannot be 0,Örnek Numarası  0 olamaz
+Case No(s) already in use. Try from Case No {0},Konu Numarası/numaraları zaten kullanımda. Konu No {0} olarak deneyin.
+Case No. cannot be 0,Durum No 0 olamaz
 Cash,Nakit
-Cash In Hand,Kasa mevcudu
+Cash In Hand,Eldeki Nakit
 Cash Voucher,Para yerine geçen belge
 Cash or Bank Account is mandatory for making payment entry,Kasa veya Banka Hesabı ödeme girişi yapmak için zorunludur
 Cash/Bank Account,Kasa / Banka Hesabı
-Casual Leave,Casual bırak
+Casual Leave,Mazeret İzni
 Cell Number,Hücre sayısı
 Change UOM for an Item.,Bir madde için uom değiştirin.
 Change the starting / current sequence number of an existing series.,Varolan bir serinin başlangıç ​​/ geçerli sıra numarasını değiştirin.
 Channel Partner,Kanal Ortağı
-Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Hesap tipi {0} 'Gerçek' ise, Ürün Oranı içeremez."
+Charge of type 'Actual' in row {0} cannot be included in Item Rate,Satır {0}'daki 'Gerçek' ücret biçimi Ürün Br.Fiyatına dahil edilemez
 Chargeable,Ücretli
-Charity and Donations,Yardım ve Bağışlar
+Charity and Donations,Hayır ve Bağışlar
 Chart Name,Grafik Adı
 Chart of Accounts,Hesap Tablosu
-Chart of Cost Centers,Maliyet Merkezlerinin tablosu
-Check how the newsletter looks in an email by sending it to your email.,Check how the newsletter looks in an email by sending it to your email.
-"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Eğer tekrarlanan faturalar varsa, kontrol özelliğini kaldırın veya bitiş tarihini kaldırın."
-"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Otomatik yinelenen faturalara gerek olduğunda kontrol edin. Herhangi bir satış faturası gönderdikten sonra, Tekrarlanan bölüm görünür olacaktır."
-Check if you want to send salary slip in mail to each employee while submitting salary slip,Check if you want to send salary slip in mail to each employee while submitting salary slip
-Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Check this if you want to force the user to select a series before saving. There will be no default if you check this.
-Check this if you want to show in website,Check this if you want to show in website
-Check this to disallow fractions. (for Nos),Kesirlere izin vermemek için kontrol edin. (Nos için)
-Check this to pull emails from your mailbox,Check this to pull emails from your mailbox
+Chart of Cost Centers,Maliyet Merkezlerinin Grafikleri
+Check how the newsletter looks in an email by sending it to your email.,Haber bülteninin e-mailde nasıl göründüğünü e-mailinize göndererek kontrol edin.
+"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Tekrar eden fatura varsa kontrol edin, tekrar eden faturayı durdurun veya uygun bitiş tarihi ekleyin."
+"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Otomatik mükerrer faturaya ihtiyacınız olup olmadığını kontrol edin, herhangi bir satış faturası ibraz edildikten sonra tekrar bölümü görünür olacaktır."
+Check if you want to send salary slip in mail to each employee while submitting salary slip,Maaş makbuzu verirken her çalışana mail ile maaş makbuzu göndermek istiyorsanız işaretleyin
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Kullanıcıya kaydetmeden önce seri seçtirmek istiyorsanız işaretleyin. Eğer işaretlerseniz atanmış seri olmayacaktır.
+Check this if you want to show in website,Web sitesinde göstermek istiyorsanız işaretleyin
+Check this to disallow fractions. (for Nos),Kesirlere izin vermemek için işaretleyin (Numaralar için)
+Check this to pull emails from your mailbox,Posta kutunuzdan mail çekmek için işaretleyin
 Check to activate,Etkinleştirmek için kontrol edin
-Check to make Shipping Address,Sevkıyat Adresi kontrol et
+Check to make Shipping Address,Kargo Adresi oluşturmak için işaretleyin
 Check to make primary address,Birincil adresi olmak için kontrol edin
 Chemical,Kimyasal
 Cheque,Çek
 Cheque Date,Çek Tarih
 Cheque Number,Çek Numarası
-Child account exists for this account. You can not delete this account.,Bu hesapta çocuk hesap vardır. Bu hesabı silemezsiniz.
+Child account exists for this account. You can not delete this account.,Bu hesap için çocuk hesabı var. Bu hesabı silemezsiniz.
 City,İl
 City/Town,İl / İlçe
 Claim Amount,Hasar Tutarı
-Claims for company expense.,Şirket gideri için alacaklar.
+Claims for company expense.,Şirket Gideri Talepleri.
 Class / Percentage,Sınıf / Yüzde
 Classic,Klasik
 Clear Table,Temizle Tablo
 Clearance Date,Gümrükleme Tarih
 Clearance Date not mentioned,Gümrükleme Tarih belirtilmeyen
-Clearance date cannot be before check date in row {0},"Gümrükleme tarihi satırda ,onay tarihinden önce olamaz {0}"
+Clearance date cannot be before check date in row {0},Gümrükleme tarihi {0} satırındaki kontrol tarihinden önce olamaz
 Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Yeni Satış Faturası oluşturmak için 'Satış Fatura Yap' butonuna tıklayın.
-Click on a link to get options to expand get options ,Seçenekleri görmek ve açıklama almak için linke tıklayın.
+Click on a link to get options to expand get options ,Seçenekleri genişletmek için bağlantıya tıklayın
 Client,Müşteri:
-Close Balance Sheet and book Profit or Loss.,Bilanço belgesi ve kar-zarar kitabı
+Close Balance Sheet and book Profit or Loss.,Bilançoyu Kapat ve Kar veya Zararı ayır.
 Closed,Kapalı
 Closing (Cr),Kapanış (Cr)
 Closing (Dr),Kapanış (Dr)
 Closing Account Head,Kapanış Hesap Başkanı
-Closing Account {0} must be of type 'Liability',Hesap Kapanış {0} türü 'borçlu' olmalıdır.
+Closing Account {0} must be of type 'Liability',Kapanan Hesap {0} 'Yükümlülük' tipi olmalıdır
 Closing Date,Kapanış Tarihi
 Closing Fiscal Year,Mali Yılı Kapanış
 Closing Qty,Kapanış Adet
@@ -528,8 +528,8 @@
 Cold Calling,Soğuk Arama
 Color,Renk
 Column Break,Sütun Arası
-Comma separated list of email addresses,E-posta adreslerinin virgülle ayrılmış listesi
-Comment,Yorum
+Comma separated list of email addresses,E-mail adreslerinin virgülle ayrılmış listesi
+Comment,Yorum yap
 Comments,Yorumlar
 Commercial,Ticari
 Commission,Komisyon
@@ -547,7 +547,7 @@
 Company Abbreviation,Şirket Kısaltma
 Company Details,Şirket Detayı
 Company Email,Şirket e-posta
-"Company Email ID not found, hence mail not sent","Şirket e-posta kimliği bulunamadı, bu nedenle mail gönderilemedi"
+"Company Email ID not found, hence mail not sent","Şirket e-posta kimliği bulunamadı, mail gönderilemedi"
 Company Info,Şirket Bilgisi
 Company Name,Firma Adı
 Company Settings,Firma Ayarları
@@ -555,8 +555,8 @@
 Company is required,Firma gereklidir
 Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Referans için şirket kayıt numaraları. Örnek: KDV Sicil Numaraları vs
 Company registration numbers for your reference. Tax numbers etc.,Referans için şirket kayıt numaraları. Vergi numaraları vb
-"Company, Month and Fiscal Year is mandatory","Şirket, mali ay ve yıl için zorunludur."
-Compensatory Off,Telafi izni
+"Company, Month and Fiscal Year is mandatory","Şirket, Ay ve Mali Yıl zorunludur"
+Compensatory Off,Telafi İzni
 Complete,Tamamlandı
 Complete Setup,Kurulum Tamamlandı
 Completed,Tamamlandı
@@ -568,9 +568,9 @@
 Computers,Bilgisayarlar
 Confirmation Date,Onay Tarihi
 Confirmed orders from Customers.,Müşteriler Siparişi Onaylandı.
-Consider Tax or Charge for,Vergi veya Charge düşünün
-Considered as Opening Balance,Açılış bakiyesi olarak kabul edilmiş
-Considered as an Opening Balance,Bir Açılış bakiyesi olarak kabul edilmiş.
+Consider Tax or Charge for,Vergi veya Ücret
+Considered as Opening Balance,Açılış bakiyesi olarak kabul edilen
+Considered as an Opening Balance,Açılış bakiyesi olarak kabul edilen
 Consultant,Danışman
 Consulting,Danışmanlık
 Consumable,Tüketilir
@@ -580,24 +580,24 @@
 Consumer Products,Tüketici Ürünleri
 Contact,İletişim
 Contact Control,İletişim Kontrolü
-Contact Desc,İrtibat Kişisi Detaylar
+Contact Desc,İrtibat Desc
 Contact Details,İletişim Bilgileri
 Contact Email,İletişim E-Posta
 Contact HTML,İletişim HTML
 Contact Info,İletişim Bilgileri
-Contact Mobile No,Cep No
+Contact Mobile No,İrtibat Mobil No
 Contact Name,İletişim İsmi
 Contact No.,İletişim No
 Contact Person,İrtibat Kişi
-Contact Type,İletişim türü
+Contact Type,İrtibat Tipi
 Contact master.,İletişim ustası.
-Contacts,İletişimler
+Contacts,Kişiler
 Content,İçerik
 Content Type,İçerik Türü
 Contra Voucher,Contra Çeki
 Contract,Sözleşme
 Contract End Date,Sözleşme Bitiş Tarihi
-Contract End Date must be greater than Date of Joining,Sözleşme Bitiş Tarihi Katılma tarihinden daha büyük olmalıdır
+Contract End Date must be greater than Date of Joining,Sözleşme Bitiş tarihi Katılma tarihinden büyük olmalıdır
 Contribution (%),Katkı Payı (%)
 Contribution to Net Total,Net Toplam Katkı
 Conversion Factor,Katsayı
@@ -605,27 +605,27 @@
 Conversion factor cannot be in fractions,Dönüşüm faktörü kesirler olamaz
 Conversion factor for default Unit of Measure must be 1 in row {0},Tedbir varsayılan Birimi için dönüşüm faktörü satırda 1 olmalıdır {0}
 Conversion rate cannot be 0 or 1,Dönüşüm oranı 0 veya 1 olamaz
-Convert into Recurring Invoice,Tekrarlayan Faturaya dönüştürün
-Convert to Group,Gruba dönüştür
-Convert to Ledger,Muhasebe defterine dönüştür
+Convert into Recurring Invoice,Mükerrer faturaya dönüştür
+Convert to Group,Gruba Dönüştürmek
+Convert to Ledger,Ana deftere dönüştür
 Converted,Dönüştürülmüş
-Copy From Item Group,Ürün grubu kopyası
+Copy From Item Group,Ürün Grubundan kopyalayın
 Cosmetics,Bakım ürünleri
 Cost Center,Maliyet Merkezi
 Cost Center Details,Maliyet Merkezi Detayları
 Cost Center Name,Maliyet Merkezi Adı
 Cost Center is required for 'Profit and Loss' account {0},Maliyet Merkezi 'Kar ve Zarar hesabı için gerekli olan {0}
-Cost Center is required in row {0} in Taxes table for type {1},Maliyet Merkezi satırda gereklidir {0} Vergi tablosu tür için tabloda {1}
-Cost Center with existing transactions can not be converted to group,"Mevcut işlemli maliyet merkezi, gruba dönüştürülemez."
-Cost Center with existing transactions can not be converted to ledger,Mevcut işlemler ile maliyet Center defterine dönüştürülemez.
-Cost Center {0} does not belong to Company {1},Maliyet Merkezi {0} Şirkete ait değil {1}
+Cost Center is required in row {0} in Taxes table for type {1},Satır {0} da Vergiler Tablosunda tip {1} için Maliyet Merkezi gereklidir
+Cost Center with existing transactions can not be converted to group,Maliyet Merkezi mevcut işlemlere gruba dönüştürülemez
+Cost Center with existing transactions can not be converted to ledger,Maliyet Merkezi mevcut işlemlere ana deftere dönüştürülemez
+Cost Center {0} does not belong to Company {1},Maliyet Merkezi {0} Şirket {1} e ait değildir.
 Cost of Goods Sold,Satışların Maliyeti
 Costing,Maliyetlendirme
 Country,Ülke
 Country Name,Ülke Adı
-Country wise default Address Templates,Ülke bilge varsayılan Adres Şablonları
+Country wise default Address Templates,Ülke bilgisi varsayılan adres şablonları
 "Country, Timezone and Currency","Ülke, Saat Dilimi ve Döviz"
-Create Bank Voucher for the total salary paid for the above selected criteria,Yukarıda seçilen ölçütler için ödenen toplam maaş için Banka Çeki oluştur
+Create Bank Voucher for the total salary paid for the above selected criteria,Yukarıda seçilen kriterler için ödenen toplam maaşa Banka Dekontu oluştur
 Create Customer,Müşteri Oluştur
 Create Material Requests,Malzeme İstekleri Oluştur
 Create New,Yeni Oluştur
@@ -633,23 +633,23 @@
 Create Production Orders,Üretim Emirleri Oluştur
 Create Quotation,Teklif oluşturma
 Create Receiver List,Alıcı listesi oluşturma
-Create Salary Slip,Maaş kuponu oluştur
-Create Stock Ledger Entries when you submit a Sales Invoice,"Bir Satış Faturası gönderdiğinizde, muhasebe stok girdileri tasarlar."
-"Create and manage daily, weekly and monthly email digests.","Günlük, haftalık ve aylık mailler düzenleyin."
+Create Salary Slip,Maaş Makbuzu Oluştur
+Create Stock Ledger Entries when you submit a Sales Invoice,Satış Faturası verdiğinde Stok Ana Defter girdileri oluştur
+"Create and manage daily, weekly and monthly email digests.","Günlük, haftalık ve aylık e-posta özetleri oluştur."
 Create rules to restrict transactions based on values.,Değerlere dayalı işlemleri kısıtlamak için kurallar oluşturun.
-Created By,Oluşturan
-Creates salary slip for above mentioned criteria.,Yukarıda belirtilen kriterlere göre maaş slip oluşturur.
+Created By,Tarafından oluşturulan
+Creates salary slip for above mentioned criteria.,Yukarıda belirtilen kriterler için maaş makbuzu oluştur.
 Creation Date,Oluşturulma Tarihi
-Creation Document No,Kreasyon Belge No
-Creation Document Type,Kreasyon Belge Türü
+Creation Document No,Oluşturulan Belge Tarihi
+Creation Document Type,Oluşturulan Belge Türü
 Creation Time,Oluşturma Zamanı
 Credentials,Kimlik Bilgileri
 Credit,Kredi
 Credit Amt,Kredi Tutarı
 Credit Card,Kredi kartı
 Credit Card Voucher,Kredi Kartı Çeki
-Credit Controller,Kredi Kontrolör
-Credit Days,Kredi Gün
+Credit Controller,Kredi Kontrolü
+Credit Days,Kredi Günleri
 Credit Limit,Kredi Limiti
 Credit Note,Kredi mektubu
 Credit To,Kredi için
@@ -658,7 +658,7 @@
 Currency Name,Para Birimi Adı
 Currency Settings,Döviz Ayarları
 Currency and Price List,Döviz ve Fiyat Listesi
-Currency exchange rate master.,Döviz kuru oranı başkanı
+Currency exchange rate master.,Ana Döviz Kuru.
 Current Address,Mevcut Adresi
 Current Address Is,Güncel Adresi
 Current Assets,Mevcut Varlıklar
@@ -675,8 +675,8 @@
 Customer,Müşteri
 Customer (Receivable) Account,Müşteri (Alacak) Hesap
 Customer / Item Name,Müşteri / Ürün İsmi
-Customer / Lead Address,Müşteri / Sorumlu Adresi
-Customer / Lead Name,Müşteri / Sorumlu İsmi
+Customer / Lead Address,Müşteri / Adres
+Customer / Lead Name,Müşteri/ İlk isim
 Customer > Customer Group > Territory,Müşteri> Müşteri Grubu> Eyalet
 Customer Account Head,Müşteri Hesap Başkanı
 Customer Acquisition and Loyalty,Müşteri Edinme ve Sadakat
@@ -692,26 +692,26 @@
 Customer Group Name,Müşteri Grup Adı
 Customer Intro,Müşteri Giriş
 Customer Issue,Müşteri Sorunu
-Customer Issue against Serial No.,Seri Numarasına karşı Müşteri sayısı
+Customer Issue against Serial No.,Seri No karşılığı Müşteri Nüshası
 Customer Name,Müşteri Adı
-Customer Naming By,Müşteri ... tarafından adlandırılmaktadır.
+Customer Naming By,Adlandırılan Müşteri 
 Customer Service,Müşteri Hizmetleri
 Customer database.,Müşteri veritabanı.
 Customer is required,Müşteri gereklidir
 Customer master.,Müşteri usta.
-Customer required for 'Customerwise Discount','Customerwise İndirimi' için gerekli Müşteri
+Customer required for 'Customerwise Discount', 'Müşteri indirimi' için gereken müşteri
 Customer {0} does not belong to project {1},Müşteri {0} projeye ait değil {1}
 Customer {0} does not exist,Müşteri {0} yok
 Customer's Item Code,Müşterinin Ürün Kodu
 Customer's Purchase Order Date,Müşterinin Sipariş Tarihi
-Customer's Purchase Order No,Müşterinin Sipariş Numarası
+Customer's Purchase Order No,Müşterinin Sipariş numarası
 Customer's Purchase Order Number,Müşterinin Sipariş Numarası
-Customer's Vendor,Müşteri Satıcı
-Customers Not Buying Since Long Time,Müşteriler uzun zamandır alım yapmıyor.
-Customerwise Discount,Customerwise İndirim
+Customer's Vendor,Müşterinin Satıcısı
+Customers Not Buying Since Long Time,Uzun zamandır alım yapmamış Müşteriler
+Customerwise Discount,Müşteri İndirimi
 Customize,Özelleştirme
 Customize the Notification,Bildirim özelleştirin
-Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Bu e-posta bir parçası olarak gider tanıtım metni özelleştirin. Her işlem ayrı bir giriş metni vardır.
+Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"E-postanın bir parçası olarak giden giriş metnini özelleştirin, her işlemin ayrı giriş metni vardır"
 DN Detail,DN Detay
 Daily,Günlük
 Daily Time Log Summary,Günlük Saat Günlük Özet
@@ -720,602 +720,602 @@
 Date,Tarih
 Date Format,Tarih Biçimi
 Date Of Retirement,Emeklilik Tarihiniz
-Date Of Retirement must be greater than Date of Joining,"Emeklilik Tarihi, Katılma tarihinden daha büyük olmalıdır"
+Date Of Retirement must be greater than Date of Joining,Emeklilik Tarihi katılım tarihinden büyük olmalıdır
 Date is repeated,Tarih tekrarlanır
 Date of Birth,Doğum tarihi
 Date of Issue,Veriliş tarihi
 Date of Joining,Katılma Tarihi
-Date of Joining must be greater than Date of Birth,Katılma Tarihi Doğum tarihinden daha büyük olmalıdır
-Date on which lorry started from supplier warehouse,Tarih hangi kamyon tedarikçisi depodan başladı
-Date on which lorry started from your warehouse,Tarih hangi kamyon depo başladı
+Date of Joining must be greater than Date of Birth,Katılım Tarihi Doğum Tarihinden büyük olmalıdır
+Date on which lorry started from supplier warehouse,Kamyonun tedarikçi deposundan yola çıktığı tarih
+Date on which lorry started from your warehouse,Kamyonun deponuzdan yola çıktığı tarih
 Dates,Tarihler
-Days Since Last Order,Son siparişten bu yana geçen gün sayısı
-Days for which Holidays are blocked for this department.,Bu departmanın kapatılmadığı Tatil günleri
+Days Since Last Order,Son siparişten bu yana geçen günler
+Days for which Holidays are blocked for this department.,Bu departman için tatillerin kaldırıldığı günler.
 Dealer,Satıcı
 Debit,Borç
 Debit Amt,Bankamatik Tutarı
 Debit Note,Borç dekontu
-Debit To,Için Bankamatik
-Debit and Credit not equal for this voucher. Difference is {0}.,Borç ve kredi bu çek/senet için eşit değildir. Farklılık {0}.
+Debit To,Borç
+Debit and Credit not equal for this voucher. Difference is {0}.,Bu belge için Borç ve Alacak eşit değildir. Fark {0}
 Deduct,Düşmek
 Deduction,Kesinti
 Deduction Type,Kesinti Türü
-Deduction1,Kesinti1
+Deduction1,Kesinti 1
 Deductions,Kesintiler
 Default,Varsayılan
 Default Account,Varsayılan Hesap
 Default Address Template cannot be deleted,Varsayılan Adres Şablon silinemez
 Default Amount,Standart Tutar
-Default BOM,Standart Malzeme Listesi (ML)
-Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Bu mod seçildiğinde Varsayılan Banka / Kasa hesabı otomatik olarak POS faturada güncellenecektir.
+Default BOM,Standart BOM
+Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Bu mod seçildiğinde Varsayılan Banka / Kasa hesabı otomatik olarak POS Faturada güncellenecektir.
 Default Bank Account,Varsayılan Banka Hesabı
 Default Buying Cost Center,Standart Alış Maliyet Merkezi
 Default Buying Price List,Standart Alış Fiyat Listesi
 Default Cash Account,Standart Kasa Hesabı
-Default Company,Varsayılan Şirket
-Default Currency,Geçerli Para Birimi
+Default Company,Standart Firma
+Default Currency,Varsayılan Para Birimi
 Default Customer Group,Varsayılan Müşteri Grubu
-Default Expense Account,Varsayılan Gider Hesabı
-Default Income Account,Varsayılan Gelir Hesabı
-Default Item Group,Varsayılan Ürün Grubu
+Default Expense Account,Standart Gider Hesabı
+Default Income Account,Standart Gelir Hesabı
+Default Item Group,Standart Ürün Grubu
 Default Price List,Standart Fiyat Listesi
-Default Purchase Account in which cost of the item will be debited.,Standart Satın Alma Hesabı (ürünün maliyetinin borçlandırılacağı hesap)
+Default Purchase Account in which cost of the item will be debited.,Ürün maliyetinin borçlanılacağı Varsayılan satın alma hesabı.
 Default Selling Cost Center,Standart Satış Maliyet Merkezi
 Default Settings,Varsayılan Ayarlar
 Default Source Warehouse,Varsayılan Kaynak Deposu
-Default Stock UOM,Varsayılan Stok Ölçü BİRİMİ (OB)
+Default Stock UOM,Varsayılan Stok UOM
 Default Supplier,Standart Tedarikçi
-Default Supplier Type,Standart Tedarikçi Türü
-Default Target Warehouse,Varsayılan Hedef Deposu
-Default Territory,Standart Territory
-Default Unit of Measure,Varsayılan Ölçü Birimi (ÖB)
-"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Zaten başka UOM ile bazı işlem (ler) yaptık çünkü Ölçü Varsayılan Birim doğrudan değiştirilemez. Varsayılan uom değiştirmek için, Stok modülü altında 'UoM Faydalı değiştirin' aracını kullanın."
+Default Supplier Type,Standart Tedarikçii Türü
+Default Target Warehouse,Standart Hedef Depo
+Default Territory,Standart Bölge
+Default Unit of Measure,Varsayılan Ölçü Birimi
+"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.",Varsayılan ölçü birimi doğrudan değiştirilemez çünkü diğer UOM ile zaten başka işlemler yapmış durumdasınız. Varsayılan UOM'u değiştirmek için Stok Modülü altındaki 'UOM Değiştirme Aracını' kullanın.
 Default Valuation Method,Standart Değerleme Yöntemi
 Default Warehouse,Standart Depo
-Default Warehouse is mandatory for stock Item.,Standart Depo stok Ürün için zorunludur.
-Default settings for accounting transactions.,Muhasebe işlemleri için varsayılan ayarlar.
-Default settings for buying transactions.,Işlemleri satın almak için varsayılan ayarlar.
-Default settings for selling transactions.,Satımın için varsayılan ayarlar.
-Default settings for stock transactions.,Hisse senedi işlemleri için varsayılan ayarlar.
+Default Warehouse is mandatory for stock Item.,Standart Depo stok Ürünleri için zorunludur.
+Default settings for accounting transactions.,Muhasebe işlemleri için Varsayılan ayarlar.
+Default settings for buying transactions.,Alış İşlemleri için Varsayılan ayarlar.
+Default settings for selling transactions.,Satış İşlemleri için  Varsayılan ayarlar.
+Default settings for stock transactions.,Stok işlemleri için Varsayılan ayarlar.
 Defense,Savunma
-"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Bu Maliyet Merkezi için Bütçe tanımlayın. Bütçe eylemi ayarlamak için, bir href <bakın = ""#!Liste / Şirket ""> Şirket Usta </ ​​a>"
-Del,Del
-Delete,Silmek
+"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Bu Maliyet Merkezi için Bütçe tanımlayın. Bütçe eylemi ayarlamak için, bir href <bakın = ""#!List/Company ""> Şirket Alanı </ ​​a>"
+Del,Sil
+Delete,Sil
 Delete {0} {1}?,Sil {0} {1}?
-Delivered,Teslim edildi
-Delivered Items To Be Billed,Faturalanmış teslim edilen ürünler
-Delivered Qty,Teslim Miktarı
+Delivered,Teslim Edildi
+Delivered Items To Be Billed,Faturalanacak Teslim edilen Ürünler
+Delivered Qty,Teslim Edilen Miktar
 Delivered Serial No {0} cannot be deleted,Teslim Seri No {0} silinemez
-Delivery Date,Teslim Tarihi
-Delivery Details,Teslimat Detayları
-Delivery Document No,Teslimat Belge No
+Delivery Date,Teslimat Tarihi
+Delivery Details,Teslim Bilgileri
+Delivery Document No,Teslim Belge No
 Delivery Document Type,Teslim Belge Türü
-Delivery Note,Teslim Alındı ​​fişi
-Delivery Note Item,Teslimat Not Ürünler
-Delivery Note Items,Teslimat Not Ürünler
-Delivery Note Message,Teslimat Not İleti
-Delivery Note No,Teslimat Not No
-Delivery Note Required,Teslimat Not Gerekli
-Delivery Note Trends,İrsaliye Trendler
-Delivery Note {0} is not submitted,İrsaliye {0} teslim edilmez
+Delivery Note,İrsaliye
+Delivery Note Item,Ürün İrsaliyesi
+Delivery Note Items,İrsaliye Ürünleri
+Delivery Note Message,İrsaliye Mesajı
+Delivery Note No,İrsaliye No
+Delivery Note Required,İrsaliye Gerekli
+Delivery Note Trends,İrsaliye Eğilimleri;
+Delivery Note {0} is not submitted,İrsaliye {0} teslim edilmedi
 Delivery Note {0} must not be submitted,İrsaliye {0} teslim edilmemelidir
-Delivery Notes {0} must be cancelled before cancelling this Sales Order,Teslim Notları {0} bu Satış Siparişi iptal etmeden önce iptal edilmelidir
-Delivery Status,Teslimat Durumu
-Delivery Time,Teslim Süresi
-Delivery To,Için teslim
+Delivery Notes {0} must be cancelled before cancelling this Sales Order,Satış Emri iptal edilmeden önce İrsaliyeler {0} iptal edilmelidir
+Delivery Status,Teslim Durumu
+Delivery Time,Teslimat süresi
+Delivery To,Teslim
 Department,Departman
-Department Stores,Alışveriş Merkezleri
-Depends on LWP,Depends on LWP
+Department Stores,Departman mağazaları
+Depends on LWP,LWP'ye bağlı
 Depreciation,Amortisman
-Description,Tanım
+Description,Açıklama
 Description HTML,Açıklama HTML
 Designation,Atama
-Designer,Tasarlayıcı
-Detailed Breakup of the totals,Toplamlarının Ayrıntılı Dağılımı
+Designer,Tasarımcı
+Detailed Breakup of the totals,Toplamların detaylı dağılımı
 Details,Ayrıntılar
 Difference (Dr - Cr),Fark (Dr - Cr)
 Difference Account,Fark Hesabı
-"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Bu Stok Uzlaşma bir açılış girdisi olduğundan Fark Hesabı, bir 'Sorumluluk' tipi hesabı olmalıdır"
-Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Öğeler için farklı UOM yanlış (Toplam) Net Ağırlık değerine yol açacaktır. Her öğenin Net Ağırlık aynı UOM olduğundan emin olun.
+"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry",Fark hesabı bir 'Sorumluluk' tipi hesap olmalıdır.
+Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Ürünler için farklı UOM yanlış (Toplam) net ağırlıklı değere yol açacaktır. Net ağırlıklı değerin aynı olduğundan emin olun.
 Direct Expenses,Doğrudan Giderler
 Direct Income,Doğrudan Gelir
-Disable,Devre dışı bırak
+Disable,Devre Dışı Bırak
 Disable Rounded Total,Yuvarlak toplam devre dışı
-Disabled,Pasif
+Disabled,Devredışı
 Discount  %,İndirim%
 Discount %,İndirim%
 Discount (%),İndirim (%)
 Discount Amount,İndirim Tutarı
-"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","İndirim Alanlar Sipariş, Satın Alma Makbuzu, Satınalma Fatura sunulacak"
+"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","İndirim Alanları Satın alma Emrinde, Satın alma makbuzunda, satın alma faturasında mevcut olacaktır"
 Discount Percentage,İndirim Yüzdesi
-Discount Percentage can be applied either against a Price List or for all Price List.,İndirim Yüzde Fiyat Listesi karşı veya tüm Fiyat Listesi için ya uygulanabilir.
-Discount must be less than 100,İndirim az 100 olmalıdır
+Discount Percentage can be applied either against a Price List or for all Price List.,İndirim Yüzdesi bir Fiyat listesine veya bütün fiyat listelerine karşı uygulanabilir.
+Discount must be less than 100,İndirim 100'den az olmalıdır
 Discount(%),İndirim (%)
 Dispatch,Sevk
-Display all the individual items delivered with the main items,Ana ürün ile birlikte olan tüm tekil ürünleri görüntüler
-Distribute transport overhead across items.,Distribute transport overhead across items.
+Display all the individual items delivered with the main items,Taşıma yükünü Ürünlere dağıt
+Distribute transport overhead across items.,Taşıma yükünü Ürünlere dağıt.
 Distribution,Dağıtım
 Distribution Id,Dağıtım Kimliği
 Distribution Name,Dağıtım Adı
-Distributor,Dağıtıcı
-Divorced,Boşanmış
-Do Not Contact,İletişim Etmeyin
-Do not show any symbol like $ etc next to currencies.,Sonraki paralara $ vb gibi herhangi bir sembol görünmüyor.
-Do really want to unstop production order: ,Do really want to unstop production order: 
-Do you really want to STOP ,Do you really want to STOP 
-Do you really want to STOP this Material Request?,Eğer gerçekten bu Malzeme İsteği durdurmak istiyor musunuz?
-Do you really want to Submit all Salary Slip for month {0} and year {1},Eğer gerçekten {0} ve yıl {1} ​​ay boyunca tüm Maaş Kayma Gönder istiyor musunuz
-Do you really want to UNSTOP ,Do you really want to UNSTOP 
-Do you really want to UNSTOP this Material Request?,Eğer gerçekten bu Malzeme İsteği unstop istiyor musunuz?
-Do you really want to stop production order: ,Do you really want to stop production order: 
-Doc Name,Doküman Adı
-Doc Type,Dok Türü
-Document Description,Belge Açıklama
+Distributor,Dağıtımcı
+Divorced,Ayrılmış
+Do Not Contact,İrtibata Geçmeyin
+Do not show any symbol like $ etc next to currencies.,Para birimlerinin yanında $ vb semboller kullanmayın.
+Do really want to unstop production order: ,Üretim emrini gerçekten durdurmak istiyor musunuz?
+Do you really want to STOP ,Gerçekten durmak istiyor musunuz
+Do you really want to STOP this Material Request?,Malzeme isteğini gerçekten durdurmak istiyor musunuz
+Do you really want to Submit all Salary Slip for month {0} and year {1},Gerçekten ay {0} ve yıl {1} için Maaş Makbuzu vermek istiyor musunuz
+Do you really want to UNSTOP ,Gerçekten durdurmaktan vazgeçmek istiyor musunuz
+Do you really want to UNSTOP this Material Request?,Bu Malzeme isteğini durdurmaktan gerçekten vazgeçmek istiyor musunuz?
+Do you really want to stop production order: ,Üretim emrini gerçekten durdurmak istiyor musunuz?
+Doc Name,Doküman adı
+Doc Type,Doküman Türü
+Document Description,Belge Tanımı
 Document Type,Belge Türü
-Documents,Evraklar
+Documents,Belgeler
 Domain,Etki Alanı
-Don't send Employee Birthday Reminders,Çalışan Doğum Günü Hatırlatmalar göndermek yok
-Download Materials Required,Gerekli Malzemeler indirin
-Download Reconcilation Data,Mutabakatı veri indir
-Download Template,Şablon İndir
-Download a report containing all raw materials with their latest inventory status,En son envanter durumu ile tüm hammadde içeren bir rapor indirin
-"Download the Template, fill appropriate data and attach the modified file.","Şablon indir, uygun veri doldurmak ve değiştirilmiş dosya eklemek."
-"Download the Template, fill appropriate data and attach the modified file.All dates and employee combination in the selected period will come in the template, with existing attendance records","Şablon indir, uygun veri doldurmak ve değiştirilmiş dosya eklemek. Seçilen dönemde tüm tarihler ve çalışanların kombinasyon mevcut katılım kayıtları ile, şablonda gelecek"
+Don't send Employee Birthday Reminders,Çalışanların Doğumgünü Hatırlatmalarını gönderme
+Download Materials Required,Gerekli Malzemeleri indirin
+Download Reconcilation Data,Mutabakat verilerini indir
+Download Template,Şablonu İndir
+Download a report containing all raw materials with their latest inventory status,En son stok durumu ile bütün ham maddeleri içeren bir rapor indir
+"Download the Template, fill appropriate data and attach the modified file.","Şablonu indir, uygun verileri gir ve düzenlenen dosyayı ekle."
+"Download the Template, fill appropriate data and attach the modified file.All dates and employee combination in the selected period will come in the template, with existing attendance records","Şablonu indir, uygun verileri gir ve düzenlenen dosyayı ekle, seçilen dönem için bütün tarih ve çalışan kombinasyonları mevcut devam kayıtları ile şablona geçecektir."
 Draft,Taslak
 Dropbox,Dropbox
-Dropbox Access Allowed,İzin Dropbox Erişim
+Dropbox Access Allowed,Dropbox Erişimine İzin verildi
 Dropbox Access Key,Dropbox Erişim Anahtarı
-Dropbox Access Secret,Dropbox Erişim Gizli
-Due Date,Due Date
-Due Date cannot be after {0},Due Date sonra olamaz {0}
-Due Date cannot be before Posting Date,Due Date tarihi gönderdiği önce olamaz
+Dropbox Access Secret,Dropbox Erişimi Gizli
+Due Date,Bitiş tarihi
+Due Date cannot be after {0},bitiş tarihi şundan sonra olamaz {0}
+Due Date cannot be before Posting Date,Bitiş Tarihi gönderim tarihinden önce olamaz
 Duplicate Entry. Please check Authorization Rule {0},Girişi çoğaltın. Yetkilendirme Kuralı kontrol edin {0}
 Duplicate Serial No entered for Item {0},Çoğaltın Seri No Ürün için girilen {0}
-Duplicate entry,Girişini çoğaltmak
-Duplicate row {0} with same {1},Yinelenen satır {0} ile aynı {1}
-Duties and Taxes,Görev ve Vergiler
-ERPNext Setup,ERPNext Kur
+Duplicate entry,Girdiyi Kopyala
+Duplicate row {0} with same {1},Satır {0} ı  {1} ile aynı biçimde kopyala
+Duties and Taxes,Harç ve Vergiler
+ERPNext Setup,ERPNext Kurulum
 Earliest,En erken
 Earnest Money,Kaparo
-Earning,Kazanç
-Earning & Deduction,Kazanç & Kesintisi
-Earning Type,Kazanç Tipi
-Earning1,Earning1
+Earning,Kazanma
+Earning & Deduction,Kazanma & Kesintisi
+Earning Type,Kazanç Türü
+Earning1,Kazanç1
 Edit,Düzenle
-Edu. Cess on Excise,Edu. Vergi ile ilgili Cess
-Edu. Cess on Service Tax,Edu. Hizmet Vergisi Cess
-Edu. Cess on TDS,Edu. TDS ile ilgili Cess
+Edu. Cess on Excise,Edu. Vergi alımı
+Edu. Cess on Service Tax,Hizmet Vergisinde Edu Vergisi
+Edu. Cess on TDS,Edu. TDS 'de EDU Vergisi
 Education,Eğitim
-Educational Qualification,Eğitim Kalifikasyonu
-Educational Qualification Details,Eğitim Kalifikasyon Ayrıntıları
-Eg. smsgateway.com/api/send_sms.cgi,Örn. smsgateway.com / api / send_sms.cgi
-Either debit or credit amount is required for {0},Banka veya kredi tutarı Ya için gereklidir {0}
-Either target qty or target amount is mandatory,Hedef Adet Adet veya hedef tutar Ya zorunludur
-Either target qty or target amount is mandatory.,Hedef Adet Adet veya hedef tutar Ya zorunludur.
+Educational Qualification,Eğitim Yeterliliği
+Educational Qualification Details,Eğtim Yeterlilik Detayları
+Eg. smsgateway.com/api/send_sms.cgi,Örn. msgateway.com / api / send_sms.cgi
+Either debit or credit amount is required for {0},{0} için borç ya da kredi hesabı gereklidir
+Either target qty or target amount is mandatory,Hedef miktarı veya hedef tutarı zorunludur
+Either target qty or target amount is mandatory.,Hedef miktarı veya hedef tutarı zorunludur.
 Electrical,Elektrik
 Electricity Cost,Elektrik Maliyeti
 Electricity cost per hour,Saat başına elektrik maliyeti
 Electronics,Elektronik
-Email,E-posta
-Email Digest,E-Posta Özeti
-Email Digest Settings,E-posta Yayını Ayarları
-Email Digest: ,Email Digest: 
+Email,E-posta;
+Email Digest,E-Mail Bülteni
+Email Digest Settings,E-Mail Bülteni ayarları
+Email Digest: ,E-Mail Bülteni:
 Email Id,E-posta Kimliği
-"Email Id where a job applicant will email e.g. ""jobs@example.com""","Bir iş başvurusu e-posta göndereceğiz E-posta Kimliği örneğin ""jobs@example.com"""
+"Email Id where a job applicant will email e.g. ""jobs@example.com""","İş başvurusu yapacakların kullacağı e-posta adresi, örneğin ""jobs@example.com"""
 Email Notifications,E-posta Bildirimleri
-Email Sent?,Gönderilen e-posta?
-"Email id must be unique, already exists for {0}","E-posta id benzersiz olmalıdır, zaten var {0}"
-Email ids separated by commas.,E-posta kimlikleri virgülle ayırarak.
-"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","Satış e-posta id örneğin ""sales@example.com"" den İlanlar ayıklamak için e-posta ayarları"
-Emergency Contact,Acil İletişim
-Emergency Contact Details,Acil İletişim Detayları
+Email Sent?,Email Gönderildi mi?
+"Email id must be unique, already exists for {0}","E-posta yeni olmalıdır, {0} için zaten mevcut"
+Email ids separated by commas.,E-posta kimlikleri virgülle ayrılıyor.
+"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","Satış e-posta kimliğinden satışları çekmek için e-mail ayarları, örneğin ""sales@example.com"""
+Emergency Contact,Acil Durum İrtibat Kişisi
+Emergency Contact Details,Acil Durum İrtibat Kişisi Bilgileri
 Emergency Phone,Acil Telefon
 Employee,Çalışan
 Employee Birthday,Çalışan Doğum Günü
-Employee Details,Çalışan Ayrıntıları
-Employee Education,Çalışan Eğitim
-Employee External Work History,Çalışan Dış İş Geçmişi
-Employee Information,Çalışan Bilgi
-Employee Internal Work History,Çalışan İç Çalışma Planları
-Employee Internal Work Historys,Çalışan İç Çalışma geçmişi
-Employee Leave Approver,Çalışan bırak Approver
-Employee Leave Balance,Çalışan bırak Dengesi
+Employee Details,Çalışan Bilgileri
+Employee Education,Çalışan Eğitimi
+Employee External Work History,Çalışan Harici İş Geçmişi
+Employee Information,Çalışan Bilgileri
+Employee Internal Work History,Çalışan Dahili İş Geçmişi
+Employee Internal Work Historys,Çalışan Dahili İş Geçmişi
+Employee Leave Approver,Çalışan izin Onayı
+Employee Leave Balance,Çalışanın Kalan İzni
 Employee Name,Çalışan Adı
-Employee Number,Çalışan No
-Employee Records to be created by,Çalışan Records tarafından oluşturulacak
+Employee Number,Çalışan sayısı
+Employee Records to be created by,Oluşturulacak Çalışan Kayıtları
 Employee Settings,Çalışan Ayarları
 Employee Type,Çalışan Tipi
-"Employee designation (e.g. CEO, Director etc.).","Çalışan atama (ör. CEO, Müdür vb.)"
-Employee master.,Çalışan usta.
-Employee record is created using selected field. ,Çalışan kayıt seçili alanını kullanarak oluşturulur.
+"Employee designation (e.g. CEO, Director etc.).","Çalışan görevi (ör. CEO, Müdür vb.)"
+Employee master.,Ana Çalışan.
+Employee record is created using selected field. ,Çalışan kaydı seçilen alan kullanılarak yapılmıştır
 Employee records.,Çalışan kayıtları.
-Employee relieved on {0} must be set as 'Left',{0} üzerinde rahatlamış Çalışan 'Sol' olarak ayarlanmış olmalıdır
-Employee {0} has already applied for {1} between {2} and {3},Çalışan {0} zaten arasındaki {1} için başvurdu {2} ve {3}
-Employee {0} is not active or does not exist,Çalışan {0} aktif değil veya yok
-Employee {0} was on leave on {1}. Cannot mark attendance.,Çalışan {0} {1} tarihinde izinli oldu. Katılım işaretlemek olamaz.
-Employees Email Id,Çalışan E-posta Kimliği
+Employee relieved on {0} must be set as 'Left',"{0} üzerinde bırakılan işçi 'ayrılı' olarak ayarlanmalıdır"""
+Employee {0} has already applied for {1} between {2} and {3},Çalışan {0} hali hazırda  {2} ve {3} arasında {1} için başvurmuştur
+Employee {0} is not active or does not exist,Çalışan {0} aktif değil veya yok.
+Employee {0} was on leave on {1}. Cannot mark attendance.,Çalışan {0} {1} tarihinde izinli oldu. Katılım işaretlenemez.
+Employees Email Id,Çalışanların e-posta adresleri
 Employment Details,İstihdam Detayları
 Employment Type,İstihdam Tipi
-Enable / disable currencies.,Para birimi etkinleştirin / devre dışı bırakın.
+Enable / disable currencies.,/ Para birimlerini etkinleştir/devre dışı bırak.
 Enabled,Etkin
-Encashment Date,Nakde Çevrilme Tarihi
+Encashment Date,Nakit Çekim Tarihi
 End Date,Bitiş Tarihi
-End Date can not be less than Start Date,"Bitiş Tarihi, Başlangıç ​​Tarihinden daha az olamaz"
-End date of current invoice's period,Cari faturanın dönem sonu tarihi
-End of Life,End of Life
+End Date can not be less than Start Date,"Bitiş Tarihi, Başlangıç Tarihinden daha az olamaz"
+End date of current invoice's period,Cari fatura döneminin bitiş tarihi
+End of Life,Kullanım süresi Sonu
 Energy,Enerji
 Engineer,Mühendis
 Enter Verification Code,Doğrulama kodunu girin
-Enter campaign name if the source of lead is campaign.,Enter campaign name if the source of lead is campaign.
-Enter department to which this Contact belongs,Enter department to which this Contact belongs
-Enter designation of this Contact,Enter designation of this Contact
-"Enter email id separated by commas, invoice will be mailed automatically on particular date","Virgülle ayrılmış e-posta id girin, fatura belirli bir tarihte otomatik olarak gönderilecek olacak"
-Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.
-Enter name of campaign if source of enquiry is campaign,Enter name of campaign if source of enquiry is campaign
-"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Burada statik url parametreleri girin (Örn. gönderen = ERPNext, username = ERPNext, şifre = 1234 vb)"
-Enter the company name under which Account Head will be created for this Supplier,Enter the company name under which Account Head will be created for this Supplier
-Enter url parameter for message,Enter url parameter for message
-Enter url parameter for receiver nos,Enter url parameter for receiver nos
+Enter campaign name if the source of lead is campaign.,Eğer baş kaynak kampanya ise kampanya adı girin.
+Enter department to which this Contact belongs,Bu irtibatın ait olduğu departmanı girin
+Enter designation of this Contact,Bu irtibatın görevini girin
+"Enter email id separated by commas, invoice will be mailed automatically on particular date","Virgülle ayrılmış e-posta kimliklerini girin, fatura belirli bir tarihte otomatik olarak gönderilecek"
+Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Kendisi için üretim emri vermek istediğiniz Malzemeleri girin veya analiz için ham maddeleri indirin.
+Enter name of campaign if source of enquiry is campaign,Sorgu kaynağı kampanya ise kampanya adı girin
+"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Buraya statik url parametreleri girin (Örn. gönderen = ERPNext, kullanıcı adı = ERPNext, Şifre = 1234 vb)"
+Enter the company name under which Account Head will be created for this Supplier,Bu Tedarikçi için Hesap başlığının oluşturulacağı şirket adını girin
+Enter url parameter for message,Mesaj için url parametresi girin
+Enter url parameter for receiver nos,Alıcı numaraları için url parametresi girin
 Entertainment & Leisure,Eğlence ve Boş Zaman
 Entertainment Expenses,Eğlence Giderleri
-Entries,Entries
-Entries against ,Entries against 
-Entries are not allowed against this Fiscal Year if the year is closed.,Entries are not allowed against this Fiscal Year if the year is closed.
+Entries,Girdiler
+Entries against ,karşı girdiler
+Entries are not allowed against this Fiscal Year if the year is closed.,Yıl kapandı ise bu mali yıla karşı girdilere izin verilmez.
 Equity,Özkaynak
 Error: {0} > {1},Hata: {0}> {1}
 Estimated Material Cost,Tahmini Malzeme Maliyeti
-"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","En yüksek önceliğe sahip birden Fiyatlandırması Kuralları olsa bile, o zaman aşağıdaki iç öncelikler uygulanır:"
+"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Eğer yüksek öncelikli birden çok Fiyatlandırma Kuralı varsa, şu iç öncelikler geçerli olacaktır."
 Everyone can read,Herkes okuyabilir
-"Example: ABCD.#####If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.",". Örnek: ABCD # # # # #  serisi ayarlanır ve Seri No işlemlerde söz değilse, o zaman otomatik seri numarası bu dizi dayalı oluşturulur. Eğer her zaman açıkça bu öğe için Seri Nos bahsetmek istiyorum. Bu boş bırakın."
-Exchange Rate,Döviz kuru
+"Example: ABCD.#####If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Örnek: ABCD #####vserisi ayarlanmıştır ve işlemlerde seri no belirtilmemiştir, bu durumda bu seriye dayalı olarak otomatik seri no oluşturulacaktır. Eğer bu Ürün için seri numaralarını her zaman ayrıca belirtmek istiyorsanız boş bırakın."
+Exchange Rate,Döviz Kuru
 Excise Duty 10,Özel Tüketim Vergisi 10
-Excise Duty 14,Özel Tüketim Vergisi 14
-Excise Duty 4,Tüketim Vergisi 4
-Excise Duty 8,ÖTV 8
-Excise Duty @ 10,@ 10 Özel Tüketim Vergisi
-Excise Duty @ 14,14 @ ÖTV
-Excise Duty @ 4,@ 4 Özel Tüketim Vergisi
+Excise Duty 14,Özel Tüketim Vergisi  14
+Excise Duty 4,Özel Tüketim Vergisi 4
+Excise Duty 8,Özel Tüketim Vergisi  8
+Excise Duty @ 10,@ 10 Özel Tüketim Vergisi 
+Excise Duty @ 14,14 @ Özel Tüketim Vergisi
+Excise Duty @ 4,@ 4 Özel Tüketim Vergisi 
 Excise Duty @ 8,@ 8 Özel Tüketim Vergisi
-Excise Duty Edu Cess 2,ÖTV Edu Cess 2
-Excise Duty SHE Cess 1,ÖTV SHE Cess 1
+Excise Duty Edu Cess 2,Özel Tüketim Vergisi  Edu Cess 2
+Excise Duty SHE Cess 1,Özel Tüketim Vergisi SHE Cess 1
 Excise Page Number,Tüketim Sayfa Numarası
-Excise Voucher,Tüketim Çeki
+Excise Voucher,Vergi Dekontu
 Execution,Yerine Getirme
-Executive Search,Executive Search
-Exemption Limit,Muafiyet Sınırı
+Executive Search,Yürütücü Arama
+Exemption Limit,Muafiyet Limiti
 Exhibition,Sergi
 Existing Customer,Mevcut Müşteri
 Exit,Çıkış
-Exit Interview Details,Röportaj Ayrıntılar Çık
+Exit Interview Details,Çıkış Görüşmesi Detayları
 Expected,Beklenen
-Expected Completion Date can not be less than Project Start Date,Beklenen Bitiş Tarihi Proje Başlangıç ​​Tarihi az olamaz
-Expected Date cannot be before Material Request Date,Beklenen Tarih Malzeme Talep Tarihi önce olamaz
+Expected Completion Date can not be less than Project Start Date,Beklenen Bitiş Tarihi Proje Başlangıç Tarihinden az olamaz
+Expected Date cannot be before Material Request Date,Beklenen Tarih Malzeme Talep Tarihinden önce olamaz
 Expected Delivery Date,Beklenen Teslim Tarihi
-Expected Delivery Date cannot be before Purchase Order Date,Beklenen Teslim Tarihi Sipariş Tarihinden önce olamaz
-Expected Delivery Date cannot be before Sales Order Date,Beklenen Teslim Tarihi önce Satış Sipariş Tarihi olamaz
+Expected Delivery Date cannot be before Purchase Order Date,Beklenen Teslim Tarihi Siparii Tarihinden önce olamaz
+Expected Delivery Date cannot be before Sales Order Date,Beklenen Teslim Tarihi satış siparişi tarihinden önce olamaz
 Expected End Date,Beklenen Bitiş Tarihi
-Expected Start Date,Beklenen Başlangıç ​​Tarihi
+Expected Start Date,Beklenen BaşlangıçTarihi
 Expense,Gider
-Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Gider / Farkı hesabı ({0}), bir 'Kar veya Zarar' hesabı olmalıdır"
+Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Gider / Fark hesabı({0}), bir 'Kar veya Zarar' hesabı olmalıdır"
 Expense Account,Gider Hesabı
 Expense Account is mandatory,Gider Hesabı zorunludur
 Expense Claim,Gider Talebi
-Expense Claim Approved,Gideri Talep Onaylandı
-Expense Claim Approved Message,Gideri Talep Mesaj Onaylı
-Expense Claim Detail,Gideri Talep Detayı
-Expense Claim Details,Gideri Talep Detayları
-Expense Claim Rejected,Gideri Talebi Reddedildi
-Expense Claim Rejected Message,Gideri Talep İleti Reddedildi
-Expense Claim Type,Gideri Talep Türü
-Expense Claim has been approved.,Gideri Talep onaylandı.
-Expense Claim has been rejected.,Gideri Talep reddedildi.
-Expense Claim is pending approval. Only the Expense Approver can update status.,Gideri Talep onayı bekliyor. Sadece Gider Approver durumunu güncelleyebilirsiniz.
-Expense Date,Gideri Tarih
+Expense Claim Approved,Gideri Talebi Onaylandı
+Expense Claim Approved Message,Gideri Talebi Onay Mesajı
+Expense Claim Detail,Gideri Talebi Detayı
+Expense Claim Details,Gider Talebi Detayları
+Expense Claim Rejected,Gider Talebi Reddedildi
+Expense Claim Rejected Message,Gider Talebi Reddedildi Mesajı
+Expense Claim Type,Gideri Talebi Türü
+Expense Claim has been approved.,Gideri Talebi onaylandı.
+Expense Claim has been rejected.,Gideri Talebi reddedildi.
+Expense Claim is pending approval. Only the Expense Approver can update status.,Gider Talebi onay bekliyor. Yalnızca Gider yetkilisi durumu güncelleyebilir.
+Expense Date,Gider Tarih
 Expense Details,Gider Detayları
-Expense Head,Gideri Hesabı
-Expense account is mandatory for item {0},Gider hesap kalemi için zorunludur {0}
-Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Gider veya Fark hesabı zorunludur Ürün için {0} etkilediğini genel stok değeri olarak
+Expense Head,Gider Başlığı
+Expense account is mandatory for item {0},Ürün {0} için gider hesabı zorunludur
+Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Ürün {0} için gider veya fark hesabı bütün stok değerini etkilediği için zorunludur
 Expenses,Giderler
-Expenses Booked,Giderleri rezervasyonu
-Expenses Included In Valuation,Giderleri Değerleme Dahil
-Expenses booked for the digest period,Sindirmek dönemi için rezervasyonu Giderleri
-Expiry Date,Son Kullanma Tarihi
+Expenses Booked,Ayrılan giderler
+Expenses Included In Valuation,Değerlemeye dahil giderler
+Expenses booked for the digest period,Özet dönemi için ayrılan giderler
+Expiry Date,Son kullanma tarihi
 Exports,İhracat
-External,Dış
-Extract Emails,E-postalar ayıklayın
-FCFS Rate,FCFS Rate
-Failed: ,Failed: 
-Family Background,Aile Arka Plan
+External,Harici
+Extract Emails,E-postalar çıkarın
+FCFS Rate,FCFS Oranı
+Failed: ,Başarısız: 
+Family Background,Aile Geçmişi
 Fax,Faks
-Features Setup,Özellikler Kurulum
-Feed,Beslemek
+Features Setup,Özellik  Kurulumu
+Feed,Besleme
 Feed Type,Besleme Türü
-Feedback,Geribesleme
+Feedback,Geri bildirim
 Female,Kadın
-Fetch exploded BOM (including sub-assemblies),(Alt-montajlar dahil) patladı BOM Fetch
-"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","İrsaliye, Teklif, Satış Fatura, Satış Siparişi kullanılabilir alan"
-Files Folder ID,Dosyalar Klasör Kimliği
-Fill the form and save it,Formu doldurun ve bunu kaydetmek
-Filter based on customer,Müşteri filtre
-Filter based on item,Ürün filtre
-Financial / accounting year.,Finans / Muhasebe yıl.
-Financial Analytics,Finansal Analytics
+Fetch exploded BOM (including sub-assemblies),(Alt-montajlar dahil) patlamış BOM'ları getir
+"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","İrsaliye, Teklif, Satış Faturası, Satış Siparişinde kullanılabilir alan"
+Files Folder ID,Dosya klasörü kimliği
+Fill the form and save it,Formu doldurun ve kaydedin
+Filter based on customer,Müşteriye dayalı filtre
+Filter based on item,Ürüne dayalı filtre
+Financial / accounting year.,Mali / Muhasebe yılı.
+Financial Analytics,Mali Analitik
 Financial Services,Finansal Hizmetler
 Financial Year End Date,Mali Yıl Bitiş Tarihi
-Financial Year Start Date,Mali Yıl Başlangıç ​​Tarihi
+Financial Year Start Date,Mali Yıl Başlangıç Tarihi
 Finished Goods,Mamüller
 First Name,Ad
-First Responded On,İlk Yanıtlanan
-Fiscal Year,Mali Yıl
-Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Mali Yılı Başlangıç ​​Tarihi ve Mali Yıl Bitiş Tarihi zaten Mali Yılı ayarlanır {0}
-Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Mali Yılı Başlangıç ​​Tarihi ve Mali Yıl Bitiş Tarihi dışında bir yıldan fazla olamaz.
-Fiscal Year Start Date should not be greater than Fiscal Year End Date,Mali Yıl Başlangıç ​​Tarihi Mali Yıl Sonu tarihden olmamalıdır
-Fixed Asset,Sabit Kıymet
+First Responded On,İlk cevap verilen
+Fiscal Year,Mali yıl
+Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Mali Yıl {0} da Mali Yıl Başlangıç Tarihi ve Mali Yıl Bitiş Tarihi zaten ayarlanmış
+Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Mali Yıl Bitişi ve Başlangıcı arasında bir yıldan fazla zaman olamaz.
+Fiscal Year Start Date should not be greater than Fiscal Year End Date,Mali Yıl başlangıç tarihi Mali Yıl bitiş tarihinden ileri olmamalıdır
+Fixed Asset,Sabit Varlık
 Fixed Assets,Duran Varlıklar
 Follow via Email,E-posta ile takip
-"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.","Maddeleri alt iseniz aşağıdaki tablo değerleri gösterecektir - daralmıştır. Bu değerler alt ""Malzeme Listesi"" nin ustadan getirilecek - öğeleri sözleşmeli."
+"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.","Aşağıdaki tablo Malzemeler alt sözleşmeye bağlı ise değerleri gösterecektir. Bu değerler alt sözleşmeye bağlı Malzemelerin ""Malzeme Faturalarından"" getirilecektir."
 Food,Yiyecek Grupları
 "Food, Beverage & Tobacco","Gıda, İçecek ve Tütün"
-"For 'Sales BOM' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","'Satış BOM' öğeleri, Depo, Seri No ve Toplu Hayır 'Paketleme Listesi' tablosundan kabul edilecektir. Depo ve Toplu Hayır herhangi bir 'Satış BOM' öğe için tüm ambalaj öğeler için aynı ise, bu değerler ana Öğe tabloda girilebilir, değerler 'Ambalaj' List tabloya kopyalanır."
+"For 'Sales BOM' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","'Satış BOM Malzemeleri' için, depo, seri no ve parti no 'Ambalaj listesinden' alınacaktır. Bütün 'Satış BOM' Malzemelerinin ambalajları için depo ve parti no aynı ise, bu değerler ana Malzeme tablosuna girilebilir, değerler Ambalaj Listesi tablosuna kopyalanacaktır."
 For Company,Şirket için
-For Employee,Çalışan için
-For Employee Name,Çalışan Adı İçin
-For Price List,Fiyat Listesi
+For Employee,Çalışanlara
+For Employee Name,Çalışan Adına
+For Price List,Fiyat Listesi İçin
 For Production,Üretim için
-For Reference Only.,Başvuru için sadece.
+For Reference Only.,Sadece referans için.
 For Sales Invoice,Satış Faturası için
-For Server Side Print Formats,Server Side Baskı Biçimleri
-For Supplier,Tedarikçi için
+For Server Side Print Formats,Sunucu Yan Basım Formatları için
+For Supplier,Tedarikçi İçin
 For Warehouse,Depo için
-For Warehouse is required before Submit,Depo gereklidir için önce Gönder
+For Warehouse is required before Submit,Sunulmadan önce gerekli depo için
 "For e.g. 2012, 2012-13","Örneğin 2012 için, 2012-13"
-For reference,başvuru için
+For reference,Referans için
 For reference only.,Sadece referans.
-"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Müşterilerinin rahatlığı için, bu kodları Faturalar ve Teslimat notları gibi baskı biçimleri kullanılabilir"
-Fraction,kesir
-Fraction Units,Kesir Üniteleri
-Freeze Stock Entries,Freeze Stok Yazılar
-Freeze Stocks Older Than [Days],Freeze Stoklar Daha Eski [Gün]
-Freight and Forwarding Charges,Yük ve Yönlendirme Ücretleri
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Müşterilerinin rahatlığı için, bu kodlar faturalarda ve irsaliyelerde olduğu gibi basılı formatta kullanılabilir."
+Fraction,Kesir
+Fraction Units,Kesir Birimleri
+Freeze Stock Entries,Donmuş Stok Girdileri
+Freeze Stocks Older Than [Days], [Days] daha eski donmuş stoklar
+Freight and Forwarding Charges,Navlun ve Sevkiyat Ücretleri
 Friday,Cuma
 From,Itibaren
-From Bill of Materials,Malzeme Bill
-From Company,Şirket Gönderen
-From Currency,Para Gönderen
-From Currency and To Currency cannot be same,Para itibaren ve Para için aynı olamaz
-From Customer,Müşteri Gönderen
-From Customer Issue,Müşteri Sayı Gönderen
-From Date,Tarih Gönderen
-From Date cannot be greater than To Date,Tarihten itibaren için daha büyük olamaz
-From Date must be before To Date,Tarih
-From Date should be within the Fiscal Year. Assuming From Date = {0},Tarih Mali Yılı içinde olmalıdır. Tarihten itibaren varsayarsak = {0}
-From Delivery Note,Teslim Not
-From Employee,Çalışan Gönderen
-From Lead,Kurşun gelen
-From Maintenance Schedule,Bakım Programı Gönderen
-From Material Request,Malzeme istek
-From Opportunity,Fırsat
-From Package No.,Paket No Gönderen
-From Purchase Order,Satınalma Siparişi Gönderen
-From Purchase Receipt,Satın Alındı ​​Gönderen
-From Quotation,Teklifimizin Gönderen
-From Sales Order,Satış Siparişi Gönderen
-From Supplier Quotation,Tedarikçi Teklifimizin Gönderen
-From Time,Time
-From Value,Değer itibaren
-From and To dates required,Gerekli tarihleri ​​Başlangıç ​​ve
-From value must be less than to value in row {0},Değerden üst üste değerine daha az olmalıdır {0}
-Frozen,Kitlendi
-Frozen Accounts Modifier,Dondurulmuş Hesapları Değiştirici
-Fulfilled,Karşılanan
+From Bill of Materials,Malzeme Faturasından
+From Company,Şirketten
+From Currency,Para biriminden
+From Currency and To Currency cannot be same,Para biriminden ve para birimine aynı olamaz
+From Customer,Müşteriden
+From Customer Issue,Müşteri nüshasından
+From Date,Tarihinden itibaren
+From Date cannot be greater than To Date,Tarihten itibaren tarihe kadardan ileride olamaz
+From Date must be before To Date,Tarihten itibaren tarihe kadardan önce olmalıdır
+From Date should be within the Fiscal Year. Assuming From Date = {0},Tarihten itibaren Mali yıl içinde olmalıdır Tarihten itibaren  = {0} varsayılır
+From Delivery Note,İrsaliyeden
+From Employee,Çalışanlardan
+From Lead,Baştan
+From Maintenance Schedule,Bakım Programından
+From Material Request,Malzeme talebinden
+From Opportunity,Fırsattan
+From Package No.,Ambalaj Numarasından.
+From Purchase Order,Satın Alma Emrinden
+From Purchase Receipt,Satın Alma Makbuzundan
+From Quotation,Fiyat Teklifinden
+From Sales Order,Satış Emrinden
+From Supplier Quotation,Tedarikçi fiyat teklifinden
+From Time,Zamandan
+From Value,Değerden
+From and To dates required,Tarih aralığı gerekli
+From value must be less than to value in row {0},"Değerden, {0} satırındaki değerden az olmalıdır"
+Frozen,Dondurulmuş
+Frozen Accounts Modifier,Dondurulmuş Hesap Düzenleyici
+Fulfilled,Gerçekleştirilmiş
 Full Name,Tam Adı
-Full-time,Tam gün
-Fully Billed,Tamamen Faturalı
-Fully Completed,Tamamen Tamamlandı
-Fully Delivered,Tamamen Teslim
+Full-time,Tam zamanlı
+Fully Billed,Tam Faturalı
+Fully Completed,Tamamen Tamamlanmış
+Fully Delivered,Tamamen Teslim Edilmiş
 Furniture and Fixture,Mobilya ve Fikstürü
-Further accounts can be made under Groups but entries can be made against Ledger,Ek hesaplar Gruplar altında yapılabilir ancak girdiler Ledger karşı yapılabilir
-"Further accounts can be made under Groups, but entries can be made against Ledger","Ek hesaplar Gruplar altında yapılabilir, ancak girdiler Ledger karşı yapılabilir"
-Further nodes can be only created under 'Group' type nodes,Dahası düğümleri sadece 'Grup' tipi düğüm altında oluşturulabilir
-GL Entry,GL Girişi
+Further accounts can be made under Groups but entries can be made against Ledger,Ek hesaplar Gruplar altında yapılabilir ancak girdiler Ana defter karşılığı yapılabilir
+"Further accounts can be made under Groups, but entries can be made against Ledger","Ek hesaplar Gruplar altında yapılabilir, ancak girdiler Ana defter karşılığı yapılabilir"
+Further nodes can be only created under 'Group' type nodes,Ek kısımlar ancak 'Grup' tipi kısımlar altında oluşturulabilir
+GL Entry,GL Girdisi
 Gantt Chart,Gantt Şeması
-Gantt chart of all tasks.,Tüm görevlerin Gantt şeması
+Gantt chart of all tasks.,Bütün görevlerin Gantt Şeması.
 Gender,Cinsiyet
 General,Genel
 General Ledger,Genel Muhasebe
-Generate Description HTML,Açıklama HTML Oluştur
+Generate Description HTML,Açıklama HTML'si oluştur
 Generate Material Requests (MRP) and Production Orders.,Malzeme İstekleri (MRP) ve Üretim Emirleri oluşturun.
-Generate Salary Slips,Maaş Fişi Üret
-Generate Schedule,Takvim Oluştur
-Generates HTML to include selected image in the description,Açıklamasında seçilen görüntü eklemek için HTML üretir
-Get Advances Paid,Ödenmiş Avanslar
-Get Advances Received,Alınan Avanslar
-Get Current Stock,Güncel Stok
-Get Items,Ürünler
-Get Items From Sales Orders,Satış Siparişleri Öğeleri alın
-Get Items from BOM,BOM Öğeleri alın
-Get Last Purchase Rate,Son Alış Fiyatı
-Get Outstanding Invoices,Get Outstanding Invoices
-Get Relevant Entries,İlgili başlıklar alın
-Get Sales Orders,Satış Siparişleri
-Get Specification Details,Teknik Detaylar
-Get Stock and Rate,Stok ve Fiyat
-Get Template,Şablon
-Get Terms and Conditions,Şartlar ve Koşullar
-Get Unreconciled Entries,Uzlaşmayan başlıklar alın
-Get Weekly Off Dates,Haftalık Çalışılmayan Günler
-"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Sözü gönderme tarih-zaman kaynak / hedef depoda değerleme oranı ve mevcut stok alın. Öğeyi tefrika varsa, seri nos girdikten sonra bu düğmeye basınız."
-Global Defaults,Genel Varsayılan Değerler
-Global POS Setting {0} already created for company {1},Küresel POS Ayar {0} zaten oluşturulan şirket {1}
+Generate Salary Slips,Maaş Makbuzu Oluşturun
+Generate Schedule,Program Oluşturun
+Generates HTML to include selected image in the description,Açıklamada seçilen resmi içerecek HTML oluşturur
+Get Advances Paid,Avansları Öde
+Get Advances Received,Avansların alınmasını sağla
+Get Current Stock,Cari Stok alın
+Get Items,Ürünleri alın
+Get Items From Sales Orders,Satış Emirlerinden Ürünleri alın
+Get Items from BOM,BOM dan Ürünleri alın
+Get Last Purchase Rate,Son Alım Br.Fİyatını alın
+Get Outstanding Invoices,Bekleyen Faturaları alın
+Get Relevant Entries,İlgili girdileri alın
+Get Sales Orders,Satış Şiparişlerini alın
+Get Specification Details,Şartname Detaylarını alın
+Get Stock and Rate,Stok ve Br.Fiyatları alın
+Get Template,Şablon alın
+Get Terms and Conditions,Şart ve Koşulları alın
+Get Unreconciled Entries,Mutabık olmayan girdileri alın
+Get Weekly Off Dates,Haftalık Hesap Kesim tarihlerini alın
+"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Belirtilen gönderim tarihinde-zamanında kaynak/hedef depodaki değerleme oranını ve mevcut stoku alın. Eğer Ürünler seri ise, seri numaralarını girdikten sonra butona tıklayınız"
+Global Defaults,Küresel Varsayılanlar
+Global POS Setting {0} already created for company {1},Küresel POS Ayarları {0} Şirket {1} için zaten oluşturulmuştur
 Global Settings,Genel Ayarlar
-"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""","Uygun gruba (Fon genellikle Uygulama> Dönen Varlıklar> Banka Hesapları gidin ve ""Bankası"" türü Child ekle tıklayarak yeni Hesabı Ledger () oluşturmak"
-"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.","Uygun gruba (Fon genellikle Kaynağı> Yükümlülükler> Vergi ve Görevleri gidin ve türü ""Vergi"" ve Ledger (tıklayarak Çocuk ekle) yeni bir hesap oluşturmak ve Vergi oranı söz yok."
+"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""", Uygun Gruba gidin (genellikle Fon uygulamaları> Cari varlıklar> Banka Hesapları ve Yeni hesap defteri türü oluştur (Çocuk Ekle'ye tıklayarak)
+"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate."," Uygun Gruba gidin (genellikle Fon kaynakları> Cari borçlar> Vergi ve Harçlar ve Yeni hesap defteri türü oluştur (Çocuk Ekle'ye tıklayarak)) ""Vergi Türü"" ve Vergi oranını belirtin."
 Goal,Hedef
 Goals,Hedefler
-Goods received from Suppliers.,Tedarikçilerden alınan Ürünler 
+Goods received from Suppliers.,Tedarikçilerden alınan mallar.
 Google Drive,Google Drive
-Google Drive Access Allowed,Google Drive Erişim İzin
+Google Drive Access Allowed,Google Drive Erişimine İzin verildi
 Government,Devlet
-Graduate,Lisansüstü
+Graduate,Mezun
 Grand Total,Genel Toplam
-Grand Total (Company Currency),Genel Toplam (Şirket para birimi)
+Grand Total (Company Currency),Genel Toplam (Şirket para birimi)
 "Grid ""","Izgara """
 Grocery,Bakkal
 Gross Margin %,Brüt Kar Marjı%
-Gross Margin Value,Brüt Kar Marjı
-Gross Pay,Brüt Ücret
-Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Brüt Ücret + geciken Tutar + Nakde Çevrilmelerinde Tutarı - Toplam Kesintisi
-Gross Profit,Brüt kazanç
+Gross Margin Value,Brüt Kar Marjı Değeri
+Gross Pay,Brüt Ödeme
+Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Büt Ücret + geciken Tutar + Nakit Çekim Tutarı - Toplam Kesinti
+Gross Profit,Brüt Kar
 Gross Profit (%),Brüt Kar (%)
 Gross Weight,Brüt Ağırlık
-Gross Weight UOM,Brüt Ağırlık Ölçü Birim (ÖB)
+Gross Weight UOM,Brüt Ağırlık UOM
 Group,Grup
-Group by Account,Hesap tarafından Grup
-Group by Voucher,Çeki ile grup
-Group or Ledger,Grup veya Ledger
+Group by Account,Hesap Grubu
+Group by Voucher,Dekont Grubu
+Group or Ledger,Grup veya Defter
 Groups,Gruplar
 HR Manager,İK Yöneticisi
 HR Settings,İK Ayarları
-HTML / Banner that will show on the top of product list.,Ürün listesinin üstünde gösterecektir HTML / Banner.
+HTML / Banner that will show on the top of product list.,Ürün listesinin tepesinde görünecek HTML / Banner.
 Half Day,Yarım Gün
-Half Yearly,Yarı Yıllık
-Half-yearly,Yarıyıllık
+Half Yearly,Yarım Yıllık
+Half-yearly,Yarı Yıllık
 Happy Birthday!,Doğum günün kutlu olsun!
 Hardware,Donanım
-Has Batch No,Batch No var
-Has Child Node,Alt Düğüm var
-Has Serial No,Seri No var
-Head of Marketing and Sales,Pazarlama ve Satış Müdürü
+Has Batch No,Parti No Var
+Has Child Node,Çocuk Kısmı Var
+Has Serial No,Seri no Var
+Head of Marketing and Sales,Satış ve Pazarlama Müdürü
 Header,Başlık
 Health Care,Sağlık hizmeti
-Health Concerns,Sağlık Kaygıları
+Health Concerns,Sağlık Sorunları
 Health Details,Sağlık Bilgileri
-Held On,Açık Tutulacak
-Help HTML,HTML Help
+Held On,Yapılan
+Help HTML,Yardım HTML
 "Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Yardım: sistemindeki başka bir kayda bağlamak için, ""# Form / Not / [İsim Not]"" Bağlantı URL olarak kullanın. (""Http://"" kullanmayın)"
-"Here you can maintain family details like name and occupation of parent, spouse and children","Burada ebeveyn, eş ve çocukların isim ve meslek gibi aile ayrıntıları koruyabilirsiniz"
-"Here you can maintain height, weight, allergies, medical concerns etc","Burada boy, kilo, alerji, tıbbi endişeler vb koruyabilirsiniz"
-Hide Currency Symbol,Para birimi simgesi gizle
+"Here you can maintain family details like name and occupation of parent, spouse and children","Burada ebeveyn, eş ve çocukların isim ve meslek gibi aile ayrıntıları  muhafaza edebilirsiniz"
+"Here you can maintain height, weight, allergies, medical concerns etc","Burada boy, kilo, alerji, tıbbi endişeler vb  muhafaza edebilirsiniz"
+Hide Currency Symbol,Para birimi simgesini gizle
 High,Yüksek
-History In Company,Şirketimiz Tarihçesi
-Hold,Tutmak
+History In Company,Şirketteki Geçmişi
+Hold,Muhafaza et
 Holiday,Tatil
 Holiday List,Tatil Listesi
 Holiday List Name,Tatil Listesi Adı
-Holiday master.,Tatil usta.
+Holiday master.,Ana tatil. 
 Holidays,Bayram
-Home,Ev
-Host,Evsahibi
-"Host, Email and Password required if emails are to be pulled","E-postalar çekti isteniyorsa konak, E-posta ve Şifre gereklidir"
+Home,Ana Sayfa
+Host,Host
+"Host, Email and Password required if emails are to be pulled","E-posta çekimi isteniyorsa host, E-posta ve şifre gereklidir"
 Hour,Saat
 Hour Rate,Saat Hızı
-Hour Rate Labour,Saat Hızı Çalışma
+Hour Rate Labour,İşçi Saat Br.Fiyatı
 Hours,Saat
-How Pricing Rule is applied?,Nasıl Fiyatlandırma Kural uygulanır?
-How frequently?,Ne kadar sıklıkta?
-"How should this currency be formatted? If not set, will use system defaults","Bu nasıl para biçimlendirilmiş olmalıdır? Set değilse, sistem varsayılan kullanacak"
+How Pricing Rule is applied?,Fiyatlandırma Kuralı Nasıl Uygulanır?
+How frequently?,Ne sıklıkla?
+"How should this currency be formatted? If not set, will use system defaults","Bu para birimi nasıl biçimlendirilmelidir? Ayarlanmamışsa, sistem varsayılanı kullanacaktır."
 Human Resources,İnsan Kaynakları
-Identification of the package for the delivery (for print),Teslimat için paketin tanımlanması (baskı için)
-If Income or Expense,Eğer Gelir veya Gider
-If Monthly Budget Exceeded,Aylık Bütçe aşıldıysa
-"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Satış BOM tanımlanmış ise, Pack gerçek BOM tablo olarak görüntülenir. İrsaliye ve Satış Sipariş mevcuttur"
-"If Supplier Part Number exists for given Item, it gets stored here","Tedarikçi Parça Numarası verilen parçanın varsa, burada depolanır"
-If Yearly Budget Exceeded,Yıllık Bütçe aşıldıysa
-"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Eğer işaretli ise, alt-montaj kalemleri için BOM hammadde almak için kabul edilecektir. Aksi takdirde, tüm alt-montaj öğeler bir hammadde olarak kabul edilecektir."
-"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Eğer seçilirse, toplam yok. Çalışma gün ve tatiller dahil olacak ve bu Maaş Günlük değerini azaltacaktır"
-"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Kontrol eğer zaten Baskı Hızı / Baskı Tutar dahil olarak, vergi tutarı olarak kabul edilecektir"
-If different than customer address,Eğer müşteri adres farklı
-"If disable, 'Rounded Total' field will not be visible in any transaction","Devre dışı ise, 'Yuvarlak Total' alanı herhangi bir işlem görünür olmayacak"
-"If enabled, the system will post accounting entries for inventory automatically.","Etkinse, sistem otomatik olarak envanter için muhasebe kayıtları yayınlayacağız."
-If more than one package of the same type (for print),Aynı türdeki birden fazla paket (baskı)
-"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Birden Fiyatlandırma Kurallar hakim devam ederse, kullanıcılar çatışmayı çözmek için el Öncelik ayarlamanız istenir."
-"If no change in either Quantity or Valuation Rate, leave the cell blank.","Miktar veya Değerleme Oranı da hiçbir değişiklik, hücre boş bırakırsanız."
-If not applicable please enter: NA,Geçerli değilse NA giriniz
-"If not checked, the list will have to be added to each Department where it has to be applied.","Kontrol edilmez ise, liste bu uygulanması gereken her bölüm için ilave edilmesi gerekecektir."
-"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Seçilen Fiyatlandırma Kural 'Fiyat' için yapılmış ise, Fiyat Listesi üzerine yazılır. Fiyatlandırma Kural fiyat nihai fiyat, yani başka hiçbir indirim uygulanmalıdır. Bu nedenle, Satış Emri, Sipariş vb gibi işlemlerde, oldukça 'Fiyat Listesi Derece' alanına daha, 'Derece' alanına getirilecek."
-"If specified, send the newsletter using this email address","Belirtilen varsa, bu e-posta adresini kullanarak bülten göndermek"
-"If the account is frozen, entries are allowed to restricted users.","Hesap donmuş ise, girişleri sınırlı kullanıcılara izin verilir."
-"If this Account represents a Customer, Supplier or Employee, set it here.","Bu Hesap Müşteri, tedarikçi ya da çalışan temsil ediyorsa, burada ayarlayın."
-"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Iki veya daha fazla Fiyatlandırması Kuralları yukarıdaki koşullara dayalı bulunursa, Öncelik uygulanır. Varsayılan değer sıfır (boş) ise Öncelik 0-20 arasında bir sayıdır. Daha fazla sayıda aynı koşullarda birden Fiyatlandırması Kuralları vardır eğer öncelik alacak demektir."
-If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Kalite Tetkiki izleyin. Hayır Satın Alma Makbuzu Öğe QA Gerekli ve QA sağlar
-If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Eğer Satış Ekibi ve Satış Ortakları (Kanal Ortakları) varsa onlar etiketlendi ve satış faaliyetleri kendi katkılarını sürdürmek olabilir
-"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Eğer Satınalma Vergi ve Masraflar Master standart bir şablon oluşturduk varsa, birini seçin ve aşağıdaki butona tıklayın."
-"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Eğer Satış Vergi ve Masraflar Master standart bir şablon oluşturduk varsa, birini seçin ve aşağıdaki butona tıklayın."
-"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Uzun baskı biçimleri varsa, bu özellik, her sayfada tüm üstbilgi ve altbilgi ile birden fazla sayfa yazdırılacak sayfayı bölmek için kullanılabilir"
-If you involve in manufacturing activity. Enables Item 'Is Manufactured',Eğer üretim faaliyeti dahil edin. Öğe sağlayan 'Üretildi'
+Identification of the package for the delivery (for print),(Baskı için) teslimat için ambalajın tanımlanması
+If Income or Expense,Gelir veya Gider ise
+If Monthly Budget Exceeded,Aylık Bütçe Aşılırsa
+"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Satış BOM u tanımlanmış ise, Paketin gerçek BOM u tablo olarak görüntülenir. İrsaliye ve Satış Siparişi mevcuttur"
+"If Supplier Part Number exists for given Item, it gets stored here","Bir Ürün için tedarikçi parça numarası varsa, burada depolanır"
+If Yearly Budget Exceeded,Yıllık Bütçe Aşılırsa
+"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Eğer işaretli ise, alt-montaj kalemleri için BOM hammadde almak için kabul edilecektir. Aksi takdirde, tüm alt-montaj ögeleri bir hammadde olarak kabul edilecektir."
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Seçili ise,toplam çalışma günleri sayısı tatilleri içerecektir ve bu da Günlük ücreti düşürecektir"
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","İşaretli ise, vergi miktarının hali hazırda Basım Oranında/Basım Miktarında dahil olduğu düşünülecektir"
+If different than customer address,Müşteri adresinden farklı ise
+"If disable, 'Rounded Total' field will not be visible in any transaction","Devre dışıysa, 'Yuvarlanmış Toplam' alanı hiçbir işlemde görünmeyecektir."
+"If enabled, the system will post accounting entries for inventory automatically.","Etkinse, sistem otomatik olarak envanter için muhasebe kayıtlarını yayınlayacaktır"
+If more than one package of the same type (for print),(Baskı için) aynı ambalajdan birden fazla varsa
+"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Birden fazla fiyatlandırma Kuralo hakimse, kullanıcılardan zorunu çözmek için Önceliği elle ayarlamaları istenir"
+"If no change in either Quantity or Valuation Rate, leave the cell blank.","Miktar veya Değerleme Oranında değişiklik olmazsa, hücreyi boş bırakın."
+If not applicable please enter: NA,Eğer uygulanabilir değilse NA giriniz
+"If not checked, the list will have to be added to each Department where it has to be applied.","İşaretli değilse, liste uygulanması gereken her Departmana eklenmelidir"
+"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Seçilen fiyatlandırma kuralı fiyat için olursa, fiyat listesini geçersiz kılacaktır. Fiyatlandırma kuralının fiyatı son fiyattır, bu yüzden daha fazla indirim yapılmayacaktır. bu nedenle, satış emri, satın alma emri vb gibi işlemlerde 'Fiyat Listesi Oranı' alanı yerine 'Oran' alanında getirilecektir."
+"If specified, send the newsletter using this email address","Belirtilmişse, bülteni bu e-posta adresini kullanarak gönderiniz"
+"If the account is frozen, entries are allowed to restricted users.","Hesap dondurulmuş ise, girdiler kısıtlı kullanıcılara açıktır."
+"If this Account represents a Customer, Supplier or Employee, set it here.","Bu Hesap bir Müşteriyi, Tedarikçiyi veya Çalışanı temsil ediyorsa burada ayarlayınız."
+"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.",Yukarıdaki koşullara dayalı iki veya daha fazla Fiyatlandırma Kuralı bulunursa Öncelik uygulanır. Varsayılan değer sıfır iken (boşluk) Öncelik 0 ile 20 arasında bir rakamdır. Daha büyük rakamlar aynı koşullarda birden fazla Fiyatlandırma Kuralı varsa bunların geçerli olacağı anlamına gelir.
+If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Kalite Denetimini izlerseniz Alım Makbuzunda Ürünlerin Kalite Güvencesini ve Kalite Güvence numarasını verir.
+If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Satış Takımınız ve Satış Ortaklarınız (Kanal Ortakları) varsa işaretlenebilirler ve satış faaliyetine katkılarını sürdürebilirler
+"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Satın Alma Vergilerinde ve Ana Ücretlerde standart bir şablon oluşturduysanız, birini seçin ve aşağıdaki butona tıklayın"
+"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Satış Vergilerinde ve Ana Ücretlerde standart bir şablon oluşturduysanız, birini seçin ve aşağıdaki butona tıklayın"
+"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Uzun baskı formatlarınız varsa, bu özellik basılacak sayfayı başlıkları ve dipnotları her sayfada olmak üzere birden fazla sayfaya bölmek için kullanılabilir"
+If you involve in manufacturing activity. Enables Item 'Is Manufactured',Üretim faaliyetlerinde bulunuyorsanız Ürünlerin 'Üretilmiş' olmasını sağlar
 Ignore,Yoksay
 Ignore Pricing Rule,Fiyatlandırma Kuralı Yoksay
-Ignored: ,Ignored: 
+Ignored: ,Yoksayıldı: 
 Image,Resim
 Image View,Resim Görüntüle
 Implementation Partner,Uygulama Ortağı
-Import Attendance,İthalat Devam
-Import Failed!,İthalat Başarısız!
-Import Log,Log alma
+Import Attendance,İthalat Katılımı 
+Import Failed!,İthalat Başarısız oldu
+Import Log,İthalat Günlüğü
 Import Successful!,Başarılı İthalat!
-Imports,Ithalat
+Imports,İthalat
 In Hours,Saatleri
-In Process,Proses
-In Qty,Adet
-In Value,Değer
-In Words,Kelimeler
-In Words (Company Currency),Kelimeler (Firma para birimi) olarak
-In Words (Export) will be visible once you save the Delivery Note.,İrsaliyeyi kaydettiğnizde Kelimeler (İhracat) görünür olacaktır.
-In Words will be visible once you save the Delivery Note.,İrsaliye kaydettiğinizde Kelimeler görünür olacaktır.
-In Words will be visible once you save the Purchase Invoice.,Alış Faturasını kaydettiğinizde Kelimeler görünür olacaktır.
-In Words will be visible once you save the Purchase Order.,Alış Siparişini kaydettiğinizde Kelimeler görünür olacaktır.
-In Words will be visible once you save the Purchase Receipt.,Alış Kabulünü kaydettiğinizde Kelimeler görünür olacaktır.
-In Words will be visible once you save the Quotation.,Talebi kaydettiğinizde Kelimeler görünür olacaktır.
-In Words will be visible once you save the Sales Invoice.,Satış Faturasını kaydettiğinizde Kelimeler görünür olacaktır.
-In Words will be visible once you save the Sales Order.,Satış Siparişini kaydettiğinizde Kelimeler görünür olacaktır.
+In Process,Süreci
+In Qty,Miktarında
+In Value,Değerinde
+In Words,Kelimelerle
+In Words (Company Currency),Sözlü (Firma para birimi) olarak
+In Words (Export) will be visible once you save the Delivery Note.,Sözlü (İhracat) İrsaliyeyi kaydettiğinizde görünür olacaktır.
+In Words will be visible once you save the Delivery Note.,Sözlü İrsaliyeyi kaydettiğinizde görünür olacaktır
+In Words will be visible once you save the Purchase Invoice.,Satın alma faturasını kaydettiğinizde görünür olacaktır.
+In Words will be visible once you save the Purchase Order.,Sözlü Alım belgesini kaydettiğinizde görünür olacaktır.
+In Words will be visible once you save the Purchase Receipt.,Sözlü Alım belgesini kaydettiğinizde görünür olacaktır.
+In Words will be visible once you save the Quotation.,fiyat teklifini kaydettiğinizde görünür olacaktır
+In Words will be visible once you save the Sales Invoice.,Satış faturasını kaydettiğinizde görünür olacaktır.
+In Words will be visible once you save the Sales Order.,Satış emrini kaydettiğinizde görünür olacaktır.
 Incentives,Teşvikler
-Include Reconciled Entries,Uzlaşılan başlıklar şunlardır
-Include holidays in Total no. of Working Days,Hiçbir Toplam tatilleri dahil. Çalışma Günleri
+Include Reconciled Entries,Mutabık girdileri dahil edin
+Include holidays in Total no. of Working Days,Çalışma günlerinin toplam sayısı ile tatilleri dahil edin
 Income,Gelir
 Income / Expense,Gelir / Gider
 Income Account,Gelir Hesabı
-Income Booked,Gelir rezervasyonu
+Income Booked,Ayrılan Gelir
 Income Tax,Gelir vergisi
-Income Year to Date,Tarih Gelir Yıl
-Income booked for the digest period,Sindirmek dönemi için rezervasyonu Gelir
-Incoming,Gelen
-Incoming Rate,Gelen Puan
+Income Year to Date,Güncel Gelir Yılı
+Income booked for the digest period,Özet Dönemi için ayrılan gelir
+Incoming,Alınan
+Incoming Rate,Gelen Oranı
 Incoming quality inspection.,Gelen kalite kontrol.
-Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Genel Muhasebe Yazılar Yanlış sayısı bulundu. Siz işlemde yanlış Hesabı seçmiş olabilirsiniz.
-Incorrect or Inactive BOM {0} for Item {1} at row {2},Yanlış veya Kapalı BOM {0} öğesi için {1} satırdaki {2}
-Indicates that the package is a part of this delivery (Only Draft),Paketi Bu teslim bir parçası olduğunu gösterir (Sadece Taslak)
+Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Yanlış Genel Defter Girdileri bulundu. İşlemde yanlış bir hesap seçmiş olabilirsiniz.
+Incorrect or Inactive BOM {0} for Item {1} at row {2},Satır {2} deki Ürün {1} için Yanlış veya Etkin Olmayan BOM {0}
+Indicates that the package is a part of this delivery (Only Draft),Paketin bu teslimatın bir parçası olduğunu gösterir (Sadece Taslak)
 Indirect Expenses,Dolaylı Giderler
 Indirect Income,Dolaylı Gelir
-Individual,Bireysel
-Industry,Endüstri
-Industry Type,Endüstri Tipi
-Inspected By,Denetleyen
-Inspection Criteria,Denetim Kriterleri
-Inspection Required,Denetim Gerekli
+Individual,Tek
+Industry,Sanayi
+Industry Type,Sanayi Tipi
+Inspected By,Tarafından denetlenir
+Inspection Criteria,Muayene Kriterleri
+Inspection Required,Muayene Gerekli
 Inspection Type,Muayene Türü
 Installation Date,Kurulum Tarihi
 Installation Note,Kurulum Not
-Installation Note Item,Kurulum Not Ürün
+Installation Note Item,Kurulum Notu Maddesi
 Installation Note {0} has already been submitted,Kurulum Not {0} zaten gönderildi
-Installation Status,Yükleme Durumu
+Installation Status,Kurulum Durumu
 Installation Time,Kurulum Zaman
 Installation date cannot be before delivery date for Item {0},Kurulum tarih Ürün için teslim tarihinden önce olamaz {0}
-Installation record for a Serial No.,Seri No için yükleme kaydı
-Installed Qty,Yüklünen Miktar
+Installation record for a Serial No.,Bir Seri No için kurulum kaydı.
+Installed Qty,Kurulan Miktar
 Instructions,Talimatlar
-Integrate incoming support emails to Support Ticket,Ticket Destek gelen destek e-postaları entegre
-Interested,Ilgili
+Integrate incoming support emails to Support Ticket,Bilet Desteklemek için gelen destek e-postalarını birleştir
+Interested,İlgili
 Intern,Stajyer
-Internal,Iç
-Internet Publishing,İnternet Yayıncılık
+Internal,Dahili
+Internet Publishing,İnternet Yayıncılığı
 Introduction,Giriş
 Invalid Barcode,Geçersiz Barkod
 Invalid Barcode or Serial No,Geçersiz Barkod veya Seri No
-Invalid Mail Server. Please rectify and try again.,Geçersiz Mail Server. Düzeltmek ve tekrar deneyin.
-Invalid Master Name,Geçersiz Usta İsmi
-Invalid User Name or Support Password. Please rectify and try again.,Geçersiz Kullanıcı Adı veya Şifre Destek. Düzeltmek ve tekrar deneyin.
-Invalid quantity specified for item {0}. Quantity should be greater than 0.,Öğesi için belirtilen geçersiz miktar {0}. Miktar 0'dan büyük olmalıdır.
-Inventory,Envanter
+Invalid Mail Server. Please rectify and try again.,Geçersiz Mail Sunucusu. Düzeltmek ve tekrar deneyin.
+Invalid Master Name,Geçersiz Alan Adı
+Invalid User Name or Support Password. Please rectify and try again.,Geçersiz Kullanıcı Adı veya Şifre Destek. Lütfen Düzeltin ve tekrar deneyin.
+Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ürün {0} için geçersiz miktar belirtildi. Miktar 0 dan fazla olmalıdır
+Inventory,Stok
 Inventory & Support,Envanter ve Destek
 Investment Banking,Yatırım Bankacılığı
 Investments,Yatırımlar
@@ -1323,230 +1323,230 @@
 Invoice Details,Fatura Ayrıntıları
 Invoice No,Fatura No
 Invoice Number,Fatura Numarası
-Invoice Period From,Gönderen Fatura Dönemi
-Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Faturayı yinelenen zorunlu tarihler için ve Fatura Dönemi itibaren Fatura Dönemi
-Invoice Period To,Için Fatura Dönemi
+Invoice Period From,İtibaren Fatura Tarihi
+Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Mükerrer fatura için tarihinden itibaren ve tarihine kadar Fatura dönemleri zorunludur
+Invoice Period To,Tarihine kadar fatura dönemi
 Invoice Type,Fatura Türü
-Invoice/Journal Voucher Details,Fatura / Dergi Çeki Detayları
-Invoiced Amount (Exculsive Tax),Faturalanan Tutar (Exculsive Vergisi)
-Is Active,Aktif mi
-Is Advance,Peşin mi
-Is Cancelled,İptal Edilmiştir
-Is Carry Forward,İleri Devam mı
-Is Default,Standart mı
-Is Encash,Bozdurmak mı
-Is Fixed Asset Item,Sabit Kıymet öğedir
-Is LWP,YSP mi
-Is Opening,Açıklıyor mu
-Is Opening Entry,Entry Açılış mı
-Is POS,POS mu
-Is Primary Contact,Birincil İletişim mi
-Is Purchase Item,Satınalma ürünü mü
-Is Sales Item,Satış ürünü mü
-Is Service Item,Hizmet Ürünü mü
-Is Stock Item,Stok Ürünü mü
-Is Sub Contracted Item,Alt Sözleşmeli ürün mü
-Is Subcontracted,Taşeron firmaya mı vrildi
-Is this Tax included in Basic Rate?,Bu Vergi Birim Fiyata dahil mi?
-Issue,Konu
-Issue Date,Yayın Tarihi
-Issue Details,Sorun Ayrıntıları
-Issued Items Against Production Order,Üretim Emri Karşı İhraç Ürünleri
-It can also be used to create opening stock entries and to fix stock value.,Ayrıca açılış stok girişleri oluşturmak ve stok değerini düzeltmek için kullanılabilir.
+Invoice/Journal Voucher Details,Fatura / Dekont Detayları
+Invoiced Amount (Exculsive Tax),Faturalanan Tutar (Vergi Hariç)
+Is Active,Aktif
+Is Advance,Avans
+Is Cancelled,İptal edilmiş
+Is Carry Forward,İleri taşınmış
+Is Default,Standart
+Is Encash,Bozdurulmuş
+Is Fixed Asset Item,Sabit Varlık Maddesi
+Is LWP,LWP
+Is Opening,Açılır
+Is Opening Entry,Açılış Girdisi
+Is POS,POS
+Is Primary Contact,Birincil İrtibat
+Is Purchase Item,Satın Alma Maddesi 
+Is Sales Item,Satış Maddesi
+Is Service Item,Hizmet Maddesi
+Is Stock Item,Stok Maddesi
+Is Sub Contracted Item,Alt Sözleşmeli Madde
+Is Subcontracted,Taşerona verilmiş
+Is this Tax included in Basic Rate?,Bu Vergi Temel Br.Fiyata dahil mi?
+Issue,Sayı
+Issue Date,Veriliş tarihi
+Issue Details,Konu Detayları
+Issued Items Against Production Order,Üretim Emrine Karşı verilmiş maddeler
+It can also be used to create opening stock entries and to fix stock value.,Ayrıca açılış stok girdilerini oluşturmak ve stok değerini sabitlemek için de kullanılabilir.
 Item,Ürün
-Item Advanced,Ürün Gelişmiş
+Item Advanced,İleri Madde
 Item Barcode,Ürün Barkodu
-Item Batch Nos,Ürün Batch No
+Item Batch Nos,Ürün Parti Numaraları
 Item Code,Ürün Kodu
 Item Code > Item Group > Brand,Ürün Kodu> Ürün Grubu> Marka
-Item Code and Warehouse should already exist.,Ürün Kodu ve Depo zaten var.
+Item Code and Warehouse should already exist.,Ürün Kodu ve Depo zaten var olmalıdır.
 Item Code cannot be changed for Serial No.,Ürün Kodu Seri No için değiştirilemez
-Item Code is mandatory because Item is not automatically numbered,Ürün otomatik olarak numaralandırılmış değil çünkü Ürün Kodu zorunludur
-Item Code required at Row No {0},Sıra No gerekli Ürün Kodu {0}
-Item Customer Detail,Ürün Müşteri Detay
-Item Description,Ürün Açıklaması
-Item Desription,Ürün Oy Ver Açıklama
+Item Code is mandatory because Item is not automatically numbered,Ürün Kodu zorunludur çünkü Ürün otomatik olarak numaralandırmaz
+Item Code required at Row No {0},{0} Numaralı satırda Ürün Kodu gereklidir
+Item Customer Detail,Ürün Müşteri Detayı
+Item Description,Ürün Tanımı
+Item Desription,Ürün Tanımı
 Item Details,Ürün Detayları
 Item Group,Ürün Grubu
 Item Group Name,Ürün Grup Adı
 Item Group Tree,Ürün Grubu Ağacı
-Item Group not mentioned in item master for item {0},Öğe için öğe ana belirtilmeyen Ürün Grubu {0}
-Item Groups in Details,Ayrıntılar Ürün Grupları
-Item Image (if not slideshow),Ürün Resmi (değilse slayt)
-Item Name,Ürün Adı
-Item Naming By,Ürün adlandırma By
+Item Group not mentioned in item master for item {0},Ürün {0} içim Ürün alanında Ürün grubu belirtilmemiş
+Item Groups in Details,Ayrıntılı Ürün Grupları
+Item Image (if not slideshow),Ürün Görüntü (yoksa slayt)
+Item Name,Nesne Adı
+Item Naming By,Ürün adlandırma
 Item Price,Ürün Fiyatı
 Item Prices,Ürün Fiyatları
-Item Quality Inspection Parameter,Ürün Kalite Kontrol Parametre
-Item Reorder,Ürün Reorder
+Item Quality Inspection Parameter,Ürün Kalite Kontrol Parametreleri
+Item Reorder,Ürün Yeniden Sipariş
 Item Serial No,Ürün Seri No
-Item Serial Nos,Ürün Seri Noları
+Item Serial Nos,Ürün Seri Numaralar
 Item Shortage Report,Ürün yetersizliği Raporu
 Item Supplier,Ürün Tedarikçisi
 Item Supplier Details,Ürün Tedarikçi Ayrıntıları
 Item Tax,Ürün Vergisi
 Item Tax Amount,Ürün Vergi Tutarı
 Item Tax Rate,Ürün Vergi Oranı
-Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Ürün Vergi Row {0} türü Vergisi veya Gelir veya gider veya Ücretli bir hesabınız olması gerekir
-Item Tax1,Ürün Vergi1
-Item To Manufacture,Üretim Ürün
-Item UOM,Ürün Ölçü Birimi (ÖB)
+Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Ürün Vergi Satırı {0} Vergi Gelir Gider veya Ödenebilir türde hesabı olmalıdır.
+Item Tax1,Ürün Vergisi 1
+Item To Manufacture,Üretilecek Ürün
+Item UOM,Ürün UOM
 Item Website Specification,Ürün Web Sitesi Özellikleri
 Item Website Specifications,Ürün Web Sitesi Özellikleri
-Item Wise Tax Detail,Ürün Vergi Detayı
+Item Wise Tax Detail, Ürün Vergi Detayları
 Item Wise Tax Detail ,
 Item is required,Ürün gereklidir
 Item is updated,Ürün güncellenir
-Item master.,Ürün usta.
-"Item must be a purchase item, as it is present in one or many Active BOMs","Bu bir veya birçok Active reçetelerde mevcut olduğu gibi öğe, bir satın alma öğe olmalı"
-Item or Warehouse for row {0} does not match Material Request,Satır için öğe veya Depo {0} Malzeme İsteği eşleşmiyor
-Item table can not be blank,Ürün masa boş olamaz
-Item to be manufactured or repacked,Ürün imal edilmiş veya paketlenmiş
+Item master.,Ürün alanı.
+"Item must be a purchase item, as it is present in one or many Active BOMs","Bir veya daha fazla etkin BOM'da bulunduğundan, Ürün bir satın alma maddesi olmalıdır"
+Item or Warehouse for row {0} does not match Material Request,Satır {0} daki Ürün veya Depo Ürün isteğini karşılamıyor
+Item table can not be blank,Ürün tablosu boş olamaz
+Item to be manufactured or repacked,Üretilecek veya yeniden paketlenecek Ürün
 Item valuation updated,Ürün değerleme güncellendi
-Item will be saved by this name in the data base.,Ürün veri tabanına bu isimle kaydedilecektir.
-Item {0} appears multiple times in Price List {1},Item {0} Fiyat Listesi birden çok kez görüntülenir {1}
-Item {0} does not exist,Ürün {0} yok
-Item {0} does not exist in the system or has expired,Item {0} sistemde yoksa veya süresi doldu
-Item {0} does not exist in {1} {2},Item {0} yok {1} {2}
-Item {0} has already been returned,Item {0} zaten iade edilmiş
-Item {0} has been entered multiple times against same operation,Item {0} aynı operasyona karşı birden çok kez girildi
-Item {0} has been entered multiple times with same description or date,Item {0} aynı açıklama ya da tarih ile birden çok kez girildi
-Item {0} has been entered multiple times with same description or date or warehouse,Item {0} aynı açıklama veya tarihe depo ile birden çok kez girildi
-Item {0} has been entered twice,Item {0} kez girildi
-Item {0} has reached its end of life on {1},Item {0} üzerindeki ömrünün sonuna gelmiştir {1}
-Item {0} ignored since it is not a stock item,Bir stok kalemi olmadığı Item {0} yok
-Item {0} is cancelled,Item {0} iptal edilir
-Item {0} is not Purchase Item,Item {0} Öğe satın değil
-Item {0} is not a serialized Item,Item {0} bir tefrika değil Öğe
-Item {0} is not a stock Item,"Item {0}, bir hisse senedi değil Öğe"
-Item {0} is not active or end of life has been reached,Item {0} aktif değil ise veya hayatın sonuna gelindi
-Item {0} is not setup for Serial Nos. Check Item master,Item {0} Seri No Kontrol Ürün usta için kurulum değil
-Item {0} is not setup for Serial Nos. Column must be blank,Item {0} Seri No Kolon için kurulum boş olmalı değil
-Item {0} must be Sales Item,Item {0} Satış Ürün olmalı
-Item {0} must be Sales or Service Item in {1},Item {0} Satış veya Servis Ürün olmalıdır {1}
-Item {0} must be Service Item,Item {0} Service Ürün olmalı
-Item {0} must be a Purchase Item,Item {0} Satınalma Ürün olmalı
-Item {0} must be a Sales Item,Item {0} Satış Ürün olmalı
-Item {0} must be a Service Item.,Item {0} Service Ürün olmalıdır.
-Item {0} must be a Sub-contracted Item,Item {0} bir taşeronluk Ürün olmalı
-Item {0} must be a stock Item,Item {0} bir stok Ürün olmalı
-Item {0} must be manufactured or sub-contracted,Item {0} imal edilmeli veya taşeronluk
-Item {0} not found,Item {0} bulunamadı
-Item {0} with Serial No {1} is already installed,Item {0} Seri No ile {1} zaten yüklü
-Item {0} with same description entered twice,Item {0} aynı açıklama ile iki kez girdi
-"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Seri Numarası seçildiğinde Öğe, Garanti, AMC (Yıllık Bakım Sözleşme) bilgilerini otomatik olarak zorlama olacaktır."
-Item-wise Price List Rate,Madde-bilge Fiyat Listesi Oranı
-Item-wise Purchase History,Madde-bilge Satın Alma Geçmişi
-Item-wise Purchase Register,Madde-bilge Alım Kayıt
-Item-wise Sales History,Madde-bilge Satış Tarihi
-Item-wise Sales Register,Madde-bilge Satış Kayıt
-"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry","Ürün: {0} toplu-bilge yönetilen kullanarak mutabakat olamaz \ Stock Uzlaşma yerine, stok girişi kullanın"
+Item will be saved by this name in the data base.,Ürün veri tabanında bu isim ile kaydedilir.
+Item {0} appears multiple times in Price List {1},Ürün {0} Fiyat Listesi {1} birden çok kez görüntülenir
+Item {0} does not exist,Ürün {0} yoktur
+Item {0} does not exist in the system or has expired,Ürün {0} sistemde yoktur veya süresi dolmuştur
+Item {0} does not exist in {1} {2},Ürün {0} {1} ve {2} de yoktur
+Item {0} has already been returned,Ürün {0} zaten iade edilmiş
+Item {0} has been entered multiple times against same operation,Ürün {0} aynı işleme birden çok  kez girildi
+Item {0} has been entered multiple times with same description or date,Ürün {0} aynı tanım ya da tarih ile birden çok kez girildi
+Item {0} has been entered multiple times with same description or date or warehouse,Ürün {0} aynı tanım veya tarih veya depo ile birden çok kez girildi
+Item {0} has been entered twice,Ürün {0} iki kez girildi
+Item {0} has reached its end of life on {1},Ürün {0} {1}de kullanım ömrünün sonuna gelmiştir.
+Item {0} ignored since it is not a stock item,Stok ürünü olmadığından Ürün {0} yok sayıldı
+Item {0} is cancelled,Ürün {0} iptal edildi
+Item {0} is not Purchase Item,Ürün {0} Satın alma ürünü değildir
+Item {0} is not a serialized Item,Ürün {0} bir seri Ürün değildir
+Item {0} is not a stock Item,Ürün {0} bir stok ürünü değildir
+Item {0} is not active or end of life has been reached,Ürün {0} aktif değil veya kullanım ömrünün sonuna gelindi
+Item {0} is not setup for Serial Nos. Check Item master,"Ürün {0} Seri No Kontrol ürünü değildir, Ürün alanını kontrol ediniz"
+Item {0} is not setup for Serial Nos. Column must be blank,Ürün {0} Seri No kurulumu değildir. Sütun boş bırakılmalıdır
+Item {0} must be Sales Item,Ürün {0} Satış ürünü olmalıdır
+Item {0} must be Sales or Service Item in {1},Ürün {0} {1} de Satış veya Hizmet ürünü olmalıdır
+Item {0} must be Service Item,Ürün {0} Hizmet ürünü olmalıdır
+Item {0} must be a Purchase Item,Ürün {0} Satın alma ürünü olmalıdır
+Item {0} must be a Sales Item,Ürün {0} Satış ürünü olmalı
+Item {0} must be a Service Item.,Ürün {0} Hizmet ürünü olmalıdır.
+Item {0} must be a Sub-contracted Item,Ürün {0} bir taşeron ürünü olmalıdır
+Item {0} must be a stock Item,Ürün {0} bir stok ürünü olmalıdır
+Item {0} must be manufactured or sub-contracted,Ürün {0} imal edilmeli veya taşerona verilmelidir
+Item {0} not found,Ürün {0} bulunamadı
+Item {0} with Serial No {1} is already installed,Ürün {0} Seri No  {1} ile  zaten yerleştirilmiş
+Item {0} with same description entered twice,Ürün {0} aynı açıklama ile iki kez girilmiş
+"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Seri Numarası seçildiğinde Ürün, Garanti, AMC (Yıllık Bakım Sözleşmesi) bilgilerini otomatik olarak getirecektir."
+Item-wise Price List Rate,Ürün bilgisi Fiyat Listesi Oranı
+Item-wise Purchase History,Ürün bilgisi Satın Alma Geçmişi
+Item-wise Purchase Register,Ürün bilgisi Alım Kaydı
+Item-wise Sales History,Ürün bilgisi Satış Geçmişi
+Item-wise Sales Register,Ürün bilgisi Satış Kaydı
+"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry","Ürün: {0} bitirilmiş parti bilgisi, Stok girdisi yerine stok mutabakatı kullanılarak uzlaştırılamaz"
 Item: {0} not found in the system,Ürün: {0} sistemde bulunamadı
 Items,Ürünler
-Items To Be Requested,İstenen To Be ürün
-Items required,Gerekli Öğeler
-"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","""Stokta"" olan talep edilecek kalemler öngörülen qty ve minimum sipariş adet dayalı tüm depolar dikkate"
-Items which do not exist in Item master can also be entered on customer's request,Ana ürün listesinde olmayan ürünlerde müşterinin isteği üzerine girilebilir
-Itemwise Discount,Itemwise İndirim
-Itemwise Recommended Reorder Level,Itemwise Yeniden Sipariş Seviye Önerilen
-Job Applicant,İş Başvuru
-Job Opening,Is Firsatlari
+Items To Be Requested,İstenecek Ürünler
+Items required,Gerekli Ürünler
+"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Öngörülen miktar ve minimum sipariş miktarına dayalı olarak bütün depolarda ""Stokta bulunmayan"" istenecek Ürünler"
+Items which do not exist in Item master can also be entered on customer's request,Ürün alanında bulunmayan Ürünler müşterinin isteği üzerine de girilebilir
+Itemwise Discount,Ürün İndirimi
+Itemwise Recommended Reorder Level,Ürünnin Önerilen Yeniden Sipariş Düzeyi
+Job Applicant,İş Başvuru Sahiibi
+Job Opening,İş Açılışı
 Job Profile,İş Profili
-Job Title,Meslek
-"Job profile, qualifications required etc.","Gerekli iş profili, nitelikleri vb"
+Job Title,İş Unvanı
+"Job profile, qualifications required etc.","İş Profili, gerekli nitelikler vb"
 Jobs Email Settings,İş E-posta Ayarları
-Journal Entries,Yevmiye Girişleri
-Journal Entry,Yevmiye Girişi
-Journal Voucher,Yevmiye Fişi
-Journal Voucher Detail,Alacak/Borç Fiş Detay
-Journal Voucher Detail No,Alacak/Borç Fiş Detay No
-Journal Voucher {0} does not have account {1} or already matched,Dergi Çeki {0} hesabı yok {1} ya da zaten eşleşti
-Journal Vouchers {0} are un-linked,Dergi Fişler {0} un-bağlantılı
-Keep a track of communication related to this enquiry which will help for future reference.,Gelecekte başvurulara yardımcı olmak için bu soruşturma ile ilgili bir iletişim takip edin.
-Keep it web friendly 900px (w) by 100px (h),100px tarafından web dostu 900px (w) it Keep (h)
-Key Performance Area,Anahtar Performans Alan
-Key Responsibility Area,Anahtar Sorumluluk Alanı
+Journal Entries,Kayıt Girdileri
+Journal Entry,Kayıt Girdisi
+Journal Voucher,Dekont
+Journal Voucher Detail,Dekont Detayı
+Journal Voucher Detail No,Dekont Detay No
+Journal Voucher {0} does not have account {1} or already matched,Dekontun {0} hesabı yok {1} veya zaten eşleşmemiş
+Journal Vouchers {0} are un-linked,Dekontlar {0} bağlantısız
+Keep a track of communication related to this enquiry which will help for future reference.,Size ileride yardımı dokunacak bu sorguyla iligli iletişimi takip edin.
+Keep it web friendly 900px (w) by 100px (h),100px (yukseklik) ile 900 px (genislik) web dostu tutun
+Key Performance Area,Kilit Performans Alanı
+Key Responsibility Area,Kilit Sorumluluk Alanı
 Kg,Kilogram
-LR Date,LR Tarihi
-LR No,LR yok
+LR Date,LR Tarih
+LR No,LR No
 Label,Etiket
-Landed Cost Item,İndirilmiş Maliyet Kalemi
-Landed Cost Items,İndirilmiş Maliyet Kalemleri
-Landed Cost Purchase Receipt,İndirilmiş Maliyet Satın Alma Makbuzu
-Landed Cost Purchase Receipts,İndirilmiş Maliyet Satın Alma Makbuzları
-Landed Cost Wizard,İndirilmiş Maliyet Sihirbazı
-Landed Cost updated successfully,Indi Maliyet başarıyla güncellendi
+Landed Cost Item,İnen Maliyet Kalemi
+Landed Cost Items,İnen Maliyet Kalemi
+Landed Cost Purchase Receipt,İnen Maliyet Alım Makbuzu
+Landed Cost Purchase Receipts,İnen Maliyet Alım Makbuzları
+Landed Cost Wizard,İnen Maliyet Sihirbazı
+Landed Cost updated successfully,İnen Maliyet başarıyla güncellendi
 Language,Dil
 Last Name,Soyadı
 Last Purchase Rate,Son Satış Fiyatı
 Latest,Son
-Lead,Aday
-Lead Details,Lead Details
-Lead Id,Kurşun Kimliği
-Lead Name,Lead Name
-Lead Owner,Lead Owner
-Lead Source,Aday Kaynak
-Lead Status,Aday Durumu
-Lead Time Date,Lead Time Date
-Lead Time Days,Lead Time Days
-Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,"Lead Time gün bu öğe depoda beklenen hangi gün sayısıdır. Bu öğeyi seçtiğinizde, bu gün Malzeme İsteği getirildi."
-Lead Type,Lead Type
-Lead must be set if Opportunity is made from Lead,Fırsat Lead yapılmış ise kurşun ayarlanmalıdır
-Leave Allocation,İzin Tahsis
-Leave Allocation Tool,İzin Tahsis  aracı
-Leave Application,İzin başvurusu
-Leave Approver,İzin onay mercii
-Leave Approvers,Onaylayanlar bırakın
-Leave Balance Before Application,Leave Balance Before Application
-Leave Block List,Blok Listesi bırakın
-Leave Block List Allow,Blok Liste İzin bırakın
-Leave Block List Allowed,Blok Liste İzin bırakın
-Leave Block List Date,Blok Liste Tarihi bırakın
-Leave Block List Dates,Blok Liste Tarihler bırakın
-Leave Block List Name,Blok Liste Adını bırak
-Leave Blocked,Bırakın Engellendi
-Leave Control Panel,Leave Control Panel
-Leave Encashed?,Leave Encashed?
-Leave Encashment Amount,Leave Encashment Amount
-Leave Type,Leave Type
-Leave Type Name,Leave Type Name
-Leave Without Pay,Leave Without Pay
-Leave application has been approved.,Bırak başvuru onaylandı.
-Leave application has been rejected.,Bırak başvuru reddedildi.
+Lead,Talep Yaratma
+Lead Details,Talep Yaratma Detayları
+Lead Id,Talep Yaratma  Kimliği
+Lead Name,Talep Yaratma Adı
+Lead Owner,Talep Yaratma Sahibi
+Lead Source,Talep Yaratma Kaynağı
+Lead Status,Talep Yaratma Durumu
+Lead Time Date,Talep Yaratma Zaman Tarihi
+Lead Time Days,Talep Yaratma Gün Saati
+Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,"Tedarik süresi bir ürünün deponuzda beklendiği süredir. Bu süre, Ürünü seçtiğinizde Ürün Talebi ile getirilir."
+Lead Type,Talep Yaratma Tipi
+Lead must be set if Opportunity is made from Lead,Talepten fırsat oluşturuldu ise talep ayarlanmalıdır
+Leave Allocation,İzin Tahsisi
+Leave Allocation Tool,İzin Tahsis Aracı
+Leave Application,İzin uygulaması
+Leave Approver,İzin Onaylayan
+Leave Approvers,İzin Onaylayanlar
+Leave Balance Before Application,Uygulamadan Önce Kalan İzin
+Leave Block List,İzin engel listesi
+Leave Block List Allow,İzin engel listesi müsaade eder
+Leave Block List Allowed,Müsaade edilen izin engel listesi
+Leave Block List Date,İzin engel listesi tarihi
+Leave Block List Dates,İzin engel listesi tarihleri
+Leave Block List Name,İzin engel listesi adı
+Leave Blocked,İzin engellendi
+Leave Control Panel,İzin Kontrol Paneli
+Leave Encashed?,İzin Tahsil Edilmiş mi?
+Leave Encashment Amount,İzin Tahsilat Miktarı
+Leave Type,İzin Tipi
+Leave Type Name,İzin Tipi Adı
+Leave Without Pay,Ücretsiz İzin
+Leave application has been approved.,İzin Uygulaması Onaylandı.
+Leave application has been rejected.,İzin uygulaması reddedildi.
 Leave approver must be one of {0},Bırakın onaylayan biri olmalıdır {0}
-Leave blank if considered for all branches,Leave blank if considered for all branches
-Leave blank if considered for all departments,Leave blank if considered for all departments
-Leave blank if considered for all designations,Leave blank if considered for all designations
-Leave blank if considered for all employee types,Leave blank if considered for all employee types
-"Leave can be approved by users with Role, ""Leave Approver""","Bırakın Rolü kullanıcılar tarafından onaylanmış olabilir, ""Onaylayan bırakın"""
-Leave of type {0} cannot be longer than {1},Türü bırak {0} daha uzun olamaz {1}
-Leaves Allocated Successfully for {0},Yapraklar Başarıyla Ayrılan {0}
-Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Yapraklar türü için {0} zaten Çalışanlara için tahsis {1} Mali Yılı için {0}
-Leaves must be allocated in multiples of 0.5,Yapraklar 0.5 katları tahsis edilmelidir
+Leave blank if considered for all branches,Tüm branşlarda için kabul ise boş bırakın
+Leave blank if considered for all departments,Tüm bölümler için kabul ise boş bırakın
+Leave blank if considered for all designations,Tüm tanımları için kabul ise boş bırakın
+Leave blank if considered for all employee types,Tüm çalışan tipleri için kabul ise boş bırakın
+"Leave can be approved by users with Role, ""Leave Approver""","İzinler ""İzin onaylayıcı"" rolü olan kullanıcılar tarafından onaylanabilir"
+Leave of type {0} cannot be longer than {1},Tip{0} izin  {1}'den uzun olamaz
+Leaves Allocated Successfully for {0},İzinler {0} için başarıyla tahsis edildi
+Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Tip {0} izinler Çalışan {1} e {0} Mali yılı için hali hazırda tahsis edildi
+Leaves must be allocated in multiples of 0.5,İzinler 0.5 katlanarak tahsis edilmelidir
 Ledger,Defteri kebir
-Ledgers,Defterleri
-Left,Sol
+Ledgers,Defterler
+Left,Bırakmak
 Legal,Yasal
 Legal Expenses,Yasal Giderler
-Letter Head,Antet
-Letter Heads for print templates.,Baskı şablonları için mektup Başkanları.
+Letter Head,Antetli Kağıt
+Letter Heads for print templates.,Baskı şablonları için antetli kağıtlar
 Level,Seviye
 Lft,Lft
 Liability,Borç
-List a few of your customers. They could be organizations or individuals.,Müşterilerinizin birkaç listeleyin. Onlar kuruluşlar veya bireyler olabilir.
-List a few of your suppliers. They could be organizations or individuals.,Lütfen tedarikçilerin az listeleyin. Onlar kuruluşlar veya bireyler olabilir.
-List items that form the package.,Paket oluşturur Listesi ürün.
-List this Item in multiple groups on the website.,Bu Ürünü Web sitesinde birden çok grupta  listeleyin.
-"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Ürün ya da satın almak veya satmak hizmetleri sıralayın. Başlattığınızda Ürün Grubu, Ölçü ve diğer özellikleri Birimi kontrol ettiğinizden emin olun."
-"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Ve standart oranları; vergi başlarını (onlar benzersiz adları olması gerekir, örneğin KDV, Özel Tüketim) listeleyin. Bu düzenlemek ve daha sonra ekleyebileceğiniz standart bir şablon oluşturmak olacaktır."
+List a few of your customers. They could be organizations or individuals.,Müşterilerinizin birkaçını listeleyin. Bunlar kuruluşlar veya bireyler olabilir.
+List a few of your suppliers. They could be organizations or individuals.,Tedarikçilerinizin birkaçını listeleyin. Bunlar kuruluşlar veya bireyler olabilir.
+List items that form the package.,Ambalajı oluşturan Ürünleri listeleyin
+List this Item in multiple groups on the website.,Bu Ürünü web sitesinde gruplar halinde listeleyin
+"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Sattığınız veya satın aldığınız ürün veya hizmetleri listeleyin, başladığınızda Ürün grubunu, ölçü birimini ve diğer özellikleri işaretlediğinizden emin olun"
+"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Vergi başlıklarınızı (örneğin KDV, tüketim, kendi isimleri ile olmalıdır) ve standart oranlarını girin, bu daha sonra ekleme ve düzenleme yapabileceğiniz standart bir şablon oluşturacaktır."
 Loading...,Yükleniyor...
 Loans (Liabilities),Krediler (Yükümlülükler)
 Loans and Advances (Assets),Krediler ve avanslar (Varlıklar)
 Local,Yerel
 Login,Giriş
-Login with your new User ID,Yeni Kullanıcı ID ile giriş
+Login with your new User ID,Yeni Kullanıcı Kimliğinizle Giriş Yapın
 Logo,Logo
-Logo and Letter Heads,Logo ve Letter Başkanları
+Logo and Letter Heads,Logo ve Antetli Kağıtlar
 Lost,Kayıp
 Lost Reason,Kayıp Nedeni
 Low,Düşük
@@ -1554,574 +1554,574 @@
 MTN Details,MTN Detayları
 Main,Ana
 Main Reports,Ana Raporlar
-Maintain Same Rate Throughout Sales Cycle,Satış döngüsü boyunca aynı puanla koruyun
-Maintain same rate throughout purchase cycle,Satın alma döngüsü boyunca aynı oranda koruyun
+Maintain Same Rate Throughout Sales Cycle,Satış döngüsü boyunca aynı oranı koruyun
+Maintain same rate throughout purchase cycle,Alım döngüsü boyunca aynı oranı koruyun
 Maintenance,Bakım
 Maintenance Date,Bakım Tarih
-Maintenance Details,Bakım Detayları
+Maintenance Details,Bakım Ayrıntıları
 Maintenance Schedule,Bakım Programı
 Maintenance Schedule Detail,Bakım Programı Detayı
-Maintenance Schedule Item,Bakım Programı Ürün
-Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Bakım Programı tüm öğeler için oluşturulur. 'Oluştur Takviminde tıklayınız
-Maintenance Schedule {0} exists against {0},Bakım Programı {0} karşı var {0}
-Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Bakım Programı {0} bu Satış Siparişi iptal etmeden önce iptal edilmelidir
-Maintenance Schedules,Bakım Çizelgeleri
+Maintenance Schedule Item,Bakım Programı Ürünü
+Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Bakım Programı bütün Ürünler için oluşturulmamıştır. Lütfen 'Program Oluştura' tıklayın
+Maintenance Schedule {0} exists against {0},Bakım Programı {0} {0} karşılığında mevcuttur
+Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Bakım Programı {0} bu Satış Emri iptal edilmeden önce iptal edilmelidir
+Maintenance Schedules,Bakım Programları
 Maintenance Status,Bakım Durumu
 Maintenance Time,Bakım Zamanı
 Maintenance Type,Bakım Türü
 Maintenance Visit,Bakım Ziyareti
-Maintenance Visit Purpose,Bakım ziyaret Amacı
-Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Bakım ziyaret {0} bu Satış Siparişi iptal etmeden önce iptal edilmelidir
-Maintenance start date can not be before delivery date for Serial No {0},Bakım başlangıç ​​tarihi Seri No için teslim tarihinden önce olamaz {0}
-Major/Optional Subjects,Zorunlu / Opsiyonel Konular
-Make ,Make 
-Make Accounting Entry For Every Stock Movement,Her Stok Hareketi İçin Muhasebe kaydı yapmak
-Make Bank Voucher,Banka Çeki Yap
-Make Credit Note,Kredi Not Yap
-Make Debit Note,Banka Not Yap
-Make Delivery,Teslim olun
-Make Difference Entry,Fark Giriş Yap
-Make Excise Invoice,Tüketim Fatura Yap
-Make Installation Note,Kurulum Not olun
-Make Invoice,Fatura olun
-Make Maint. Schedule,Bakým olun. Program
-Make Maint. Visit,Bakým olun. Ziyaret
-Make Maintenance Visit,Bakım Ziyaret olun
-Make Packing Slip,Ambalaj Slip olun
-Make Payment,Ödeme Yap
-Make Payment Entry,Ödeme Girişi yapın
-Make Purchase Invoice,Satınalma fatura yapmak
-Make Purchase Order,Yapmak Sipariş
-Make Purchase Receipt,Alım yapmak Makbuz
-Make Salary Slip,Maaş Kayma olun
-Make Salary Structure,Maaş Yapısı olun
-Make Sales Invoice,Satış Faturası olun
-Make Sales Order,Make Satış Sipariş
-Make Supplier Quotation,Tedarikçi Teklif Yap
-Make Time Log Batch,Saat Günlük Toplu olun
+Maintenance Visit Purpose,Bakım ziyareti Amacı
+Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Bakım Ziyareti {0} bu Satış Emri iptal edilmeden önce iptal edilmelidir
+Maintenance start date can not be before delivery date for Serial No {0},Seri No {0} için bakım başlangıç tarihi teslim tarihinden önce olamaz
+Major/Optional Subjects,Ana / Opsiyonel Konular
+Make ,Oluştur
+Make Accounting Entry For Every Stock Movement,Her Stok Hareketi için Muhasebe kaydı oluştur
+Make Bank Voucher,Banka Dekontu Oluştur
+Make Credit Note,Alacak Dekontu Oluştur
+Make Debit Note,Borç Dekontu Oluştur
+Make Delivery,Teslimat Yap
+Make Difference Entry,Fark Girişi yapın
+Make Excise Invoice,Tüketim faturası yapın
+Make Installation Note,Kurulum Notu Yapın
+Make Invoice,Fatura Oluştur
+Make Maint. Schedule,Bakım Programı Yapın
+Make Maint. Visit,Bakım Ziyareti Programı Yapın
+Make Maintenance Visit,Bakım Ziyareti Yapın
+Make Packing Slip,Ambalaj Makbuzu Yapın
+Make Payment,Ödeme Yapın
+Make Payment Entry,Ödeme Girdisi Oluştur
+Make Purchase Invoice,Satın Alma Faturası Oluştur
+Make Purchase Order,Satın Alma Emri verin
+Make Purchase Receipt,Satın Alma Makbuzu Oluştur
+Make Salary Slip,Maaş Makbuzu Oluştur
+Make Salary Structure,Maaş Yapısı oluşturun
+Make Sales Invoice,Satış Faturası Oluştur
+Make Sales Order,Satış Emri verin
+Make Supplier Quotation,Tedarikçi Teklifi Oluştur
+Make Time Log Batch,Günlük Parti oluşturun
 Male,Erkek
-Manage Customer Group Tree.,Müşteri Grup Ağacını Yönet.
-Manage Sales Partners.,Satış Ortakları yönetmek.
-Manage Sales Person Tree.,Satış Elemanı Ağacını Yönet.
-Manage Territory Tree.,Eyalet Ağacını Yönet.
-Manage cost of operations,Operasyonel maliyetleri yönetin
+Manage Customer Group Tree.,Müşteri Grupbu Ağacını Yönetin.
+Manage Sales Partners.,Satış Ortaklarını Yönetin.
+Manage Sales Person Tree.,Satış Elemanı Ağacını Yönetin.
+Manage Territory Tree.,Bölge Ağacını Yönetin.
+Manage cost of operations,İşlem Maliyetlerini Yönetin
 Management,Yönetim
 Manager,Yönetici
-"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Zorunlu eğer Stok Ürün ""Evet"". Ayrıca saklıdır miktar Satış Siparişi ayarlanır varsayılan depo."
-Manufacture against Sales Order,Satış Sipariş imalatı
-Manufacture/Repack,Üret /Paketle
-Manufactured Qty,Üretim Miktar
-Manufactured quantity will be updated in this warehouse,Üretilmiş miktar bu depoda verilerini güncelleyecektir
-Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Üretilmiş miktar {0} planlanan quanitity daha büyük olamaz {1} Üretim Sipariş {2}
-Manufacturer,İmalatçı
-Manufacturer Part Number,İmalatçı Ürün Numarası
+"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Stok Ürünleri ""Evet"" ise zorunludur. Ayrıca Satış Emrinden ayrılan miktarın olduğu standart depodur."
+Manufacture against Sales Order,Satış Emrine Karşı Üretim
+Manufacture/Repack,İmalat / Yeniden Ambalajlama
+Manufactured Qty,Üretilen Miktar
+Manufactured quantity will be updated in this warehouse,Üretilen miktar bu depoda güncellenecektir
+Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Üretilen miktar {0} Üretim Emrindeki {2} planlanan miktardan fazla olamaz
+Manufacturer,Üretici
+Manufacturer Part Number,Üretici kısım numarası
 Manufacturing,İmalat
 Manufacturing Quantity,Üretim Miktarı
 Manufacturing Quantity is mandatory,Üretim Miktarı zorunludur
-Margin,Kenar
-Marital Status,Medeni Durum
-Market Segment,Piyasa Segmenti
+Margin,Kar Marjı
+Marital Status,Medeni durum
+Market Segment,Pazar Segmenti
 Marketing,Pazarlama
 Marketing Expenses,Pazarlama Giderleri
 Married,Evli
-Mass Mailing,Toplu E-Posta
-Master Name,Ana Kaynak Adı
-Master Name is mandatory if account type is Warehouse,Hesap türü Depo ise usta ismi zorunludur
-Master Type,Ana Kaynak Türü
-Masters,Ana Kaynaklar
-Match non-linked Invoices and Payments.,İlişkilendirilmemiş Fatura ve Ödemeleri eşleştirin
-Material Issue,Malzeme Sayı
-Material Receipt,Malzeme Alındı
+Mass Mailing,Toplu Posta
+Master Name,Alan Adı
+Master Name is mandatory if account type is Warehouse,Hesap Türü Depo ise alan ismi zorunludur
+Master Type,Alan tipi
+Masters,Alanlar
+Match non-linked Invoices and Payments.,Bağlantısız Faturaları ve Ödemeleri eşleştirin.
+Material Issue,Malzeme Verilişi
+Material Receipt,Malzeme Alındısı
 Material Request,Malzeme Talebi
-Material Request Detail No,Malzeme Talebi Detay yok
+Material Request Detail No,Malzeme Talebi Detay No
 Material Request For Warehouse,Depo için Malzeme Talebi
-Material Request Item,Malzeme Talebi Ürün
-Material Request Items,Malzeme Talebi Öğeler
-Material Request No,Malzeme Talebi Yok
+Material Request Item,Malzeme Talebi Kalemi
+Material Request Items,Malzeme Talebi Kalemleri
+Material Request No,Malzeme Talebi No
 Material Request Type,Malzeme İstek Türü
-Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Maksimum Malzeme Talebi {0} öğesi için {1} karşı yapılabilir Satış Sipariş {2}
-Material Request used to make this Stock Entry,Malzeme Talebi Bu stok girişi yapmak için kullanılır
-Material Request {0} is cancelled or stopped,Malzeme Talebi {0} iptal veya durdurulur
-Material Requests for which Supplier Quotations are not created,Tedarikçi Özlü Sözler oluşturulan olmadığı için malzeme isteği
-Material Requests {0} created,Malzeme İstekler {0} oluşturuldu
-Material Requirement,Malzeme İhtiyaç
+Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Maksimum {0} Malzeme Talebi Malzeme {1} için Satış Emri {2} karşılığında yapılabilir
+Material Request used to make this Stock Entry,Bu stok girdisini yapmak için kullanılan Malzeme Talebi
+Material Request {0} is cancelled or stopped,Malzeme Talebi {0} iptal edilmiş veya durdurulmuştur
+Material Requests for which Supplier Quotations are not created,Kendisi için tedarikçi fiyat teklifi oluşturulmamış Malzeme Talepleri
+Material Requests {0} created,Malzeme Talepleri {0} oluşturuldu
+Material Requirement,Malzeme İhtiyacı
 Material Transfer,Materyal Transfer
-Materials,Malzemeler
-Materials Required (Exploded),Gerekli Malzemeler (Ayrılmış)
-Max 5 characters,Max 5 karakter
-Max Days Leave Allowed,Max İzin gün sayısı
-Max Discount (%),Max İndirim (%)
-Max Qty,Max Adet
-Max discount allowed for item: {0} is {1}%,Max indirim kalemi için izin: {0} {1}% ve
+Materials,Materyaller
+Materials Required (Exploded),Gerekli Malzemeler (patlamış)
+Max 5 characters,En fazla 5 karakter
+Max Days Leave Allowed,En fazla izin günü
+Max Discount (%),En fazla İndirim (%
+Max Qty,En fazla miktar
+Max discount allowed for item: {0} is {1}%,Malzeme {0}için izin verilen maksimum indirim} {1}% 
 Maximum Amount,Maksimum Tutar
-Maximum allowed credit is {0} days after posting date,Maksimum izin verilen kredi tarihini yazdıktan sonra {0} gün
-Maximum {0} rows allowed,Maksimum {0} satırlar izin
-Maxiumm discount for Item {0} is {1}%,Ürün için Maxiumm indirimli {0} {1}% olan
+Maximum allowed credit is {0} days after posting date,Maksimum izin verilen kredi gönderim tarihinden sonra {0} gündür
+Maximum {0} rows allowed,Maksimum {0} satıra izin verilir
+Maxiumm discount for Item {0} is {1}%,Malzeme {0} için maksimum indirim {1}% 
 Medical,Tıbbi
 Medium,Orta
-"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company","Aşağıdaki özelliklerin her ikisi, kayıtlar aynı ise birleştirme mümkündür. Grup veya Ledger, Kök Tipi, Şirket"
+"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company","Birleştirme ancak şu özellikler her iki kayıtta da aynı ise mümkündür: Grup veya Defter, Kök tipi, şirket"
 Message,Mesaj
-Message Parameter,Mesaj Parametreleri
+Message Parameter,Mesaj Parametresi
 Message Sent,Gönderilen Mesaj
 Message updated,Mesaj güncellendi
 Messages,Mesajlar
-Messages greater than 160 characters will be split into multiple messages,160 karakterden daha büyük mesajlar birden fazla mesaj bölünecektir
+Messages greater than 160 characters will be split into multiple messages,160 karakterden daha büyük mesajlar birden fazla mesaja bölünecektir
 Middle Income,Orta Gelir
-Milestone,Kilometre Taşı
-Milestone Date,Kilometre Taşı Tarihi
-Milestones,Kilometre Taşları
-Milestones will be added as Events in the Calendar,Kilometre Taşları Takvime Faaliyet olarak eklenecektir
-Min Order Qty,Min Sipariş Adedi
-Min Qty,Minimum Adet
-Min Qty can not be greater than Max Qty,Minimum Adet Max Miktar daha büyük olamaz
+Milestone,Aşama
+Milestone Date,Aşama Tarihi
+Milestones,Aşamalar
+Milestones will be added as Events in the Calendar,Aşamalar Takvime olaylar olarak girilecektir
+Min Order Qty,Minimum sipariş miktarı
+Min Qty,Minimum Miktar
+Min Qty can not be greater than Max Qty,Minimum Miktar Maksimum Miktardan Fazla olamaz
 Minimum Amount,Minimum Tutar
-Minimum Order Qty,Minimum Sipariş Miktar
+Minimum Order Qty,Minimum Sipariş Miktarı
 Minute,Dakika
 Misc Details,Çeşitli Detaylar
 Miscellaneous Expenses,Çeşitli Giderler
-Miscelleneous,Miscelleneous
-Mobile No,Cep No
+Miscelleneous,Muhtelif
+Mobile No,Mobil No
 Mobile No.,Cep No
 Mode of Payment,Ödeme Şekli
 Modern,Çağdaş
 Monday,Pazartesi
 Month,Ay
 Monthly,Aylık
-Monthly Attendance Sheet,Aylık Hazirun Cetveli
-Monthly Earning & Deduction,Aylık Kazanç & Kesintisi
-Monthly Salary Register,Aylık Maaş Ol
+Monthly Attendance Sheet,Aylık Katılım Cetveli
+Monthly Earning & Deduction,Aylık Kazanç & Kesinti
+Monthly Salary Register,Aylık Maaş Kaydı
 Monthly salary statement.,Aylık maaş beyanı.
 More Details,Daha Fazla Bilgi
 More Info,Daha Fazla Bilgi
 Motion Picture & Video,Motion Picture & Video
 Moving Average,Hareketli Ortalama
-Moving Average Rate,Hareketli Ortalama Fiyatı
+Moving Average Rate,Hareketli Ortalama Kuru
 Mr,Bay
 Ms,Bayan
 Multiple Item prices.,Çoklu Ürün fiyatları.
-"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}","Çoklu Fiyat Kural aynı kriterler ile var, çözmek lütfen \ öncelik atayarak çatışma. Fiyat Kuralları: {0}"
-Music,müzik
-Must be Whole Number,Tüm Numarası olmalı
-Name,Isim
-Name and Description,Ad ve Açıklama
-Name and Employee ID,Ad ve Çalışan kimliği
-"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Yeni Hesap adı. Not: Müşteriler ve Tedarikçiler için hesap oluşturmak etmeyin, onlar Müşteri ve Tedarikçi ustadan otomatik olarak oluşturulur"
-Name of person or organization that this address belongs to.,Name of person or organization that this address belongs to.
-Name of the Budget Distribution,Name of the Budget Distribution
-Naming Series,İsim Serisi
-Negative Quantity is not allowed,Negatif Miktar izin verilmez
-Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negatif Stok Hata ({6}) Ürün için {0} Atölyesi {1} tarihinde {2} {3} de {4} {5}
-Negative Valuation Rate is not allowed,Negatif Değerleme Oranı izin verilmez
-Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Toplu Negatif denge {0} öğesi için {1} Warehouse {2} tarihinde {3} {4}
-Net Pay,Net Ücret
-Net Pay (in words) will be visible once you save the Salary Slip.,Maaş kuponunu kaydettiğinizde Net Ücret (yazılı olarak) görünür olacak.
-Net Profit / Loss,Net Kar / Zararı
+"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}",Çoklu Ücret Kuralı aynı kriterlerle geçerlidir. Fiyat Kuralları: {0}
+Music,Müzik
+Must be Whole Number,Tam Numara olmalı
+Name,İsim
+Name and Description,İsim ve Tanım
+Name and Employee ID,İsim ve Çalışan Kimliği
+"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Yeni Hesap Adı. Not:Müşteriler ve tedarikçiler için hesap oluşturmayınız, Bunlar Müşteri ve Tedarikçi alanından otomatik olarak oluşturulacaktır."
+Name of person or organization that this address belongs to.,Bu adresin ait olduğu kişi veya kurumun adı.
+Name of the Budget Distribution,Bütçe Dağılımı Adı
+Naming Series,Seri Adlandırma
+Negative Quantity is not allowed,Negatif Miktara izin verilmez
+Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negatif Stok Hatası ({6}) Ürün {0} için {4} {5} de {2} {3} üzerindeki Depoda
+Negative Valuation Rate is not allowed,Negatif Değerleme Br.Fiyatına izin verilmez
+Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},{3} {4} üzerinde Depo {2} de Ürün {1} için Partide {0} Negatif Bakiye
+Net Pay,Net Ödeme
+Net Pay (in words) will be visible once you save the Salary Slip.,Net Ödeme (sözlü) Maaş Makbuzunu kaydettiğinizde görünecektir
+Net Profit / Loss,Net Kar / Zarar
 Net Total,Net Toplam
-Net Total (Company Currency),Net Toplam (Şirket para birimi)
-Net Weight,Net Ağırlık
-Net Weight UOM,Net Ağırlık Ölçü Birimi (ÖB)
-Net Weight of each Item,Her Ürünün Net Ağırlığı
+Net Total (Company Currency),Net Toplam (Şirket para birimi)
+Net Weight,Net Ağırlık 
+Net Weight UOM,Net Ağırlık UOM
+Net Weight of each Item,Her Ürünlerin Net Ağırlığı
 Net pay cannot be negative,Net ödeme negatif olamaz
 Never,Asla
-New ,Yeni
+New , Yeni
 New Account,Yeni Hesap
 New Account Name,Yeni Hesap Adı
-New BOM,Yeni Malzeme Listesi (ML)
-New Communications,Yeni İletişim
+New BOM,Yeni BOM
+New Communications,Yeni İletişimler
 New Company,Yeni Şirket
 New Cost Center,Yeni Maliyet Merkezi
 New Cost Center Name,Yeni Maliyet Merkezi Adı
-New Delivery Notes,Yeni Kargo Slibi
-New Enquiries,Yeni Sorular
-New Leads,Yeni İlanlar
-New Leave Application,Yeni bırak Uygulama
-New Leaves Allocated,New Leaves Allocated
-New Leaves Allocated (In Days),New Leaves Allocated (In Days)
-New Material Requests,Yeni Malzeme İstekler
+New Delivery Notes,Yeni Teslimat Notları
+New Enquiries,Yeni Sorgular
+New Leads,Yeni Alanlar
+New Leave Application,Yeni İzin Uygulaması
+New Leaves Allocated,Tahsis Edilen Yeni İzinler 
+New Leaves Allocated (In Days),Tahsis Edilen Yeni İzinler (Günler)
+New Material Requests,Yeni Malzeme İstekleri
 New Projects,Yeni Projeler
-New Purchase Orders,Yeni Satınalma Siparişleri
-New Purchase Receipts,Yeni Satınalma Makbuzlar
-New Quotations,Yeni Talepler
-New Sales Orders,Yeni Satış Siparişleri
-New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Yeni Seri No Warehouse olamaz. Depo Stok Giriş veya Satın Alma Makbuzu tarafından ayarlanması gerekir
-New Stock Entries,Yeni Stok Girişleri
-New Stock UOM,Yeni Stok Ölçü Birimi (ÖB)
+New Purchase Orders,Yeni Satın alma Siparişleri
+New Purchase Receipts,Yeni Alım Makbuzları
+New Quotations,Yeni Fiyat Teklifleri
+New Sales Orders,Yeni Satış Emirleri
+New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Yeni Seri No Warehouse olamaz. Depo Stok girişiyle veya alım makbuzuyla ayarlanmalıdır
+New Stock Entries,Yeni Stok Girdileri
+New Stock UOM,Yeni Stok UOM
 New Stock UOM is required,Yeni Stok UoM gereklidir
-New Stock UOM must be different from current stock UOM,Yeni Stok UOM mevcut stok UOM farklı olmalıdır
-New Supplier Quotations,Yeni Tedarikçi Talepleri
-New Support Tickets,Yeni Destek Talepleri
-New UOM must NOT be of type Whole Number,Yeni UOM tipi tam sayı olması OLMAMALI
-New Workplace,Yeni İşyeri
+New Stock UOM must be different from current stock UOM,Yeni Stok UOM mevcut stok UOM dan farklı olmalıdır
+New Supplier Quotations,Yeni Tedarikçi Teklifleri
+New Support Tickets,Yeni Destek Biletleri
+New UOM must NOT be of type Whole Number,Yeni UOM tam sayı tipi olmamalıdır
+New Workplace,Yeni İş Yeri
 Newsletter,Bülten
-Newsletter Content,Bülten İçerik
-Newsletter Status,Bülten Durum
-Newsletter has already been sent,Haber zaten gönderildi
-"Newsletters to contacts, leads.","Kişilere haber bültenleri, yol açar."
-Newspaper Publishers,Gazete Yayıncılar
+Newsletter Content,Bülten İçeriği
+Newsletter Status,Bülten Durumu
+Newsletter has already been sent,Bülten zaten gönderildi
+"Newsletters to contacts, leads.","İrtibatlara, müşterilere bülten"
+Newspaper Publishers,Gazete Yayıncıları
 Next,Sonraki
-Next Contact By,Next Contact By
-Next Contact Date,Sonraki İletişim Tarihi
-Next Date,Sonraki Tarih
-Next email will be sent on:,Sonraki e-posta bu tarihte gönderilecek:
+Next Contact By,Sonraki İrtibat
+Next Contact Date,Sonraki İrtibat Tarihi
+Next Date,Sonraki Tarihi
+Next email will be sent on:,Sonraki e-posta gönderilecek:
 No,Hayır
-No Customer Accounts found.,Hiçbir Müşteri Hesapları bulunamadı.
-No Customer or Supplier Accounts found,Hiçbir müşteri veya Faaliyet Hesapları bulundu
-No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Hiçbir Gider Onaylayanlar. En az bir kullanıcı için 'Gider Approver Rolü atayın
-No Item with Barcode {0},Barkod ile hayır Ürün {0}
-No Item with Serial No {0},Seri No No Kalem {0}
-No Items to pack,Paketi yok Öğeler
-No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Hayır bırak Onaylayanlar. En az bir kullanıcıya 'bırak editör'ün Rolü atayın
-No Permission,No Permission
-No Production Orders created,Oluşturulan Hayır Üretim Siparişleri
-No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,Hiçbir Tedarikçi Hesapları bulunamadı. Tedarikçi Hesapları hesap kayıtlarında 'Usta Type' değerine göre tespit edilir.
-No accounting entries for the following warehouses,Aşağıdaki depolar için hiçbir muhasebe kayıtları
-No addresses created,Yarattığı hiçbir adresleri
-No contacts created,Yaratılan kişi yok
-No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Hayır varsayılan Adres Şablon bulundu. Ayarlar> Baskı ve Markalaşma bir yenisini> Adres şablonu oluşturun.
-No default BOM exists for Item {0},Hayır Varsayılan BOM var Ürün için {0}
-No description given,Verilen hiçbir açıklaması
-No employee found,Hiçbir işçi
-No employee found!,Hiçbir çalışan bulunamadı!
-No of Requested SMS,İstenen SMS
-No of Sent SMS,Gönderilen SMS
-No of Visits,Ziyaretçi Sayısı
+No Customer Accounts found.,Müşteri Hesabı Bulunamadı.
+No Customer or Supplier Accounts found,Müşteri veya Tedarikçi hesabı bulunamadı
+No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Gider Onaylayıcı yok. Lütfen en az bir kullanıcıya 'Gider Onaylayıcı' rolü atayın
+No Item with Barcode {0},Barkodlu Ürün Yok {0}
+No Item with Serial No {0},Seri Numaralı Ürün Yok {0}
+No Items to pack,Ambalajlanacak Ürün Yok
+No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,"İzin Onaylayıcı yok. Lütfen en az bir kullanıcıya 'İzin Onaylayıcı' rolü atayın"""
+No Permission,İzin yok
+No Production Orders created,Üretim Emri Oluşturulmadı
+No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,"Tedarikçi Hesabı Bulunamadı. Tedarikçi Hesapları hesap kaydında 'Alan Adına' dayalı olarak tanımlanır"""
+No accounting entries for the following warehouses,Şu depolar için muhasebe girdisi yok
+No addresses created,Adres oluşturulmadı
+No contacts created,İrtibat kişisi oluşturulmadı
+No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Varsayılan adres şablonu bulunamadı. Lütfen Ayarlar> Basım ve Markalaştırma> Adres Şablonunu kullanarak şablon oluşturun.
+No default BOM exists for Item {0},Ürün {0} için Varsayılan BOM mevcut değildir
+No description given,Açıklama verilmemiştir
+No employee found,Çalışan bulunmadı
+No employee found!,Çalışan bulunmadı!
+No of Requested SMS,İstenen SMS Sayısı
+No of Sent SMS,Gönderilen SMS sayısı
+No of Visits,Ziyaret sayısı
 No permission,Izni yok
-No record found,Kayıt bulunamadı
+No record found,Kayıt bulunamAdı
 No records found in the Invoice table,Fatura tablosunda kayıt bulunamadı
 No records found in the Payment table,Ödeme tablosunda kayıt bulunamadı
-No salary slip found for month: ,No salary slip found for month: 
-Non Profit,Kar
-Nos,Nos
+No salary slip found for month: , Ay için maaş makbuzu yok:
+Non Profit,Kar Yok
+Nos,Numaralar
 Not Active,Aktif değil
 Not Applicable,Uygulanamaz
 Not Available,Mevcut değil
-Not Billed,Faturalı Değil
+Not Billed,Faturalanmamış
 Not Delivered,Teslim Edilmedi
-Not Set,Not Set
-Not allowed to update stock transactions older than {0},Daha hisse senedi işlemleri büyük güncellemek için izin {0}
-Not authorized to edit frozen Account {0},Dondurulmuş Hesabı düzenlemek için yetkiniz yok {0}
-Not authroized since {0} exceeds limits,{0} sınırlarını aştığı Authroized değil
-Not permitted,İzin yok
+Not Set,Ayarlanmadı
+Not allowed to update stock transactions older than {0},{0} dan eski stok işlemlerini güncellemeye izin yok
+Not authorized to edit frozen Account {0},Dondurulmuş Hesabı {0} düzenleme yetkisi yok
+Not authroized since {0} exceeds limits,{0} Yetkili değil {0} sınırı aşar
+Not permitted,İzin verilmez
 Note,Not
 Note User,Not Kullanıcı
-"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Not: Yedekleme ve dosyaları Dropbox silinmez, bunları elle silmeniz gerekir."
-"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Not: Yedekleme ve dosyalar Google Drive silinmez, bunları elle silmeniz gerekir."
-Note: Due Date exceeds the allowed credit days by {0} day(s),Not: Due Date {0} gün (ler) tarafından izin verilen kredi gün aşıyor
-Note: Email will not be sent to disabled users,Not: E-posta engelli kullanıcılara gönderilmeyecek
+"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Not: Yedekleme ve dosyalar Dropbox'dan silinmedi, bunları elle silmeniz gerekir."
+"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Not: Yedekleme ve dosyalar Google Drive'dan silinmez, bunları elle silmeniz gerekir."
+Note: Due Date exceeds the allowed credit days by {0} day(s),Not: Vade tarihi izin verilen kredi günlerini {0} günle geçer
+Note: Email will not be sent to disabled users,Not: E-posta engelli kullanıcılara gönderilmeyecektir
 Note: Item {0} entered multiple times,Not: Ürün {0} birden çok kez girilmiş
-Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Not: Ödeme Entry 'Kasa veya Banka Hesabı' belirtilmedi bu yana oluşturulmuş olmayacak
-Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Not: Sistem Ürün için teslimat ve aşırı-rezervasyon kontrol olmaz {0} nicelik ya da miktar olarak 0'dır
-Note: There is not enough leave balance for Leave Type {0},Not: bırak türü için yeterli izni denge yok {0}
-Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Not: Bu Maliyet Merkezi bir Grup. Gruplara karşı muhasebe kayıtlarını yapamazsınız.
+Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"'Nakit veya Banka Hesabı' belirtilmediğinden ötürü, Ödeme Girdisi oluşturulmayacaktır"
+Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Not: Miktar 0 olduğundan ötürü sistem Ürün {0} için teslimat ve ayırma kontrolü yapmayacaktır
+Note: There is not enough leave balance for Leave Type {0},Not: İzin tipi {0} için yeterli izin günü kalmamış
+Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Not: Bu Maliyet Merkezi bir Grup. Gruplara karşı muhasebe kayıtları yapamazsınız.
 Note: {0},Not: {0}
 Notes,Notlar
 Notes:,Notlar:
-Nothing to request,Istemek için hiçbir şey
+Nothing to request,Talep edecek bir şey yok
 Notice (days),Bildirimi (gün)
 Notification Control,Bildirim Kontrolü
 Notification Email Address,Bildirim E-posta Adresi
-Notify by Email on creation of automatic Material Request,Otomatik Malzeme Talebi oluşturulması üzerinde e-posta ile bildir
+Notify by Email on creation of automatic Material Request,Otomatik Malzeme Talebi oluşturulması durumunda e-posta ile bildir
 Number Format,Sayı Biçimi
 Offer Date,Teklif Tarihi
 Office,Ofis
-Office Equipments,Büro Gereçleri
-Office Maintenance Expenses,Büro Bakım ve Onarım Giderleri
+Office Equipments,Ofis Gereçleri
+Office Maintenance Expenses,Ofis Bakım Giderleri
 Office Rent,Ofis Kiraları
-Old Parent,Old Parent
-On Net Total,Net Toplam
-On Previous Row Amount,On Previous Row Amount
-On Previous Row Total,On Previous Row Total
+Old Parent,Eski Ebeveyn
+On Net Total,Net toplam
+On Previous Row Amount,Önceki satır toplamı
+On Previous Row Total,Önceki satır toplamı
 Online Auctions,Online Müzayede
-Only Leave Applications with status 'Approved' can be submitted,Sadece teslim edilebilir 'Onaylı' statüsü ile Uygulamalar bırakın
-"Only Serial Nos with status ""Available"" can be delivered.","Durumu ile yalnızca Seri Nos ""Available"" teslim edilebilir."
-Only leaf nodes are allowed in transaction,Only leaf nodes are allowed in transaction
-Only the selected Leave Approver can submit this Leave Application,Sadece seçilen bırak Approver bu bırak Uygulama sunabilirsiniz
-Open,Açık
-Open Production Orders,Açık Üretim Siparişleri
-Open Tickets,Open Tickets
+Only Leave Applications with status 'Approved' can be submitted,Sadece durumu 'Onaylandı' olan İzin Uygulamaları verilebilir
+"Only Serial Nos with status ""Available"" can be delivered.",Yalnızca durumu 'Erişilebilir' olan Seri numaraları teslim edilebilir
+Only leaf nodes are allowed in transaction,İşlemde yalnızca yaprak düğümlere izin verilir
+Only the selected Leave Approver can submit this Leave Application,Yalnızca seçilen izin onaylayıcı bu İzin uygulamasını verebilir
+Open,Aç
+Open Production Orders,Üretim Siparişlerini Aç
+Open Tickets,iletleri Aç
 Opening (Cr),Açılış (Cr)
 Opening (Dr),Açılış (Dr)
 Opening Date,Açılış Tarihi
-Opening Entry,Giriş deliği
-Opening Qty,Açılış Adet
-Opening Time,Açılış Saati
-Opening Value,Açılış Değer
-Opening for a Job.,Opening for a Job.
-Operating Cost,İşletim Maliyeti
-Operation Description,Operasyon Açıklaması
-Operation No,Operasyon No
-Operation Time (mins),Çalışma Süresi (dakika)
-Operation {0} is repeated in Operations Table,Çalışma {0} Operations Tablo tekrarlanır
-Operation {0} not present in Operations Table,Operasyon Tablo Operasyon {0} mevcut değil
+Opening Entry,Giriş Girdisi
+Opening Qty,Açılış Miktarı
+Opening Time,Açılış Zamanı
+Opening Value,Açılış Değeri
+Opening for a Job.,İş Açılışı.
+Operating Cost,İşletme Maliyeti
+Operation Description,İşletme Tanımı
+Operation No,İşletme No
+Operation Time (mins),İşletme Süresi (dakika)
+Operation {0} is repeated in Operations Table,İşlem {0} İşlemler tablosunda tekrarlanır
+Operation {0} not present in Operations Table,İşlem {0} işlemler tablosunda mevcut değil
 Operations,Operasyonlar
 Opportunity,Fırsat
-Opportunity Date,Fırsat Tarihi
-Opportunity From,Fırsat Gönderen
-Opportunity Item,Fırsat Ürün
+Opportunity Date,Fırsat tarihi
+Opportunity From,Fırsattan itibaren
+Opportunity Item,Fırsat Ürünü
 Opportunity Items,Fırsat Ürünleri
-Opportunity Lost,Kaybedilen Fırsatlar
+Opportunity Lost,Kayıp Fırsat
 Opportunity Type,Fırsat Türü
-Optional. This setting will be used to filter in various transactions.,"İsteğe bağlı. Bu ayar, çeşitli işlemler filtrelemek için kullanılacaktır."
+Optional. This setting will be used to filter in various transactions.,İsteğe bağlı. Bu ayar çeşitli işlemlerde filtreleme yapmak için kullanılacaktır
 Order Type,Sipariş Türü
-Order Type must be one of {0},Sipariş Tipi biri olmalıdır {0}
+Order Type must be one of {0},Sipariş türü şunlardan biri olmalıdır {0}
 Ordered,Sipariş Edildi
-Ordered Items To Be Billed,Faturalandırılmış Ürünler
-Ordered Items To Be Delivered,Teslim Edilmiş Ürünler
+Ordered Items To Be Billed,Faturalanacak Sipariş Edilen Ürünler
+Ordered Items To Be Delivered,Teslim edilecek Sipariş Edilen Ürünler
 Ordered Qty,Sipariş Miktarı
-"Ordered Qty: Quantity ordered for purchase, but not received.","Adet emretti: Miktar satın almak için sipariş, ama almadım."
-Ordered Quantity,Sipariş Miktarı
-Orders released for production.,Orders released for production.
+"Ordered Qty: Quantity ordered for purchase, but not received.","Sipariş Edilen  Miktar: Satın alınmak için sipariş edilmiş, ancak teslim alınmamış miktar"
+Ordered Quantity,Sipariş Edilen Miktar
+Orders released for production.,Üretim için verilen emirler.
 Organization Name,Kuruluş Adı
-Organization Profile,Şirket Profili
-Organization branch master.,Organizasyon şube usta.
-Organization unit (department) master.,Organizasyon birimi (bölge) usta.
+Organization Profile,Kuruluş Profili
+Organization branch master.,Kuruluş Şube Alanı
+Organization unit (department) master.,Kuruluş Birimi (departman) alanı
 Other,Diğer
 Other Details,Diğer Detaylar
 Others,Diğer
-Out Qty,Miktar Out
-Out Value,Değer Out
-Out of AMC,AMC Out
+Out Qty,Çıkış Miktarı
+Out Value,Çıkış Değeri
+Out of AMC,Çıkış AMC
 Out of Warranty,Garanti Dışı
 Outgoing,Giden
-Outstanding Amount,Outstanding Amount
-Outstanding for {0} cannot be less than zero ({1}),Üstün {0} en az sıfır olamaz için ({1})
-Overhead,Overhead
+Outstanding Amount,Bekleyen Tutar
+Outstanding for {0} cannot be less than zero ({1}),{0} için bekleyen sıfırdan az olamaz ({1})
+Overhead,Genel Masraflar
 Overheads,Genel giderler
-Overlapping conditions found between:,Arasında bulunan örtüşen durumlar:
+Overlapping conditions found between:,Şunların arasında çakışan koşullar bulundu:
 Overview,Genel Bakış
-Owned,Owned
+Owned,Hisseli
 Owner,Sahibi
 P L A - Cess Portion,PLA - Cess Porsiyon
 PL or BS,PL veya BS
-PO Date,PO Tarihi
-PO No,PO yok
-POP3 Mail Server,POP3 Mail Server
+PO Date,PO Tarih
+PO No,PO No
+POP3 Mail Server,POP3 Mail Sunucu
 POP3 Mail Settings,POP3 Posta Ayarları
-POP3 mail server (e.g. pop.gmail.com),POP3 Mail Server (ör. pop.gmail.com)
-POP3 server e.g. (pop.gmail.com),POP3 sunucusu ör. (Pop.gmail.com)
+POP3 mail server (e.g. pop.gmail.com),POP3 posta sunucusu (örneğin pop.gmail.com)
+POP3 server e.g. (pop.gmail.com),"POP3 sunucusu, örneğin (pop.gmail.com)"
 POS Setting,POS Ayarı
-POS Setting required to make POS Entry,POS giriş yapmak için gerekli POS Ayarı
-POS Setting {0} already created for user: {1} and company {2},POS Ayar {0} zaten kullanıcı için oluşturulan: {1} ve şirket {2}
+POS Setting required to make POS Entry,POS girdisi yapmak için POS Ayarı gerekir
+POS Setting {0} already created for user: {1} and company {2},POS Kullanıcı {1} ve şirket {2} için POS ayarı {0} zaten oluşturulmuştur 
 POS View,POS görüntüle
-PR Detail,PR Detay
+PR Detail,PR Detayı
 Package Item Details,Paket Ürün Detayları
-Package Items,Paket Ürünler
-Package Weight Details,Paket Ağırlığı Detayları
+Package Items,Ambalaj Ürünleri
+Package Weight Details,Ambalaj Ağırlığı Detayları
 Packed Item,Paketli Ürün
-Packed quantity must equal quantity for Item {0} in row {1},{0} üst üste {1} Paketli miktar Ürün için bir miktar eşit olmalıdır
-Packing Details,Ambalaj Detayları
-Packing List,Paketleme Listesi
-Packing Slip,Paketleme Listesi slibi
-Packing Slip Item,Paketleme Listesi slibi ürünü
-Packing Slip Items,Paketleme Listesi slibi ürünleri
-Packing Slip(s) cancelled,Ambalaj Kayma (ler) iptal
-Page Break,Page Break
+Packed quantity must equal quantity for Item {0} in row {1},{1} Paketli miktar satır {1} deki Ürün {0} a eşit olmalıdır
+Packing Details,Paketleme Detayları
+Packing List,Paket listesi
+Packing Slip,Ambalaj Makbuzu
+Packing Slip Item,Ambalaj Makbuzu Ürünleri
+Packing Slip Items,Ambalaj Makbuzu Ürünleri
+Packing Slip(s) cancelled,Ambalaj Makbuzları İptal Edildi
+Page Break,Sayfa Sonu
 Page Name,Sayfa Adı
 Paid Amount,Ödenen Tutar
-Paid amount + Write Off Amount can not be greater than Grand Total,Ödenen miktar + Tutar yaz Off Büyük Toplam daha büyük olamaz
+Paid amount + Write Off Amount can not be greater than Grand Total,Ödenen miktar + Borç İptali  Toplamdan fazla olamaz
 Pair,Çift
 Parameter,Parametre
-Parent Account,Parent Account
-Parent Cost Center,Parent Cost Center
-Parent Customer Group,Parent Customer Group
-Parent Detail docname,Parent Detail docname
-Parent Item,Parent Item
-Parent Item Group,Parent Item Group
-Parent Item {0} must be not Stock Item and must be a Sales Item,Üst Öğe {0} Hazır değil Öğe olmalı ve Satış Ürün olmalı
-Parent Party Type,Veli Parti Türü
-Parent Sales Person,Parent Sales Person
-Parent Territory,Parent Territory
-Parent Website Page,Veli Web Sayfası
-Parent Website Route,Ebeveyn Sitesi Rota
-Parenttype,Parenttype
-Part-time,Part time
+Parent Account,Ana Hesap
+Parent Cost Center,Ana Maliyet Merkezi
+Parent Customer Group,Ana Müşteri Grubu
+Parent Detail docname,Ana Detay belgesi adı
+Parent Item,Ana Ürün
+Parent Item Group,Ana Ürün Grubu
+Parent Item {0} must be not Stock Item and must be a Sales Item,Ana Ürün {0} Stok Ürünü olmamalı ve Satış Ürünü olmalıdır
+Parent Party Type,Ana Parti Türü
+Parent Sales Person,Ana Satış Elemanı
+Parent Territory,Ana Bölge
+Parent Website Page,Ana Web Sayfası
+Parent Website Route,Ana Site Rotası
+Parenttype,Ana Tip
+Part-time,Yarı Zamanlı
 Partially Completed,Kısmen Tamamlandı
-Partly Billed,Parçalı Faturalı
-Partly Delivered,Kısmen Teslim
-Partner Target Detail,Partner Hedef Detayları
+Partly Billed,Kısmen Faturalandı
+Partly Delivered,Kısmen Teslim Edildi
+Partner Target Detail,Ortak Hedef Detayı
 Partner Type,Ortak Türü
 Partner's Website,Ortağın Sitesi
-Party,Parti
-Party Account,Parti Hesap
-Party Type,Parti Türü
-Party Type Name,Parti Tür Ad
+Party,Taraf
+Party Account,Taraf Hesabı
+Party Type,Taraf Türü
+Party Type Name,Taraf Tür Adı
 Passive,Pasif
 Passport Number,Pasaport Numarası
-Password,Şifre
-Pay To / Recd From,Gönderen / RECD Pay To
-Payable,Ödenecek
+Password,Parola
+Pay To / Recd From,Gönderen/Alınan
+Payable,Borç
 Payables,Borçlar
 Payables Group,Borçlar Grubu
-Payment Days,Ödeme günleri
+Payment Days,Ödeme Günleri
 Payment Due Date,Son Ödeme Tarihi
-Payment Period Based On Invoice Date,Fatura Tarihi Dayalı Ödeme Süresi
-Payment Reconciliation,Ödeme Uzlaşma
-Payment Reconciliation Invoice,Ödeme Uzlaşma Fatura
-Payment Reconciliation Invoices,Ödeme Uzlaşma Faturalar
-Payment Reconciliation Payment,Ödeme Uzlaşma Ödeme
-Payment Reconciliation Payments,Ödeme Uzlaşma Ödemeler
+Payment Period Based On Invoice Date,Fatura Tarihine Dayalı Ödeme Süresi
+Payment Reconciliation,Ödeme Mutabakat
+Payment Reconciliation Invoice,Ödeme Mutabakat Faturası
+Payment Reconciliation Invoices,Ödeme Mutabakat Faturaları
+Payment Reconciliation Payment,Ödeme Mutabakat Ödemesi
+Payment Reconciliation Payments,Ödeme Mutabakat Ödemeleri
 Payment Type,Ödeme Şekli
-Payment cannot be made for empty cart,Ödeme boş sepeti için yapılmış olamaz
-Payment of salary for the month {0} and year {1},Ay için maaş ödeme {0} ve yıl {1}
+Payment cannot be made for empty cart,Boş sepet için ödeme yapılamaz
+Payment of salary for the month {0} and year {1},Ay {0} ve yıl {1} için maaş ödemesi
 Payments,Ödemeler
 Payments Made,Yapılan Ödemeler
 Payments Received,Alınan Ödemeler
-Payments made during the digest period,Sindirmek dönemde yapılan ödemeler
-Payments received during the digest period,Sindirmek döneminde alınan ödemeler
+Payments made during the digest period,Düzenleme döneminde yapılan ödemeler
+Payments received during the digest period,Düzenleme döneminde alınan ödemeler
 Payroll Settings,Bordro Ayarları
-Pending,Bekleniyor
+Pending,Bekliyor
 Pending Amount,Bekleyen Tutar
-Pending Items {0} updated,Bekleyen Öğeler {0} güncellendi
-Pending Review,İnceleme Bekleniyor
-Pending SO Items For Purchase Request,Satınalma İste SO Öğeler Bekliyor
+Pending Items {0} updated,Bekleyen Ürünler {0} güncellendi
+Pending Review,Bekleyen İnceleme
+Pending SO Items For Purchase Request,Satın Alma Talebi bekleyen PO Ürünleri
 Pension Funds,Emeklilik Fonları
-Percent Complete,Komple Yüzde
+Percent Complete,Yüzde Tamamlandı
 Percentage Allocation,Yüzde Tahsisi
-Percentage Allocation should be equal to 100%,Yüzde Tahsis% 100'e eşit olmalıdır
-Percentage variation in quantity to be allowed while receiving or delivering this item.,Percentage variation in quantity to be allowed while receiving or delivering this item.
-Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Eğer miktar karşı daha fazla almak veya teslim etmek için izin Yüzde emretti. Örneğin: 100 adet sipariş varsa. ve Ödeneği sonra 110 adet almak için 10% izin edilir.
+Percentage Allocation should be equal to 100%,Yüzde Tahsisi % 100'e eşit olmalıdır
+Percentage variation in quantity to be allowed while receiving or delivering this item.,Bu Ürünü alırken veya teslim ederken izin verilecek olan miktarda yüzde değişimi.
+Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Sipariş edilen miktara karşı alabileceğiniz veya teslim edebileceğiniz daha fazla miktar. Örneğin, 100 birim sipariş verdiyseniz,izniniz %10'dur, bu durumda 110 birim almaya izniniz vardır."
 Performance appraisal.,Performans değerlendirme.
 Period,Dönem
-Period Closing Voucher,Dönem Kapanış Fişi
+Period Closing Voucher,Dönem Kapanış Makbuzu
 Periodicity,Periyodik olarak tekrarlanma
-Permanent Address,Kalıcı Adres
-Permanent Address Is,Kalıcı Adres mı
-Permission,Izin
+Permanent Address,Daimi Adres
+Permanent Address Is,Kalıcı Adres
+Permission,İzin
 Personal,Kişisel
-Personal Details,Kişisel Bilgileri
+Personal Details,Kişisel Bilgiler
 Personal Email,Kişisel E-posta
-Pharmaceutical,İlaç
-Pharmaceuticals,İlaç sekt
+Pharmaceutical,Ecza
+Pharmaceuticals,Ecza
 Phone,Telefon
-Phone No,Telefon No
+Phone No,Telefon Yok
 Piecework,Parça başı iş
-Pincode,Posta kodu
-Place of Issue,Place of Issue
-Plan for maintenance visits.,Bakım ziyaretleri planlıyoruz.
+Pincode,Pinkodu
+Place of Issue,Verildiği yer
+Plan for maintenance visits.,Bakım ziyaretleri planı
 Planned Qty,Planlanan Miktar
-"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planlanan Miktar: Miktar, bunun için, Üretim Sipariş gündeme gelmiştir, ancak imal edilecek beklemede."
+"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planlanan Miktar: Üretim Emrinin verildiği, ancak üretimi bekleyen miktar"
 Planned Quantity,Planlanan Miktar
 Planning,Planlama
 Plant,Tesis
-Plant and Machinery,Bitki ve Makina
-Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.
-Please Update SMS Settings,SMS Ayarlarını Güncelleme Lütfen
-Please add expense voucher details,Gider pusulası ayrıntılarını ekleyin
-Please add to Modes of Payment from Setup.,Kur dan Ödeme Şekilleri ekleyiniz.
-Please check 'Is Advance' against Account {0} if this is an advance entry.,Hesap karşı 'Advance mi' kontrol edin {0} bu bir avans girdi ise.
-Please click on 'Generate Schedule','Oluştur Takviminde tıklayınız
-Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Seri No Ürün için eklenen getirmek için 'Oluştur Takviminde tıklayınız {0}
-Please click on 'Generate Schedule' to get schedule,Programı almak için 'Oluştur Takviminde tıklayınız
-Please create Customer from Lead {0},Lead adlı Müşteri yaratmak Lütfen {0}
-Please create Salary Structure for employee {0},Çalışan Maaş Yapı oluşturmak Lütfen {0}
-Please create new account from Chart of Accounts.,Hesap Planı yeni bir hesap oluşturun.
-Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Müşteriler ve Tedarikçiler için Hesabı (Defterler) oluşturmak etmeyin lütfen. Onlar Müşteri / Tedarikçi ustalardan doğrudan oluşturulur.
+Plant and Machinery,Tesis ve Makina
+Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Lütfen Kısaltmayı doğru giriniz çünkü bu Ek olarak Bütün hesap başlıklarına eklenecektir.
+Please Update SMS Settings,Lütfen SMS ayarlarını güncelleyiniz
+Please add expense voucher details,Lütfen Gider dekontu detaylarına giriniz
+Please add to Modes of Payment from Setup.,Lütfen Kurulumdan Ödeme Biçimlerini ekleyin
+Please check 'Is Advance' against Account {0} if this is an advance entry.,Eğer bu bir avans girdisi ise Hesap {0} karşısına 'Avans' işaretleyiniz
+Please click on 'Generate Schedule','Takvim Oluştura' tıklayınız
+Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Ürün {0} seri numarası eklemek için 'Program Ekle' ye tıklayınız
+Please click on 'Generate Schedule' to get schedule,Programı almak için 'Program Oluştura' tıklayınız
+Please create Customer from Lead {0},Lütfen alan {0}'dan Müşteri oluşturunuz
+Please create Salary Structure for employee {0},Lütfen çalışan {0} için Maaş Yapısı oluşturunuz
+Please create new account from Chart of Accounts.,Lütfen hesap tablosundan yeni hesap oluşturunuz
+Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Lütfen  Müşteriler ve Tedarikçiler için Hesaplar (defterler) oluşturmayınız. Bunlar doğrudan Müşteri/Tedarikçi alanlarından oluşturulacaktır.
 Please enter 'Expected Delivery Date','Beklenen Teslim Tarihi' girin
-Please enter 'Is Subcontracted' as Yes or No,Girin Evet veya Hayır olarak 'Taşeron mı'
-Please enter 'Repeat on Day of Month' field value,Alan değerinin 'ayın günü Repeat' girin
-Please enter Account Receivable/Payable group in company master,Şirket master Hesap Alacak / Borç grup girin
-Please enter Approving Role or Approving User,Rolü Onaylanmasının veya Kullanıcı Onaylanmasının giriniz
-Please enter BOM for Item {0} at row {1},Ürün için BOM giriniz {0} satırdaki {1}
-Please enter Company,Şirket girin
+Please enter 'Is Subcontracted' as Yes or No,'Taşeron var mı' alanına Evet veya Hayır giriniz
+Please enter 'Repeat on Day of Month' field value,Ayın 'Belli Gününde Tekrarla' alanına değer giriniz
+Please enter Account Receivable/Payable group in company master,Şirket master Hesap Alacak / Borç grubu giriniz
+Please enter Approving Role or Approving User,Onaylayıcı Rol veya Onaylayıcı Kullanıcı Giriniz
+Please enter BOM for Item {0} at row {1},Satır{1} deki {0} Ürün için BOM giriniz
+Please enter Company,Şirket girin
 Please enter Cost Center,Maliyet Merkezi giriniz
-Please enter Delivery Note No or Sales Invoice No to proceed,Devam etmek İrsaliye No veya Satış Fatura No girin
-Please enter Employee Id of this sales parson,Bu satış Parson Çalışan Kimliği girin
+Please enter Delivery Note No or Sales Invoice No to proceed,Devam etmek İrsaliye No veya Satış Faturası No girin
+Please enter Employee Id of this sales parson,Bu satış personelinin Çalışan kimliğini girin
 Please enter Expense Account,Gider Hesabı girin
-Please enter Item Code to get batch no,Hiçbir toplu almak için Ürün Kodu girin
+Please enter Item Code to get batch no,Toplu almak için Ürün Kodu girin
 Please enter Item Code.,Ürün Kodu girin.
-Please enter Item first,İlk Öğe girin
-Please enter Maintaince Details first,Maintaince Ayrıntıları İlk giriniz
-Please enter Master Name once the account is created.,Hesap oluşturulduktan sonra Usta Adı girin.
-Please enter Planned Qty for Item {0} at row {1},Ürün için Planlanan Adet giriniz {0} satırdaki {1}
-Please enter Production Item first,İlk Üretim Ürün giriniz
-Please enter Purchase Receipt No to proceed,Hayır devam Satınalma Faturası giriniz
-Please enter Reference date,Başvuru tarihi girin
-Please enter Warehouse for which Material Request will be raised,Malzeme Talebi yükseltilmiş olacaktır hangi Depo giriniz
-Please enter Write Off Account,Hesap Kapalı yaz giriniz
-Please enter atleast 1 invoice in the table,Tabloda en az 1 fatura girin
-Please enter company first,İlk şirketi girin
-Please enter company name first,İlk şirket adını giriniz
-Please enter default Unit of Measure,Tedbir varsayılan Birimi giriniz
-Please enter default currency in Company Master,Şirket Master varsayılan para birimini girin
-Please enter email address,E-posta adresinizi girin
-Please enter item details,Öğesi ayrıntılarını girin
-Please enter message before sending,Göndermeden önce mesaj giriniz
-Please enter parent account group for warehouse account,Depo hesabı için ana hesap grubu girin
-Please enter parent cost center,Ebeveyn maliyet merkezi giriniz
-Please enter quantity for Item {0},Ürün için bir miktar giriniz {0}
-Please enter relieving date.,Tarihi giderici girin.
-Please enter sales order in the above table,Yukarıdaki tabloda satış siparişi giriniz
-Please enter valid Company Email,Geçerli Şirket E-posta giriniz
-Please enter valid Email Id,Geçerli bir e-posta id girin
-Please enter valid Personal Email,Geçerli Kişisel E-posta giriniz
-Please enter valid mobile nos,Geçerli bir cep telefonu nos giriniz
+Please enter Item first,Ürün Kodu girin
+Please enter Maintaince Details first,Lütfen ilk önce Bakım Detayını girin
+Please enter Master Name once the account is created.,İlk önce Bakım detaylarını girin
+Please enter Planned Qty for Item {0} at row {1},Satır {1} deki {0} Ürünler için planlanan miktarı giriniz
+Please enter Production Item first,Önce Üretim Ürününü giriniz
+Please enter Purchase Receipt No to proceed,İlerlemek için Satın Alma makbuzu numarası giriniz
+Please enter Reference date,Referrans tarihi girin
+Please enter Warehouse for which Material Request will be raised,Malzeme Talebinin yapılacağı Depoyu girin
+Please enter Write Off Account,Borç Silme Hesabı Girin
+Please enter atleast 1 invoice in the table,Tabloya en az 1 fatura girin
+Please enter company first,Lütfen ilk önce şirketi girin
+Please enter company name first,Lütfen ilk önce şirket adını girin
+Please enter default Unit of Measure,Lütfen Varsayılan Ölçü birimini girin
+Please enter default currency in Company Master,Lütfen Şirket Alanına varsayılan para birimini girin
+Please enter email address,Lütfen E-posta adresinizi girin
+Please enter item details,Lütfen ayrıntıları girin
+Please enter message before sending,Lütfen Göndermeden önce mesajı giriniz
+Please enter parent account group for warehouse account,Lütfen Depo hesabı i.in ana hesap grubu girin
+Please enter parent cost center,Lütfen ana maliyet merkezi giriniz
+Please enter quantity for Item {0},Lütfen Ürün {0} için miktar giriniz
+Please enter relieving date.,Lütfen Boşaltma tarihi girin.
+Please enter sales order in the above table,Lütfen Yukarıdaki tabloya satış siparişi giriniz
+Please enter valid Company Email,Lütfen Geçerli Şirket E-posta adresi giriniz
+Please enter valid Email Id,Lütfen Geçerli bir e-posta id girin
+Please enter valid Personal Email,Lütfen Geçerli bir Kişisel E-posta giriniz
+Please enter valid mobile nos,Lütfen Geçerli bir cep telefonu numarası giriniz
 Please find attached Sales Invoice #{0},Ektedir Satış Faturası # {0}
-Please install dropbox python module,Dropbox python modülü kurun
-Please mention no of visits required,Belirtin gerekli ziyaret hayır
-Please pull items from Delivery Note,İrsaliye öğeleri çekin lütfen
-Please save the Newsletter before sending,Göndermeden önce Haber saklayın
-Please save the document before generating maintenance schedule,Bakım programı oluşturmadan önce belgeyi saklayın
-Please see attachment,Eki bakın
+Please install dropbox python module,Dropbox python modunu kurun
+Please mention no of visits required,Lütfen gerekli ziyaretlerin sayısını belirtin
+Please pull items from Delivery Note,İrsaliyeden Ürünleri çekin
+Please save the Newsletter before sending,Lütfen göndermeden önce bülteni kaydedin
+Please save the document before generating maintenance schedule,Bakım programı oluşturmadan önce belgeyi kaydedin
+Please see attachment,Eke bakın
 Please select Bank Account,Banka Hesabı seçiniz
-Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Geçen mali yılın bakiyelerini bu mali yıla dahil etmek isterseniz Lütfen İleri Taşıyı seçin
 Please select Category first,İlk Kategori seçiniz
-Please select Charge Type first,Şarj Tipi İlk seçiniz
+Please select Charge Type first,İlk şarj türünü seçiniz
 Please select Fiscal Year,Mali Yıl seçiniz
-Please select Group or Ledger value,Grup veya Ledger değer seçiniz
-Please select Incharge Person's name,Incharge Kişinin adı seçiniz
+Please select Group or Ledger value,Grup veya Defter değeri seçiniz
+Please select Incharge Person's name,Sorumlu kişinin adını seçiniz
 Please select Invoice Type and Invoice Number in atleast one row,En az bir satırda Fatura Tipi ve Fatura Numarası seçiniz
-"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","""Stok Öğe mi"" ""Hayır"" ve ""Satış Item mi"" ""Evet"" ve başka hiçbir Satış BOM var Öğe seçiniz"
-Please select Price List,Fiyat Listesi Lütfen seçiniz
-Please select Start Date and End Date for Item {0},Başlangıç ​​Tarihi ve Öğe için Bitiş Tarihi seçiniz {0}
-Please select Time Logs.,Zaman Kayıtlar seçiniz.
-Please select a csv file,Bir csv dosya seçiniz
-Please select a valid csv file with data,Veri ile geçerli bir csv dosya seçiniz
-Please select a value for {0} quotation_to {1},Için bir değer seçiniz {0} quotation_to {1}
-"Please select an ""Image"" first","Ilk önce bir ""Image"" seçiniz"
+"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","""Stok Ürünü mü"" kısmının Hayır, ""Satış Ürünü mü"" kısmının Evet olduğıu yerde Ürün seçiniz"
+Please select Price List,Fiyat Listesi seçiniz
+Please select Start Date and End Date for Item {0},Ürün {0} için Başlangıç ve Bitiş tarihi seçiniz
+Please select Time Logs.,Zaman Kayıtlarını seçiniz.
+Please select a csv file,Bir csv dosyası seçiniz
+Please select a valid csv file with data,Veri içeren geçerli bir csv dosyası seçiniz
+Please select a value for {0} quotation_to {1},{0} - {1} teklifi için bir değer seçiniz
+"Please select an ""Image"" first","Ilk önce bir ""Resim"" seçiniz"
 Please select charge type first,İlk şarj türünü seçiniz
-Please select company first,İlk şirketi seçiniz
-Please select company first.,İlk şirketi seçiniz.
+Please select company first,Önce ücret tipi seçiniz
+Please select company first.,Önce Şirketi seçiniz.
 Please select item code,Ürün kodu seçiniz
-Please select month and year,Ay ve yılı seçiniz
-Please select prefix first,İlk önek seçiniz
-Please select the document type first,İlk belge türünü seçiniz
-Please select weekly off day,Haftalık kapalı bir gün seçiniz
-Please select {0},Lütfen seçin {0}
-Please select {0} first,İlk {0} seçiniz
-Please select {0} first.,İlk {0} seçiniz.
-Please set Dropbox access keys in your site config,Siteniz config Dropbox erişim tuşlarını ayarlamak Lütfen
-Please set Google Drive access keys in {0},Google Drive erişim tuşlarını ayarlamak Lütfen {0}
-Please set default Cash or Bank account in Mode of Payment {0},Ödeme Şekilleri varsayılan Kasa veya Banka hesabı ayarlamak Lütfen {0}
-Please set default value {0} in Company {0},Varsayılan değeri ayarlamak Lütfen {0} Şirketi {0}
-Please set {0},Set Lütfen {0}
-Please setup Employee Naming System in Human Resource > HR Settings,İnsan Kaynakları Lütfen kurulum Çalışan İsimlendirme Sistemi> HR Ayarları
-Please setup numbering series for Attendance via Setup > Numbering Series,Kurulum> Numaralandırma Serisi yoluyla Katılım için lütfen kurulum numaralandırma serisi
-Please setup your chart of accounts before you start Accounting Entries,Eğer Muhasebe başlıklar başlamadan önce Kur hesapları sizin grafik Lütfen
+Please select month and year,Ay ve yıl seçiniz
+Please select prefix first,Önce Ön ek seçiniz
+Please select the document type first,Önce belge türünü seçiniz
+Please select weekly off day,Haftalık izin gününü seçiniz
+Please select {0},Lütfen  {0} seçiniz
+Please select {0} first,Önce {0} seçiniz
+Please select {0} first.,Önce {0} seçiniz
+Please set Dropbox access keys in your site config,Lütfen site yapılandırmanızda Dropbox erişim anahtarı ayarlayınız
+Please set Google Drive access keys in {0},Lütfen {0} da Google Drive Erişim anahtarlarını ayarlayınız
+Please set default Cash or Bank account in Mode of Payment {0},{0} Ödeme şeklinde varsayılan nakit veya banka hesabı ayarlayınız
+Please set default value {0} in Company {0},Şirket {0} da varsayılan değer {0} ayarlayınız
+Please set {0},Lütfen {0} ayarlayınız
+Please setup Employee Naming System in Human Resource > HR Settings,İnsan Kaynakları>IK Ayarlarında sistemden Çalışan isimlendirmesi kurunuz
+Please setup numbering series for Attendance via Setup > Numbering Series,Kurulum>Seri numaralandırmayı kullanarak Devam numaralandırması kurunuz
+Please setup your chart of accounts before you start Accounting Entries,Muhasebe girdilerine başlamadan önce hesap şemanızı kurunuz
 Please specify,Lütfen belirtiniz
 Please specify Company,Şirket belirtiniz
 Please specify Company to proceed,Devam etmek için Firma belirtin
-Please specify Default Currency in Company Master and Global Defaults,Şirket Lisans ve Global Varsayılanlarını Standart Para belirtiniz
+Please specify Default Currency in Company Master and Global Defaults,Şirket Alanı ve Küresel Standartlardaki Para Birimini belirtiniz
 Please specify a,Lütfen belirtiniz
-Please specify a valid 'From Case No.','Dava No Kimden' geçerli bir belirtin
-Please specify a valid Row ID for {0} in row {1},Arka arkaya {0} için geçerli bir satır kimliğini belirtin {1}
-Please specify either Quantity or Valuation Rate or both,Miktar veya Değerleme Oranı ya da her ikisini de belirtiniz
-Please submit to update Leave Balance.,Bırak Denge güncellemek için gönderin.
+Please specify a valid 'From Case No.',Lütfen geçerlli bir 'durum nodan başlayarak' belirtiniz
+Please specify a valid Row ID for {0} in row {1},Satır {1} deki {0} için geçerli bir Satır Kimliği belirtiniz
+Please specify either Quantity or Valuation Rate or both,Miktar veya Değerleme Br.Fiyatı ya da her ikisini de belirtiniz
+Please submit to update Leave Balance.,Kalan izni güncellemek için gönderin.
 Plot,Konu
-Plot By,By arsa
-Point of Sale,Point of Sale
-Point-of-Sale Setting,Point-of-Sale Ayarı
-Post Graduate,Lisansüstü
+Plot By,Konu
+Point of Sale,Satış Noktası
+Point-of-Sale Setting,Satış Noktası Ayarı
+Post Graduate,Lisans Üstü
 Postal,Posta
 Postal Expenses,Posta Giderleri
 Posting Date,Gönderme Tarihi
 Posting Time,Gönderme Zamanı
-Posting date and posting time is mandatory,Gönderme tarih ve gönderme zamanı zorunludur
-Posting timestamp must be after {0},Gönderme timestamp sonra olmalıdır {0}
-Potential opportunities for selling.,Satış için potansiyel fırsatlar.
-Preferred Billing Address,Tercih Fatura Adresi
-Preferred Shipping Address,Tercih Teslimat Adresi
+Posting date and posting time is mandatory,Gönderme tarihi ve gönderme zamanı zorunludur
+Posting timestamp must be after {0},Gönderme zamanı damgası {0}'dan sonra olmalıdır
+Potential opportunities for selling.,Satış için potansiyel Fırsatlar.
+Preferred Billing Address,Tercih edilen Fatura Adresi
+Preferred Shipping Address,Tercih edilen Teslimat Adresi
 Prefix,Önek
-Present,Tanıt
+Present,Mevcut
 Prevdoc DocType,Prevdoc DocType
 Prevdoc Doctype,Prevdoc Doctype
 Preview,Önizleme
@@ -2131,599 +2131,599 @@
 Price / Discount,Fiyat / İndirim
 Price List,Fiyat listesi
 Price List Currency,Fiyat Listesi Para Birimi
-Price List Currency not selected,Fiyat Listesi Döviz seçili değil
-Price List Exchange Rate,Fiyat Listesi Kur
+Price List Currency not selected,Fiyat Listesi para birimi seçilmemiş
+Price List Exchange Rate,Fiyat Listesi Döviz Kuru
 Price List Name,Fiyat Listesi Adı
 Price List Rate,Fiyat Listesi Oranı
 Price List Rate (Company Currency),Fiyat Listesi Oranı (Şirket para birimi)
-Price List master.,Fiyat Listesi usta.
-Price List must be applicable for Buying or Selling,Fiyat Listesi Alış veya Satış için geçerli olmalı
-Price List not selected,Fiyat Listesi seçili değil
+Price List master.,Fiyat Listesi alanı
+Price List must be applicable for Buying or Selling,Fiyat Listesi Alış veya Satış için geçerli olmalıdır
+Price List not selected,Fiyat Listesi seçilmemiş
 Price List {0} is disabled,Fiyat Listesi {0} devre dışı
 Price or Discount,Fiyat veya İndirim
-Pricing Rule,Fiyatlandırma Kural
-Pricing Rule Help,Fiyatlandırma Kural Yardım
-"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Fiyatlandırma Kural İlk Ürün, Ürün Grubu veya Marka olabilir, hangi alanda 'On Uygula' göre seçilir."
-"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Fiyatlandırma Kural, bazı kriterlere dayalı, Fiyat Listesi / indirim yüzdesini tanımlamak üzerine yazmak için yapılır."
-Pricing Rules are further filtered based on quantity.,Fiyatlandırma Kurallar daha miktarına göre süzülür.
-Print Format Style,Baskı Biçim Stili
-Print Heading,Başlık Yazdır
-Print Without Amount,Tutar olmadan yazdır
+Pricing Rule,Fiyatlandırma Kuralı
+Pricing Rule Help,Fiyatlandırma Kuralı Yardım
+"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Fiyatlandırma Kuralı ilk olarak 'Uygula' alanı üzerinde seçilir, bu bir Ürün, Grup veya Marka olabilir."
+"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",Fiyatlandırma Kuralı Fiyat Listesini/belirtilen indirim yüzdesini belli kriterlere dayalı olarak geçersiz kılmak için yapılmıştır.
+Pricing Rules are further filtered based on quantity.,Fiyatlandırma Kuralları miktara dayalı olarak tekrar filtrelenir.
+Print Format Style,Baskı Biçimi
+Print Heading,Baskı Başlığı
+Print Without Amount,Tutarı olmadan yazdır
 Print and Stationary,Baskı ve Kırtasiye
 Printing and Branding,Baskı ve Markalaşma
 Priority,Öncelik
 Private Equity,Özel Sermaye
 Privilege Leave,Privilege bırak
 Probation,Deneme Süresi
-Process Payroll,Süreç Bordro
+Process Payroll,Süreç Bordrosu
 Produced,Üretilmiş
 Produced Quantity,Üretilen Miktar
 Product Enquiry,Ürün Sorgulama
 Production,Üretim
 Production Order,Üretim Siparişi
 Production Order status is {0},Üretim Sipariş durumu {0}
-Production Order {0} must be cancelled before cancelling this Sales Order,Üretim Sipariş {0} bu Satış Siparişi iptal etmeden önce iptal edilmelidir
-Production Order {0} must be submitted,Üretim Sipariş {0} sunulmalıdır
+Production Order {0} must be cancelled before cancelling this Sales Order,Üretim Siparişi {0} bu Satış Siparişi iptal edilmeden önce iptal edilmelidir
+Production Order {0} must be submitted,Üretim Siparişi {0} verilmelidir
 Production Orders,Üretim Siparişleri
-Production Orders in Progress,Devam Üretim Siparişleri
-Production Plan Item,Üretim Planı Ürün
-Production Plan Items,Üretim Planı Ürünler
+Production Orders in Progress,Devam eden Üretim Siparişleri
+Production Plan Item,Üretim Planı nesnesi
+Production Plan Items,Üretim Planı nesneleri
 Production Plan Sales Order,Üretim Planı Satış Siparişi
 Production Plan Sales Orders,Üretim Planı Satış Siparişleri
 Production Planning Tool,Üretim Planlama Aracı
 Products,Ürünler
-"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Ürünler varsayılan aramalarında ağırlık yaşa göre sıralanır. Daha ağırlık-yaş, yüksek ürün listesinde görünecektir."
+"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.",Ürünler standart aramalarda ağırlık-yaşa göre ayrılacaktır. Ağırlık-yaş ne kadar fazlaysa ürün de listede o kadar üstte görünecektir.
 Professional Tax,Profesyonel Vergi
 Profit and Loss,Kar ve Zarar
 Profit and Loss Statement,Kar ve Zarar Tablosu
 Project,Proje
-Project Costing,Maliyetlendirme Projesi
+Project Costing,Proje Maliyetlendirme
 Project Details,Proje Detayları
 Project Manager,Proje Müdürü
-Project Milestone,Proje Milestone
+Project Milestone,Proje Aşaması
 Project Milestones,Proje Aşamaları
 Project Name,Proje Adı
-Project Start Date,Proje Başlangıç ??Tarihi
+Project Start Date,Proje Başlangıç ​​Tarihi
 Project Type,Proje Tipi
-Project Value,Proje Değeri
-Project activity / task.,Proje etkinliği / görev.
-Project master.,Proje yöneticisi.
-Project will get saved and will be searchable with project name given,Project will get saved and will be searchable with project name given
-Project wise Stock Tracking,Proje bilge Stok Takibi
-Project-wise data is not available for Quotation,Proje bilge veri Teklifimizin mevcut değildir
+Project Value,Proje Bedeli
+Project activity / task.,Proje faaliyeti / görev.
+Project master.,Proje alanı.
+Project will get saved and will be searchable with project name given,Proje kaydedilecek  ve verilen bir proje Adı ile aranabilir olacak
+Project wise Stock Tracking,Proje bilgisi Stok Takibi
+Project-wise data is not available for Quotation,Proje bilgisi verileri Teklifimiz için mevcut değildir
 Projected,Öngörülen
-Projected Qty,projelendirilmiş Miktar
+Projected Qty,Öngörülen Tutar
 Projects,Projeler
 Projects & System,Projeler ve Sistem
-Prompt for Email on Submission of,Prompt for Email on Submission of
+Prompt for Email on Submission of,Başvuru üzerine E-posta cevabı
 Proposal Writing,Teklifi Yazma
-Provide email id registered in company,Şirketin kayıtlı e-posta id sağlayın
+Provide email id registered in company,Şirkette kayıtlı e-posta adresini veriniz
 Provisional Profit / Loss (Credit),Geçici Kar / Zarar (Kredi)
-Public,Kamu
-Published on website at: {0},De internet sitesinde yayımlanan: {0}
+Public,Genel
+Published on website at: {0},{0} da internet sitesinde yayınlanmıştır
 Publishing,Yayıncılık
-Pull sales orders (pending to deliver) based on the above criteria,Yukarıdaki kriterlere göre satış siparişleri (teslim etmek için bekleyen) çekin
-Purchase,Satın alma
-Purchase / Manufacture Details,Satınalma / İmalat Detayları
-Purchase Analytics,Satınalma Analytics
-Purchase Common,Ortak Satınalma
-Purchase Details,Satınalma Detayları
-Purchase Discounts,Satınalma İndirimler
+Pull sales orders (pending to deliver) based on the above criteria,Yukarıdaki kriterlere dayalı olarak (teslimat bekleyen) satış emirlerini çek
+Purchase,Satın Alım
+Purchase / Manufacture Details,Satın alma / İmalat Detayları
+Purchase Analytics,Satın alma analizleri
+Purchase Common,Ortak Satın Alma
+Purchase Details,Satın alma Detayları
+Purchase Discounts,Satın Alma indirimleri
 Purchase Invoice,Satınalma Faturası
-Purchase Invoice Advance,Satınalma Faturası Avans
-Purchase Invoice Advances,Satınalma Faturası Avansları
-Purchase Invoice Item,Satınalma Faturası Ürünleri
-Purchase Invoice Trends,Fatura Eğilimler Satınalma
-Purchase Invoice {0} is already submitted,Satınalma Fatura {0} zaten teslim edilir
-Purchase Order,Satınalma Siparişi
-Purchase Order Item,Satınalma Sipariş Ürün
-Purchase Order Item No,Satınalma Sipariş Ürün No
-Purchase Order Item Supplied,Satınalma Sipariş Ürün Tedarik edilen
-Purchase Order Items,Satınalma Sipariş Ürünleri
-Purchase Order Items Supplied,Satınalma Sipariş Ürün Tedarik edilen
-Purchase Order Items To Be Billed,Faturalı To Be Sipariş Kalemleri
-Purchase Order Items To Be Received,Alınan To Be Sipariş Kalemleri
-Purchase Order Message,Satınalma Sipariş Mesajı
-Purchase Order Required,Satınalma Sipariş Gerekli
-Purchase Order Trends,Sipariş Eğilimler Satınalma
-Purchase Order number required for Item {0},Sipariş numarası Ürün için gerekli {0}
-Purchase Order {0} is 'Stopped',{0} 'Durduruldu' olduğunu Satınalma Siparişi
-Purchase Order {0} is not submitted,Sipariş {0} teslim edilmez
-Purchase Orders given to Suppliers.,Tedarikçilere verilen satınalma siparişi
-Purchase Receipt,Satın Alma Makbuzu
-Purchase Receipt Item,Satın Alma Makbuzu Ürünleri
-Purchase Receipt Item Supplied,Satın Alma Makbuzu Ürünleri Tedarik edilen
-Purchase Receipt Item Supplieds,Satın Alma Makbuzu Ürünleri Tedarik edilen
-Purchase Receipt Items,Satın Alma Makbuzu Ürünleri
-Purchase Receipt Message,Satın Alma Makbuzu mesajları
-Purchase Receipt No,Satın Alma Makbuzu No
-Purchase Receipt Required,Satınalma Makbuzu Gerekli
-Purchase Receipt Trends,Satın Alındı ​​Trendler
-Purchase Receipt number required for Item {0},Ürün için gerekli Satın Alındı ​​numarası {0}
-Purchase Receipt {0} is not submitted,Satın Alındı ​​{0} teslim edilmez
-Purchase Register,Üye olun Satınalma
-Purchase Return,Satınalma İadesi
-Purchase Returned,Satınalma İade Edilenler
-Purchase Taxes and Charges,Satınalma Vergiler ve Harçlar
-Purchase Taxes and Charges Master,Ana Satınalma Vergiler ve Harçlar
-Purchse Order number required for Item {0},Purchse Sipariş Numarası Ürün için gerekli {0}
+Purchase Invoice Advance,Fatura peşin alım
+Purchase Invoice Advances,Satın alma Fatura avansları
+Purchase Invoice Item,Satın alma Faturası Ürünleri
+Purchase Invoice Trends,Satın alma fatura eğilimleri
+Purchase Invoice {0} is already submitted,Satın alma Faturası {0} zaten teslim edildi
+Purchase Order,Satın alma emri
+Purchase Order Item,Satınalma Siparişi Ürünleri
+Purchase Order Item No,Satınalma Siparişi Ürün No
+Purchase Order Item Supplied,Tedarik edilen Satınalma Siparişi Ürünü
+Purchase Order Items,Satınalma Siparişi Ürünleri
+Purchase Order Items Supplied,Tedarik edilen Satınalma Siparişi Ürünleri
+Purchase Order Items To Be Billed,Faturalanacak Satınalma Siparişi Kalemleri
+Purchase Order Items To Be Received,AlınacakSatınalma Siparişi Kalemleri
+Purchase Order Message,Satınalma Siparişi Mesajı
+Purchase Order Required,gerekli Satın alma Siparişi
+Purchase Order Trends,Satın alma Siparişi Eğilimleri
+Purchase Order number required for Item {0},Ürüni {0} için Satınalma Siparişi numarası gerekli
+Purchase Order {0} is 'Stopped',Satınalma Siparişi {0} 'Durduruldu'
+Purchase Order {0} is not submitted,Satınalma Siparişi {0} teslim edilmedi
+Purchase Orders given to Suppliers.,Tedarikçilere verilen Satın alma Siparişleri.
+Purchase Receipt,Satın Alma makbuzu
+Purchase Receipt Item,Satın Alma makbuzu Ürünleri
+Purchase Receipt Item Supplied,Tedarik edilen satın alma makbuzu ürünü
+Purchase Receipt Item Supplieds,Tedarik edilen satın alma makbuzu ürünü
+Purchase Receipt Items,Satın alma makbuzu Ürünleri
+Purchase Receipt Message,Satın alma makbuzu mesajı
+Purchase Receipt No,Satın alma makbuzu numarası
+Purchase Receipt Required,Gerekli Satın alma makbuzu
+Purchase Receipt Trends,Satın alma makbuzu eğilimleri
+Purchase Receipt number required for Item {0},Ürün {0} için gerekli Satın alma makbuzu numarası
+Purchase Receipt {0} is not submitted,Satın alma makbuzu {0} teslim edilmedi
+Purchase Register,Satın alma kaydı
+Purchase Return,Satın alma iadesi
+Purchase Returned,İade edilen satın alım
+Purchase Taxes and Charges,Alım Vergi ve Harçları
+Purchase Taxes and Charges Master,Alım Vergi ve Harçları Alanı
+Purchse Order number required for Item {0},Ürün {0} için Sipariş numarası gerekli
 Purpose,Amaç
-Purpose must be one of {0},Amaç biri olmalıdır {0}
-QA Inspection,QA Muayene
+Purpose must be one of {0},Amaç şunlardan biri olmalıdır: {0}
+QA Inspection,Kalite Güvence Denetimi
 Qty,Miktar
-Qty Consumed Per Unit,Miktar Birim Başına Tüketilen
-Qty To Manufacture,Imalatı için Miktar
-Qty as per Stock UOM,Qty as per Stock UOM
-Qty to Deliver,Sunun için Adet
-Qty to Order,Adet Sipariş
-Qty to Receive,Alma Adet
-Qty to Transfer,Transfer Adet
-Qualification,Yeterlik
+Qty Consumed Per Unit,Birim Başına Tüketilen Miktar
+Qty To Manufacture,Üretilecek Miktar
+Qty as per Stock UOM,Her Stok UOM için miktar
+Qty to Deliver,Teslim Edilecek Miktar
+Qty to Order,Sipariş Miktarı
+Qty to Receive,Alınacak Miktar
+Qty to Transfer,Transfer edilecek Miktar
+Qualification,{0}Yeterlilik{/0} {1} {/1}
 Quality,Kalite
 Quality Inspection,Kalite Kontrol
 Quality Inspection Parameters,Kalite Kontrol Parametreleri
 Quality Inspection Reading,Kalite Kontrol Okuma
 Quality Inspection Readings,Kalite Kontrol Okumalar
-Quality Inspection required for Item {0},Ürün için gerekli Kalite Kontrol {0}
+Quality Inspection required for Item {0},Ürün  {0} için gerekli Kalite Kontrol
 Quality Management,Kalite Yönetimi
 Quantity,Miktar
-Quantity Requested for Purchase,Satınalma Talebi miktarı
+Quantity Requested for Purchase,Alım için İstenen miktar
 Quantity and Rate,Miktarı ve Oranı
 Quantity and Warehouse,Miktar ve Depo
-Quantity cannot be a fraction in row {0},Miktarı satırına bir fraksiyonu olamaz {0}
-Quantity for Item {0} must be less than {1},Adet Ürün için {0} daha az olmalıdır {1}
-Quantity in row {0} ({1}) must be same as manufactured quantity {2},Miktarı satırına {0} ({1}) aynı olmalıdır üretilen miktar {2}
-Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials
-Quantity required for Item {0} in row {1},Ürün için gerekli miktar {0} üst üste {1}
+Quantity cannot be a fraction in row {0},Satır{0} daki miktar kesir olamaz
+Quantity for Item {0} must be less than {1},Ürün {0} için miktar{1} den az olmalıdır
+Quantity in row {0} ({1}) must be same as manufactured quantity {2},Satır {0} ({1}) deki miktar üretilen miktar {2} ile aynı olmalıdır
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Üretimden sonra elde edilen Ürün miktarı/ ham maddelerin belli miktarlarında yeniden ambalajlama
+Quantity required for Item {0} in row {1},Satır {1} deki Ürün {0} için gereken miktar
 Quarter,Çeyrek
 Quarterly,Üç ayda bir
 Quick Help,Hızlı Yardım
-Quotation,Teklif
-Quotation Item,Teklif Ürünleri
-Quotation Items,Tırnak Ürünleri
-Quotation Lost Reason,Teklif Nedeni Kayıp
-Quotation Message,Teklif Mesaj
-Quotation To,Için Teklif
-Quotation Trends,Teklif Trendler
-Quotation {0} is cancelled,Tırnak {0} iptal edilir
-Quotation {0} not of type {1},Tırnak {0} değil türünde {1}
-Quotations received from Suppliers.,Özlü Sözler Tedarikçiler alınan.
-Quotes to Leads or Customers.,Quotes to Leads or Customers.
-Raise Material Request when stock reaches re-order level,Hisse senedi yeniden sipariş seviyesine ulaştığında Malzeme İsteği Raise
-Raised By,By Yükseltilmiş
-Raised By (Email),(E) tarafından Yükseltilmiş
-Random,Rasgele
+Quotation,Fiyat Teklifi
+Quotation Item,Teklif Ürünü
+Quotation Items,Teklif Ürünleri
+Quotation Lost Reason,Teklif Kayıp Nedeni
+Quotation Message,Teklif Mesajı
+Quotation To,Teklif Etmek
+Quotation Trends,Teklif Trendleri
+Quotation {0} is cancelled,Teklif {0} iptal edildi
+Quotation {0} not of type {1},Teklif {0} {1} türünde
+Quotations received from Suppliers.,Tedarikçilerden alınan teklifler.
+Quotes to Leads or Customers.,Müşterilere veya Taleplere verilen fiyatlar.
+Raise Material Request when stock reaches re-order level,Stok yeniden sipariş düzeyine ulaştığında Malzeme talebinde bulun
+Raised By,Talep edilen
+Raised By (Email),(Email)  ile talep edilen
+Random,Rastgele
 Range,Aralık
-Rate,Oran
+Rate, Br.Fiyat
 Rate ,
 Rate (%),Oranı (%)
 Rate (Company Currency),Oranı (Şirket para birimi)
-Rate Of Materials Based On,Dayalı Malzeme Oranı
-Rate and Amount,Hızı ve Miktarı
-Rate at which Customer Currency is converted to customer's base currency,Puan hangi Müşteri Döviz müşteri tabanı para birimine dönüştürülür
-Rate at which Price list currency is converted to company's base currency,Fiyat listesi para şirketin temel para birimine dönüştürülür hangi Oranı
-Rate at which Price list currency is converted to customer's base currency,Fiyat listesi para müşteri tabanı para birimine dönüştürülür hangi Oranı
-Rate at which customer's currency is converted to company's base currency,Puan hangi müşterinin para birimi şirketin temel para birimine dönüştürülür
-Rate at which supplier's currency is converted to company's base currency,Tedarikçi para birimi şirketin temel para birimine dönüştürülür hangi Oranı
-Rate at which this tax is applied,Bu vergi uygulandığı andaki Puan
+Rate Of Materials Based On,Dayalı Ürün Br. Fiyatı
+Rate and Amount,Br.Fiyat ve Miktar
+Rate at which Customer Currency is converted to customer's base currency,Müşteri Para Biriminin Müşterinin temel birimine dönüştürülme oranı
+Rate at which Price list currency is converted to company's base currency,Fiyat listesi para biriminin şirketin temel para birimine dönüştürülme oranı
+Rate at which Price list currency is converted to customer's base currency,Fiyat listesi para biriminin müşterinin temel para birimine dönüştürülme oranı
+Rate at which customer's currency is converted to company's base currency,Müşterinin para biriminin şirketin temel para birimine dönüştürülme oranı
+Rate at which supplier's currency is converted to company's base currency,Tedarikçinin para biriminin şirketin temel para birimine dönüştürülme oranı
+Rate at which this tax is applied,Vergi uygulanma oranı
 Raw Material,Hammadde
-Raw Material Item Code,Hammadde Ürün Kodu
-Raw Materials Supplied,Tedarik Hammaddeler
-Raw Materials Supplied Cost,Hammadde Maliyeti Tedarik
-Raw material cannot be same as main Item,Hammadde ana öğe olarak aynı olamaz
+Raw Material Item Code,Hammadde Malzeme Kodu
+Raw Materials Supplied,Tedarik edilen Hammaddeler
+Raw Materials Supplied Cost,Tedarik edilen Hammadde  Maliyeti
+Raw material cannot be same as main Item,Hammadde ana Malzeme ile aynı olamaz
 Re-Order Level,Yeniden Sipariş Seviyesi
-Re-Order Qty,Yeniden Sipariş Miktar
-Re-order,Yeniden sipariş
+Re-Order Qty,Yeniden Sipariş Miktarı
+Re-order,Yeniden Sipariş
 Re-order Level,Yeniden sipariş seviyesi
 Re-order Qty,Yeniden sipariş Adet
-Read,Okumak
-Reading 1,Reading 1
-Reading 10,Reading 10
-Reading 2,Reading 2
+Read,Okundu
+Reading 1,1 Okuma
+Reading 10,10 Okuma
+Reading 2,2 Okuma
 Reading 3,Reading 3
-Reading 4,Reading 4
-Reading 5,Reading 5
-Reading 6,Reading 6
-Reading 7,Reading 7
-Reading 8,Reading 8
-Reading 9,Reading 9
+Reading 4,4 Okuma
+Reading 5,5 Okuma
+Reading 6,6 Okuma
+Reading 7,7 Okuma
+Reading 8,8 Okuma
+Reading 9,9 Okuma
 Real Estate,Gayrimenkul
-Reason,Neden
+Reason,Nedeni
 Reason for Leaving,Ayrılma Nedeni
 Reason for Resignation,İstifa Nedeni
 Reason for losing,Kaybetme nedeni
-Recd Quantity,RECD Miktar
+Recd Quantity,Alınan Miktar
 Receivable,Alacak
-Receivable / Payable account will be identified based on the field Master Type,Alacak / Borç hesabı alan Usta Türü göre tespit edilecektir
+Receivable / Payable account will be identified based on the field Master Type,Alacak / Borç hesabı alan  Türüne göre tespit edilecektir
 Receivables,Alacaklar
 Receivables / Payables,Alacaklar / Borçlar
 Receivables Group,Alacaklar Grubu
-Received Date,Alınan Tarihi
-Received Items To Be Billed,Faturalı To Be Alınan Öğeler
+Received Date,Alınan Tarih
+Received Items To Be Billed,Faturalanacak  Alınan Malzemeler
 Received Qty,Alınan Miktar
-Received and Accepted,Alınan ve Kabul
+Received and Accepted,Alındı ve Kabul edildi
 Receiver List,Alıcı Listesi
-Receiver List is empty. Please create Receiver List,Alıcı listesi boş. Alıcı listesi oluşturmanız
+Receiver List is empty. Please create Receiver List,Alıcı listesi boş. Alıcı listesi oluşturunuz
 Receiver Parameter,Alıcı Parametre
 Recipients,Alıcılar
 Reconcile,Uzlaştırmak
-Reconciliation Data,Uzlaşma Verisi
+Reconciliation Data,Uzlaşma Verileri
 Reconciliation HTML,Uzlaşma HTML
 Reconciliation JSON,Uzlaşma JSON
 Record item movement.,Tutanak madde hareketi.
-Recurring Id,Yinelenen Kimliği
-Recurring Invoice,Dönüşümlü Fatura
-Recurring Type,Yineleme Türü
-Reduce Deduction for Leave Without Pay (LWP),Izinde için Kesintisi azaltın (YSP)
-Reduce Earning for Leave Without Pay (LWP),Izinde için Kazanç azaltın (YSP)
+Recurring Id,Tekrarlanan Kimlik
+Recurring Invoice,Mükerrer Fatura
+Recurring Type,Tekrarlanma Türü
+Reduce Deduction for Leave Without Pay (LWP),Ücretsiz İzin (Üİ) için Kesintiyi azalt
+Reduce Earning for Leave Without Pay (LWP),Ücretsiz İzin (Üİ) için Kazancı azalt
 Ref,Ref
 Ref Code,Referans Kodu
-Ref SQ,Referans SQ
+Ref SQ,Ref SQ
 Reference,Referans
 Reference #{0} dated {1},Referans # {0} tarihli {1}
-Reference Date,Başvuru Tarihi
+Reference Date,Referans Tarihi
 Reference Name,Referans Adı
-Reference No & Reference Date is required for {0},Referans No ve Referans Tarih için gereklidir {0}
-Reference No is mandatory if you entered Reference Date,Eğer Başvuru Tarihi girdiyseniz Referans No zorunludur
+Reference No & Reference Date is required for {0},Referans No ve Referans Tarihi gereklidir {0}
+Reference No is mandatory if you entered Reference Date,Referans Tarihi girdiyseniz Referans No zorunludur
 Reference Number,Referans Numarası
-Reference Row #,Referans Row #
+Reference Row #,Referans Satırı #
 Refresh,Yenile
 Registration Details,Kayıt Detayları
 Registration Info,Kayıt Bilgileri
 Rejected,Reddedildi
 Rejected Quantity,Reddedilen Miktar
-Rejected Serial No,Reddedilen Seri No
+Rejected Serial No,Seri No Reddedildi
 Rejected Warehouse,Reddedilen Depo
-Rejected Warehouse is mandatory against regected item,Reddedilen Depo regected öğe karşı zorunludur
-Relation,Ilişki
-Relieving Date,Tarih rahatlatma
-Relieving Date must be greater than Date of Joining,Üyelik giderici Katılma tarihi daha büyük olmalıdır
-Remark,Açıklama
+Rejected Warehouse is mandatory against regected item,Reddedilen Depo reddedilen Ürün karşılığı zorunludur
+Relation,İlişki
+Relieving Date,Ayrılma Tarihi
+Relieving Date must be greater than Date of Joining,Ayrılma tarihi Katılma tarihinden sonra olmalıdır
+Remark,Dikkat
 Remarks,Açıklamalar
-Remarks Custom,Açıklamalar Özel
-Rename,Adını değiştir
-Rename Log,Giris yeniden adlandırma
-Rename Tool,Yeniden adlandırma aracı
+Remarks Custom,Gümrük Açıklamaları
+Rename,Yeniden adlandır
+Rename Log,Girişi yeniden adlandır
+Rename Tool,yeniden adlandırma aracı
 Rent Cost,Kira Bedeli
-Rent per hour,Saatte kiralamak
+Rent per hour,Saatlik kira
 Rented,Kiralanmış
-Repeat on Day of Month,Ayın günü tekrarlayın
-Replace,Değiştirmek
-Replace Item / BOM in all BOMs,Tüm ürün birimi (ÖB) değiştir
-Replied,Cevaplandı
+Repeat on Day of Month,Ayın gününde tekrarlayın
+Replace,Değiştir
+Replace Item / BOM in all BOMs,Bütün BOMlarla Ürün/BOM değiştir
+Replied,Cevap
 Report Date,Rapor Tarihi
 Report Type,Rapor Türü
 Report Type is mandatory,Rapor Tipi zorunludur
 Reports to,Raporlar
-Reqd By Date,Date reqd
-Reqd by Date,Reqd Tarih
+Reqd By Date,Tarihle gerekli
+Reqd by Date,Tarihle gerekli
 Request Type,İstek Türü
 Request for Information,Bilgi İsteği
-Request for purchase.,Satın alma talebi.
+Request for purchase.,Satın alma isteği.
 Requested,Talep
 Requested For,Için talep
-Requested Items To Be Ordered,Sıralı To Be talep Ürünleri
-Requested Items To Be Transferred,Transfer edilmesini istedi Ürünleri
-Requested Qty,İstenen Adet
-"Requested Qty: Quantity requested for purchase, but not ordered.","İstenen Miktar: Miktar sipariş alımı için istenen, ancak değil."
-Requests for items.,Öğeler için istekleri.
-Required By,Gerekli gören
+Requested Items To Be Ordered,Sipariş edilmesi istenen Ürünler
+Requested Items To Be Transferred,Transfer edilmesi istenen Ürünler
+Requested Qty,İstenen miktar
+"Requested Qty: Quantity requested for purchase, but not ordered.","İstenen Miktar: Satın almak için istenen, ancak sipariş edilmeyen miktar"
+Requests for items.,Ürün istekleri.
+Required By,Gerekli
 Required Date,Gerekli Tarih
-Required Qty,Gerekli Miktar
-Required only for sample item.,Sadece örnek ürün için gereklidir.
-Required raw materials issued to the supplier for producing a sub - contracted item.,Required raw materials issued to the supplier for producing a sub - contracted item.
+Required Qty,Gerekli Adet
+Required only for sample item.,Sadece örnek Ürün için gereklidir.
+Required raw materials issued to the supplier for producing a sub - contracted item.,Bir alt-sözleşme Malzemesi üretmek için tedarikçiye verilen gerekli ham maddeler.
 Research,Araştırma
 Research & Development,Araştırma ve Geliştirme
 Researcher,Araştırmacı
 Reseller,Bayi
-Reserved,Reserved
-Reserved Qty,Rezerve Adet
-"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezerve Miktar: Miktar satışı emretti, ama teslim."
-Reserved Quantity,Rezerve Miktarı
-Reserved Warehouse,Rezerve Depo
-Reserved Warehouse in Sales Order / Finished Goods Warehouse,Satış Sipariş / Mamul Depo saklıdır Atölyesi
-Reserved Warehouse is missing in Sales Order,Rezerve Depo Satış Siparişi eksik
-Reserved Warehouse required for stock Item {0} in row {1},Stok Öğe için gerekli saklıdır Depo {0} üst üste {1}
-Reserved warehouse required for stock item {0},Stok kalemi için gerekli rezerve depo {0}
+Reserved,Ayrılmış
+Reserved Qty,Ayrılmış Miktar
+"Reserved Qty: Quantity ordered for sale, but not delivered.","Ayrılan Miktar: Satış için sipariş edilen, ancak teslim edilmeyen miktar."
+Reserved Quantity,Ayrılan Miktar
+Reserved Warehouse,Ayrılan Depo
+Reserved Warehouse in Sales Order / Finished Goods Warehouse,Satış Sipariş / Satış Emrinde ayrılan Depo/ Mamül Deposu
+Reserved Warehouse is missing in Sales Order,Satış emrinde ayrılan Depo yok
+Reserved Warehouse required for stock Item {0} in row {1},Satır {1} deki Stok Ürünleri {0} için ayrılan Depo gerekir
+Reserved warehouse required for stock item {0},Stok kalemi  {0} için ayrılan Depo gerekir
 Reserves and Surplus,Yedekler ve Fazlası
 Reset Filters,Filtreleri Sıfırla
 Resignation Letter Date,İstifa Mektubu Tarihi
 Resolution,Karar
 Resolution Date,Karar Tarihi
 Resolution Details,Karar Detayları
-Resolved By,Çözüm üreten
-Rest Of The World,World Of istirahat
+Resolved By,Tarafından Çözülmüştür
+Rest Of The World,Dünyanın geri kalanı
 Retail,Perakende
 Retail & Wholesale,Toptan ve Perakende Satış
 Retailer,Perakendeci
-Review Date,Gözden Geçirme tarihi
+Review Date,İnceleme tarihi
 Rgt,Rgt
-Role Allowed to edit frozen stock,Rol dondurulmuş stok düzenlemek için İzin
-Role that is allowed to submit transactions that exceed credit limits set.,Set kredi limitlerini aşan işlemleri göndermek için izin verilir rolü.
+Role Allowed to edit frozen stock,dondurulmuş stok düzenlemeye İzinli rol
+Role that is allowed to submit transactions that exceed credit limits set.,Kredi limiti ayarlarını geçen işlemleri teslim etmeye izinli rol
 Root Type,Kök Tipi
 Root Type is mandatory,Kök Tipi zorunludur
-Root account can not be deleted,Root hesabı silinemez
+Root account can not be deleted,Kök hesabı silinemez
 Root cannot be edited.,Kök düzenlenemez.
-Root cannot have a parent cost center,Kök bir üst maliyet merkezi olamaz
-Rounded Off,Yuvarlak Kapalı
-Rounded Total,Rounded Total
-Rounded Total (Company Currency),Yuvarlak Toplam (Şirket para birimi)
-Row # ,# Satır
-Row # {0}: ,Row # {0}: 
-Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Satır # {0}: Sıralı Adet Adet (öğe master tanımlanan) öğesinin minimum sipariş adet daha az olamaz.
-Row #{0}: Please specify Serial No for Item {1},Satır # {0}: Ürün seri no belirtiniz {1}
-Row {0}: Account does not match with \						Purchase Invoice Credit To account,Satır {0}: \ Satın Fatura Kredi hesabı için Hesabı ile uyuşmuyor
-Row {0}: Account does not match with \						Sales Invoice Debit To account,Satır {0}: \ Satış Faturası banka hesabı için Hesap ile uyuşmuyor
-Row {0}: Conversion Factor is mandatory,Satır {0}: Katsayı zorunludur
-Row {0}: Credit entry can not be linked with a Purchase Invoice,Satır {0}: Kredi girişi Satınalma Fatura ile bağlantılı olamaz
-Row {0}: Debit entry can not be linked with a Sales Invoice,Satır {0}: Banka giriş Satış Fatura ile bağlantılı olamaz
-Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Satır {0}: Ödeme tutarı veya daha az kalan miktar fatura eşittir olmalıdır. Aşağıda dikkat bakınız.
+Root cannot have a parent cost center,Kökün ana maliyet merkezi olamaz
+Rounded Off,Yuvarlanmış
+Rounded Total,Yuvarlanmış Toplam
+Rounded Total (Company Currency),Yuvarlanmış Toplam (Şirket para birimi)
+Row # , Satır No
+Row # {0}: ,Satır # {0}
+Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Satır # {0}:  sipariş edilen miktar Ürünlerin minimum sipariş tutarından az olamaz (Ürün alanında belirtilir)
+Row #{0}: Please specify Serial No for Item {1},Satır # {0}: Ürün{1} için seri no belirtiniz 
+Row {0}: Account does not match with \						Purchase Invoice Credit To account,Satır {0}: Hesap \Satın Alma Faturası Hesap Kredisi ile eşleşmiyor
+Row {0}: Account does not match with \						Sales Invoice Debit To account,Satır {0}: Hesap \Satış Faturası Hesap Borcu ile eşleşmiyor
+Row {0}: Conversion Factor is mandatory,Satır {0}: Dönüşüm katsayısı zorunludur
+Row {0}: Credit entry can not be linked with a Purchase Invoice,Satır {0}: Kredi girdisi bir Satın alma faturası ile bağlantılı olamaz
+Row {0}: Debit entry can not be linked with a Sales Invoice,Satır {0}: Borç girdisi Satış faturası ile bağlantılı olamaz
+Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Satır {0}: Ödeme miktarı bekleyen fatura tutarından az veya buna eşit olmalıdır
 Row {0}: Qty is mandatory,Satır {0}: Miktar zorunludur
-"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}","Satır {0}: Miktar depoda Avalable {1} değil {2} {3}. Mevcut Adet: {4}, Adet aktarın: {5}"
-"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}","Satır {0}: ayarlamak için {1}, sıklığı, yeri ve tarihi arasındaki fark, \ daha büyük ya da eşit olmalıdır {2}"
-Row {0}:Start Date must be before End Date,Satır {0}: Başlangıç ​​Tarihi Bitiş Tarihinden önce olmalıdır
-Rules for adding shipping costs.,Nakliye maliyetleri eklemek için Kurallar.
+"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}","Satır {0}: Depo{1} - {2} {3} de miktar bulunmamaktadır. Mevcut Miktar: {4}, Transfer Miktarı: {5}"
+"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}","Satır {0}: Dönemsellik  {1} ayarlamak için, başlangıç ve bitiş tarihi arasındaki fark {2} den büyük veya buna eşit olmalıdır"
+Row {0}:Start Date must be before End Date,Satır {0}: Başlangıç tarihi bitiş tarihinden önce olmalıdır
+Rules for adding shipping costs.,Nakliye maliyetleri ekleme  Kuralları.
 Rules for applying pricing and discount.,Fiyatlandırma ve indirim uygulanması için kurallar.
-Rules to calculate shipping amount for a sale,Bir satış için nakliye miktarını hesaplamak için Kurallar
+Rules to calculate shipping amount for a sale,Bir Satış için nakliye miktarı hesaplama için kuralları
 S.O. No.,SO No
-SHE Cess on Excise,SHE Tüketim Vergisi ile ilgili
-SHE Cess on Service Tax,SHE Hizmet Vergisi Cess
+SHE Cess on Excise,SHE Tüketim vergisi
+SHE Cess on Service Tax,SHE Hizmet Vergisi
 SHE Cess on TDS,SHE TDS ile ilgili Cess
 SMS Center,SMS Merkezi
 SMS Gateway URL,SMS Gateway URL
-SMS Log,SMS log
+SMS Log,SMS Log
 SMS Parameter,SMS Parametre
-SMS Sender Name,SMS Sender Adı
+SMS Sender Name,SMS Gönderici Adı
 SMS Settings,SMS Ayarları
-SO Date,SO Tarihi
-SO Pending Qty,SO Miktar Beklemede
+SO Date,SO Tarih
+SO Pending Qty,SO Bekleyen Miktar
 SO Qty,SO Adet
 Salary,Maaş
-Salary Information,Maaş Bilgi
-Salary Manager,Maaş Müdürü
+Salary Information,Maaş Bilgisi
+Salary Manager,Maaş Yöneticisi
 Salary Mode,Maaş Modu
-Salary Slip,Maaş fişi
-Salary Slip Deduction,Maaş fişi kesintisi
-Salary Slip Earning,Maaş fişi kazancı
-Salary Slip of employee {0} already created for this month,Çalışanın Maaş Kayma {0} zaten bu ay için oluşturulan
+Salary Slip,Maaş Makbuzu
+Salary Slip Deduction,Maaş Makbuzu Kesintisi
+Salary Slip Earning,Maaş Makbuz Kazancı
+Salary Slip of employee {0} already created for this month,Çalışan {0} için Maaş makbuzu bu ay için zaten oluşturuldu
 Salary Structure,Maaş Yapısı
 Salary Structure Deduction,Maaş Yapısı Kesintisi
-Salary Structure Earning,Maaş Yapısı Kazanç
-Salary Structure Earnings,Maaş Yapısı Kazanç
-Salary breakup based on Earning and Deduction.,Maaş çöküş Kazanç ve Kesintisi göre.
+Salary Structure Earning,Maaş Yapısı Kazancı
+Salary Structure Earnings,Maaş Yapısı Kazancı
+Salary breakup based on Earning and Deduction.,Kazanç ve Kesintiye göre Maaş Aralığı.
 Salary components.,Maaş bileşenleri.
-Salary template master.,Maaş şablon usta.
-Sales,Satış
-Sales Analytics,Satış Analizi
-Sales BOM,Satış Malzeme Listesi (ML)
-Sales BOM Help,Satış Malzeme Listesi (ML) Yardım
-Sales BOM Item,Satış Malzeme Listesi (ML) Ürün
-Sales BOM Items,Satış Malzeme Listesi (ML) Ürünler
-Sales Browser,Satış Arama
-Sales Details,Satış Bilgileri
+Salary template master.,Maaş Şablon Alanı.
+Sales,Satışlar
+Sales Analytics,Satış Analizleri
+Sales BOM,Satış BOM
+Sales BOM Help,Satış BOM Yardım
+Sales BOM Item,Satış BOM Ürünü
+Sales BOM Items,Satış BOM Ürünleri
+Sales Browser,Satış Tarayıcı
+Sales Details,Satış Ayrıntılar
 Sales Discounts,Satış İndirimleri
 Sales Email Settings,Satış E-posta Ayarları
 Sales Expenses,Satış Giderleri
 Sales Extras,Satış Ekstralar
-Sales Funnel,Satış Huni
+Sales Funnel,Satış Yolu
 Sales Invoice,Satış Faturası
-Sales Invoice Advance,Satış Fatura Peşin
-Sales Invoice Item,Satış Fatura Ürünleri
-Sales Invoice Items,Satış Fatura Öğeler
-Sales Invoice Message,Satış Faturası Mesaj
-Sales Invoice No,Satış Faturası No
+Sales Invoice Advance,Satış Fatura Avansı
+Sales Invoice Item,Satış Faturası Ürünü
+Sales Invoice Items,Satış Faturası Ürünleri
+Sales Invoice Message,Satış Faturası Mesajı
+Sales Invoice No,Satış Fatura No
 Sales Invoice Trends,Satış Faturası Trendler
 Sales Invoice {0} has already been submitted,Satış Faturası {0} zaten gönderildi
-Sales Invoice {0} must be cancelled before cancelling this Sales Order,Satış Faturası {0} bu Satış Siparişi iptal etmeden önce iptal edilmelidir
+Sales Invoice {0} must be cancelled before cancelling this Sales Order,Satış Faturası {0} bu Satış Siparişi iptal edilmeden önce iptal edilmelidir
 Sales Order,Satış Siparişi
 Sales Order Date,Satış Sipariş Tarihi
-Sales Order Item,Satış Sipariş Ürün
+Sales Order Item,Satış Sipariş Ürünü
 Sales Order Items,Satış Sipariş Ürünleri
-Sales Order Message,Satış Sipariş Mesaj
+Sales Order Message,Satış Sipariş Mesajı
 Sales Order No,Satış Sipariş No
-Sales Order Required,Satış Siparişi Gerekli
+Sales Order Required,Satış Sipariş Gerekli
 Sales Order Trends,Satış Sipariş Trendler
-Sales Order required for Item {0},Ürün için gerekli Satış Sipariş {0}
-Sales Order {0} is not submitted,Satış Sipariş {0} teslim edilmez
-Sales Order {0} is not valid,Satış Sipariş {0} geçerli değil
-Sales Order {0} is stopped,Satış Sipariş {0} durduruldu
+Sales Order required for Item {0},Ürün {0}için Satış Sipariş  gerekli 
+Sales Order {0} is not submitted,Satış Sipariş {0} teslim edilmedi
+Sales Order {0} is not valid,Satış Sipariş {0} geçerli değildir
+Sales Order {0} is stopped,Satış Siparişi {0} durduruldu
 Sales Partner,Satış Ortağı
 Sales Partner Name,Satış Ortağı Adı
-Sales Partner Target,Satış Ortağı Hedef
+Sales Partner Target,Satış Ortağı Hedefi
 Sales Partners Commission,Satış Ortakları Komisyonu
-Sales Person,Satış Elemanı
-Sales Person Name,Satış Kişi Adı
-Sales Person Target Variance Item Group-Wise,Satış Kişi Hedef Varyans Ürün Grup-Wise
-Sales Person Targets,Satış Kişisi Hedefler
-Sales Person-wise Transaction Summary,Satış Kişi-bilge İşlem Özeti
+Sales Person,Satış Personeli
+Sales Person Name,Satış Personeli Adı
+Sales Person Target Variance Item Group-Wise,Satış Personeli Hedef Varyans Ürün Grup Bilgisi
+Sales Person Targets,Satış Personeli Hedefleri
+Sales Person-wise Transaction Summary,Satış Personeli bilgisi İşlem Özeti
 Sales Register,Satış Kayıt
-Sales Return,Satış Dönüşleri
+Sales Return,Satış İade
 Sales Returned,Satış İade
-Sales Taxes and Charges,Satış Vergisi ve Harçlar
-Sales Taxes and Charges Master,Ana Satış Vergisi ve Harçlar
+Sales Taxes and Charges,Satış Vergi ve Harçlar
+Sales Taxes and Charges Master,Satış Vergi ve Harçlar Alanı
 Sales Team,Satış Ekibi
 Sales Team Details,Satış Ekibi Ayrıntıları
 Sales Team1,Satış Ekibi1
 Sales and Purchase,Satış ve Satın Alma
-Sales campaigns.,Satış kampanyaları.
+Sales campaigns.,SSatış kampanyaları.
 Salutation,Selamlama
-Sample Size,Örneklem Büyüklüğü
-Sanctioned Amount,Yaptırım Tutar
+Sample Size,Numune Boyu
+Sanctioned Amount,tasdik edilmiş tutar
 Saturday,Cumartesi
-Schedule,Planlama
-Schedule Date,Program Tarih
+Schedule,Program
+Schedule Date,Program Tarihi
 Schedule Details,Program Detayları
-Scheduled,Planlandı
-Scheduled Date,Planlanan Tarih
-Scheduled to send to {0},Göndermek için Tarifeli {0}
-Scheduled to send to {0} recipients,{0} alıcıya göndermek için Tarifeli
-Scheduler Failed Events,Zamanlayıcı Başarısız Olaylar
-School/University,Okul / Üniversite
+Scheduled,Tarifeli
+Scheduled Date,Program Tarihi
+Scheduled to send to {0},Göndermek için Programlanmış {0}
+Scheduled to send to {0} recipients,{0} Alıcılara göndermek için proramlanmış
+Scheduler Failed Events,Programlanmış Başarısız Olaylar
+School/University,kul / Üniversite
 Score (0-5),Skor (0-5)
-Score Earned,Puan Kazanılmış
-Score must be less than or equal to 5,Skor ya da daha az 5 eşit olmalıdır
-Scrap %,% Hurda
-Seasonality for setting budgets.,Bütçeleri ayarlamak için Mevsimsellik.
+Score Earned,Kazanılan Puan
+Score must be less than or equal to 5,Skor 5'ten az veya eşit olmalıdır
+Scrap %,Hurda%
+Seasonality for setting budgets.,Bütçe ayarlamalarının dönemselliği
 Secretary,Sekreter
 Secured Loans,Teminatlı Krediler
-Securities & Commodity Exchanges,Menkul Kıymetler ve Borsalar
-Securities and Deposits,Menkul Kıymetler ve Mevduat
-"See ""Rate Of Materials Based On"" in Costing Section","Bölüm Maliyet ""On esaslı malzemelerin Rate"" bakın"
-"Select ""Yes"" for sub - contracting items","Alt için ""Evet"" seçeneğini seçin - öğeleri sözleşme"
-"Select ""Yes"" if this item is used for some internal purpose in your company.","Bu öğeyi şirket bazı iç amaç için kullanılan ""Evet"" seçeneğini seçin."
-"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Bu madde vb danışmanlık eğitim, tasarım, gibi bazı işler temsil ediyorsa ""Evet"" i seçin"
-"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Eğer Envanter Bu ürünün stok muhafaza eğer ""Evet"" seçeneğini seçin."
-"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.","Bu öğeyi üretmek için tedarikçi için hammadde kaynağı ise ""Evet"" seçeneğini seçin."
-Select Brand...,Marka Seçiniz ...
-Select Budget Distribution to unevenly distribute targets across months.,Düzensiz ay boyunca hedefleri dağıtmak için Bütçe Dağılımı seçin.
-"Select Budget Distribution, if you want to track based on seasonality.","Mevsimsellik dayalı izlemek istiyorsanız, Bütçe Dağıtım seçin."
-Select Company...,Firma Seç ...
-Select DocType,DocType seçin
+Securities & Commodity Exchanges,Teminatlar ve Emtia Borsaları
+Securities and Deposits,Teminatlar ve Mevduatlar
+"See ""Rate Of Materials Based On"" in Costing Section","Maliyetlendirme Bölümünde ""Dayalı Ürünler Br.Fiyatına"" bakınız"
+"Select ""Yes"" for sub - contracting items","Alt sözleşme Ürünleri için ""Evet"" seçiniz"
+"Select ""Yes"" if this item is used for some internal purpose in your company.","Bu Ürün şirketinizde bir dahili amaç için kullanılıyorsa ""Evet"" işaretleyiniz"
+"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Bu Ürün eğitimde, tasarımda, danışmada vb bazı işleri temsil ediyorsa ""Evet"" işaretleyiniz"
+"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Envanterinizde bu Ürünün stokunu tutuyorsanız ""Eveti"" işaretleyiniz"
+"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.","Bu Ürünü üretmek için tedarikçinize ham madde sağlıyorsanız ""Evet"" işaretleyiniz"
+Select Brand...,Marka seçiniz ...
+Select Budget Distribution to unevenly distribute targets across months.,Hedefleri aylara eşit olmayan miktarda dağıtmak için Bütçe Dağıtımını seçiniz
+"Select Budget Distribution, if you want to track based on seasonality.",Dönemselliğe dayalı takip için Bütçe Dağıtımını seçin
+Select Company...,Firma Seçin ...
+Select DocType,Belge Tipi seçine
 Select Fiscal Year...,Mali Yıl Seçin ...
-Select Items,Öğeleri seçmek
-Select Project...,Projesi Seçiniz ...
-Select Purchase Receipts,Satınalma Makbuzlar Seçiniz
-Select Sales Orders,Satış Siparişleri seçin
-Select Sales Orders from which you want to create Production Orders.,Üretim Emirleri oluşturmak istediğiniz Satış Siparişleri seçin.
-Select Time Logs and Submit to create a new Sales Invoice.,Zaman Kayıtlar seçin ve yeni Satış Faturası oluşturmak için gönderin.
+Select Items,Ürünleri Seçin
+Select Project...,Proje seçiniz ...
+Select Purchase Receipts,Satın alma Makbuzları seçiniz
+Select Sales Orders,Satış Siparişleri Seçiniz
+Select Sales Orders from which you want to create Production Orders.,Üretim Emri oluşturmak istediğiniz Satış Siparişlerini seçiniz.
+Select Time Logs and Submit to create a new Sales Invoice.,Günlükleri seçin ve yeni Satış Faturası oluşturmak için teslim edin.
 Select Transaction,İşlem Seçin
-Select Warehouse...,Warehouse Seçiniz ...
+Select Warehouse...,Depo seçiniz ...
 Select Your Language,Dil Seçiniz
-Select account head of the bank where cheque was deposited.,Select account head of the bank where cheque was deposited.
-Select company name first.,Şirket adını seçin.
-Select template from which you want to get the Goals,Select template from which you want to get the Goals
-Select the Employee for whom you are creating the Appraisal.,Select the Employee for whom you are creating the Appraisal.
-Select the period when the invoice will be generated automatically,Select the period when the invoice will be generated automatically
-Select the relevant company name if you have multiple companies,Select the relevant company name if you have multiple companies
-Select the relevant company name if you have multiple companies.,Select the relevant company name if you have multiple companies.
-Select who you want to send this newsletter to,Select who you want to send this newsletter to
-Select your home country and check the timezone and currency.,Ev ülkeyi seçin ve saat dilimini ve para birimini kontrol edin.
-"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","""Evet"" seçildiğinde bu öğe Sipariş, Satın Alma Makbuzu görünmesini sağlayacaktır."
-"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","""Evet"" seçildiğinde bu öğe Satış Sipariş, İrsaliye rakam sağlayacak"
-"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.","""Evet"" seçilmesi hammadde ve bu öğeyi üretimi için katlanılan operasyonel maliyetleri gösteren Malzeme Bill oluşturmanızı sağlayacak."
-"Selecting ""Yes"" will allow you to make a Production Order for this item.","""Evet"" seçildiğinde bu öğe için bir üretim Sipariş olanak sağlayacak."
-"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","""Evet"" seçilmesi Seri No master görülebilir Bu ürünün her varlık için benzersiz bir kimlik verecek."
+Select account head of the bank where cheque was deposited.,Çekin yatırıldığı bankadaki hesap başlığını seçiniz
+Select company name first.,önce şirket adı seçiniz
+Select template from which you want to get the Goals,Hedefleri almak istediğiniz şablonu seçiniz
+Select the Employee for whom you are creating the Appraisal.,Değerlendirme oluşturduğunuz Çalışanı seçin
+Select the period when the invoice will be generated automatically,Otomatik olarak fatura oluşturulacak dönemi seçin
+Select the relevant company name if you have multiple companies,Birden fazla şirketiniz varsa ilgili şirketi seçiniz
+Select the relevant company name if you have multiple companies.,Birden fazla şirketiniz varsa ilgili şirketi seçiniz.
+Select who you want to send this newsletter to,EBu bülteni göndermek istediğiniz kişiyi seçiniz
+Select your home country and check the timezone and currency.,Ülkenizi seçin ve saat dilimini ve para birimini işaretleyin
+"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","""Evet"" işaretlemek Ürünlerin Satın Alma Emrinde görünmesini sağlar"
+"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","""Evet"" işaretlemek Ürünlerin Satış Emrinde, İrsaliyede görünmesini sağlar"
+"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.","""Evet"" işaretlemek bu  üretiminde tahakkuk eden ham madde ve işletim maliyetlerini gösteren Malzeme Faturasını oluşturmanızı sağlayacaktır."
+"Selecting ""Yes"" will allow you to make a Production Order for this item.","""Evet"" işaretlemek bu Ürün için Üretim Emri oluşturmanızı sağlar"
+"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","""Evet"" işaretlemek Seri no alanında görüntülenebilecek Ürünnin her elemanını tanımlayacak ayrı kimlik verecektir"
 Selling,Satış
-Selling Settings,Ayarları Satış
-"Selling must be checked, if Applicable For is selected as {0}","Uygulanabilir için olarak seçilirse satış, kontrol edilmelidir {0}"
+Selling Settings,Satış Ayarları 
+"Selling must be checked, if Applicable For is selected as {0}",Uygulanabilir {0} olarak seçildiyse satış işaretlenmelidir
 Send,Gönder
-Send Autoreply,Otomatik yanıt gönder
+Send Autoreply,Otomatik Cevap Gönder
 Send Email,E-posta Gönder
-Send From,Gönderen
-Send Notifications To,To Bildirimleri Gönder
+Send From,den Gönder
+Send Notifications To,Bildirimleri Gönder
 Send Now,Şimdi Gönder
-Send SMS,SMS gönder
-Send To,Kime
-Send To Type,Yazın Gönder
-Send mass SMS to your contacts,Kişilerinize toplu SMS gönder
-Send to this list,Bu listeye gönderin
+Send SMS,SMS Gönder
+Send To,Gönder
+Send To Type,Türe Gönder
+Send mass SMS to your contacts,Kişilerinize toplu SMS Gönder
+Send to this list,Bu listeye Gönder
 Sender Name,Gönderenin Adı
-Sent On,bu tarihte gönder
-Separate production order will be created for each finished good item.,Ayrı üretim siparişi her mamul madde için oluşturulur.
+Sent On,On Sent
+Separate production order will be created for each finished good item.,Her mamül madde için ayrı üretim emri oluşturulacaktır.
 Serial No,Seri No
-Serial No / Batch,Seri No / Toplu
+Serial No / Batch,Seri No / Parti
 Serial No Details,Seri No Detayları
-Serial No Service Contract Expiry,Seri No Hizmet Sözleşmesi Bitişi
+Serial No Service Contract Expiry,Seri No Hizmet Sözleşmesi Vadesi
 Serial No Status,Seri No Durumu
-Serial No Warranty Expiry,Seri No Garanti Bitişi
-Serial No is mandatory for Item {0},Seri No Ürün için zorunludur {0}
+Serial No Warranty Expiry,Seri No Garanti Bitiş tarihi
+Serial No is mandatory for Item {0},Ürün {0} için Seri no zorunludur
 Serial No {0} created,Seri No {0} oluşturuldu
-Serial No {0} does not belong to Delivery Note {1},Seri No {0} İrsaliye ait değil {1}
-Serial No {0} does not belong to Item {1},Seri No {0} Ürün ait değil {1}
-Serial No {0} does not belong to Warehouse {1},Seri No {0} Atölyesi'ne ait değil {1}
+Serial No {0} does not belong to Delivery Note {1},Seri No {0} İrsaliye  {1} e ait değil
+Serial No {0} does not belong to Item {1},Seri No {0} Ürün {1} e ait değil
+Serial No {0} does not belong to Warehouse {1},Seri No {0} Depo  {1} e ait değil
 Serial No {0} does not exist,Seri No {0} yok
-Serial No {0} has already been received,Seri No {0} alındıktan
-Serial No {0} is under maintenance contract upto {1},Seri No {0} taneye kadar bakım sözleşmesi altında {1}
-Serial No {0} is under warranty upto {1},Seri No {0} kadar garanti altındadır {1}
-Serial No {0} not in stock,Seri No {0} değil stock
-Serial No {0} quantity {1} cannot be a fraction,Seri No {0} {1} miktar kesir olamaz
-Serial No {0} status must be 'Available' to Deliver,Seri No {0} durum sunun için 'Uygun' olmalı
-Serial Nos Required for Serialized Item {0},Tefrika Ürün Serial Nos Zorunlu {0}
+Serial No {0} has already been received,Seri No {0} zaten alınmış
+Serial No {0} is under maintenance contract upto {1},Seri No {0} Bakım sözleşmesi {1} uyarınca bakımda
+Serial No {0} is under warranty upto {1},Seri No {0} {1} uyarınca garantide
+Serial No {0} not in stock,Seri No {0} stokta değil
+Serial No {0} quantity {1} cannot be a fraction,Seri No {0} miktar {1} kesir olamaz
+Serial No {0} status must be 'Available' to Deliver,Seri No {0} durumu 'erişilebilir' olmalıdır
+Serial Nos Required for Serialized Item {0},Seri Ürün{0} için Seri numaraları gereklidir
 Serial Number Series,Seri Numarası Serisi
-Serial number {0} entered more than once,Seri numarası {0} kez daha girdi
-Serialized Item {0} cannot be updated \					using Stock Reconciliation,Tefrika Öğe {0} güncelleme olamaz \ Stock Uzlaşma kullanarak
+Serial number {0} entered more than once,Seri numarası {0} birden çok girilmiş
+Serialized Item {0} cannot be updated \					using Stock Reconciliation,Seri Ürün {0} Stok Mutabakatı kullanılarak güncellenemez
 Series,Seriler
 Series List for this Transaction,Bu İşlem için Seri Listesi
-Series Updated,Serisi Güncel
-Series Updated Successfully,Serisi Başarıyla Güncellendi
-Series is mandatory,Series zorunludur
-Series {0} already used in {1},Series {0} kullanılan {1}
+Series Updated,Serisi Güncellendi
+Series Updated Successfully,Seri Başarıyla güncellendi
+Series is mandatory,Seri zorunludur
+Series {0} already used in {1},Seriler {0} {1} de zaten kullanılmıştır
 Service,Servis
 Service Address,Servis Adresi
 Service Tax,Hizmet Vergisi
 Services,Servisler
 Set,Ayarla
-"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Vb Şirket, Para, mevcut mali yılın gibi ayarla Varsayılan Değerler"
-Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Bu topraklardan Ürün Grubu-bilge bütçeler belirleyin. Ayrıca Dağıtım ayarlayarak mevsimsellik içerebilir.
-Set Status as Available,Olarak mevcut ayarla Durum
+"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Şirket, Para Birimi, Mali yıl vb gibi standart değerleri ayarlayın"
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Bu bölgede Ürün grubu bütçeleri ayarlayın. Dağıtımı ayarlayarak dönemsellik de ekleyebilirsiniz.
+Set Status as Available,Durumu Mevcut olarak ayarlayın
 Set as Default,Varsayılan olarak ayarla
 Set as Lost,Kayıp olarak ayarla
-Set prefix for numbering series on your transactions,Set prefix for numbering series on your transactions
-Set targets Item Group-wise for this Sales Person.,Set targets Item Group-wise for this Sales Person.
-Setting Account Type helps in selecting this Account in transactions.,Setting Account Type helps in selecting this Account in transactions.
-Setting this Address Template as default as there is no other default,Başka hiçbir varsayılan olduğu gibi varsayılan olarak bu Adres Template ayarlanması
+Set prefix for numbering series on your transactions,İşlemlerinizde seri numaralandırma için ön ek ayarlayın
+Set targets Item Group-wise for this Sales Person.,Bu Satış Kişisi için Ürün Grubu hedefleri ayarlayın
+Setting Account Type helps in selecting this Account in transactions.,Hesap Türünü ayarlamak işlemlerde bu hesabı seçeren yardımcı olur
+Setting this Address Template as default as there is no other default,"Bu adres şablonunu varsayılan olarak kaydedin, başka varsayılan bulunmamaktadır"
 Setting up...,Kurma ...
 Settings,Ayarlar
 Settings for HR Module,İK Modülü Ayarları
-"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""","Bir posta kutusu örneğin ""jobs@example.com"" dan İş Başvuru ayıklamak için Ayarlar"
+"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""","""jobs@example.com"" gibi bir mail adresinden İş Başvurularını çekme ayarları"
 Setup,Kurulum
-Setup Already Complete!!,Kur Zaten Tamamlandı!
+Setup Already Complete!!,Kurulum Tamamlandı!
 Setup Complete,Kurulum Tamamlandı
 Setup SMS gateway settings,Kurulum SMS ağ geçidi ayarları
 Setup Series,Kurulum Serisi
 Setup Wizard,Kurulum Sihirbazı
-Setup incoming server for jobs email id. (e.g. jobs@example.com),"Işler e-posta id için kurulum gelen sunucu. (Örneğin, jobs@example.com)"
-Setup incoming server for sales email id. (e.g. sales@example.com),"Satış e-posta id için kurulum gelen sunucu. (Örneğin, sales@example.com)"
-Setup incoming server for support email id. (e.g. support@example.com),"Destek e-posta id için kurulum gelen sunucu. (Örneğin, support@example.com)"
-Share,paylaş
+Setup incoming server for jobs email id. (e.g. jobs@example.com),İş e-mail kimliği için gelen sunucu kurulumu (örneğin: jobs@example.com)
+Setup incoming server for sales email id. (e.g. sales@example.com),İş e-mail kimliği için gelen sunucu kurulumu (örneğin: sales@example.com)
+Setup incoming server for support email id. (e.g. support@example.com),Destek e-mail kimliği için gelen sunucu kurulumu (örneğin:support@example.com)
+Share,Paylaş
 Share With,Ile paylaş
-Shareholders Funds,Hissedarlar Fonlar
+Shareholders Funds,Hissedar Fonları
 Shipments to customers.,Müşterilere yapılan sevkiyatlar.
 Shipping,Nakliye
 Shipping Account,Nakliye Hesap
-Shipping Address,Gönderim Adresi
+Shipping Address,Teslimat Adresi
 Shipping Amount,Kargo Tutarı
-Shipping Rule,Kargo Kural
-Shipping Rule Condition,Kargo Kural Durum
-Shipping Rule Conditions,Kargo Kural Koşullar
-Shipping Rule Label,Kargo Kural Etiket
+Shipping Rule,Kargo Kuralı
+Shipping Rule Condition,Kargo Kural Şartları
+Shipping Rule Conditions,Kargo Kural Koşulları
+Shipping Rule Label,Kargo Kural Etiketi
 Shop,Mağaza
 Shopping Cart,Alışveriş Sepeti
 Short biography for website and other publications.,Web sitesi ve diğer yayınlar için kısa biyografi.
-"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","""Stok"" göstermek veya ""Not Stock"" bu depoda mevcut stok göre."
-"Show / Hide features like Serial Nos, POS etc.","Vb Seri Nos, POS gibi göster / gizle özellikleri"
-Show In Website,Web Sitesi göster
-Show a slideshow at the top of the page,Sayfanın üst kısmında bir slayt göster
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Depodaki mevcut stok durumuna göre ""Stokta"" veya ""Stokta değil"" olarak göster"
+"Show / Hide features like Serial Nos, POS etc.","Seri No, POS vb gibi özellikleri göster/sakla"
+Show In Website,Web sitesinde Göster
+Show a slideshow at the top of the page,Sayfanın üstünde bir slayt gösterisi göster
 Show in Website,Web sitesi Göster
-Show rows with zero values,Sıfır değerleri olan satırları göster
-Show this slideshow at the top of the page,Sayfanın üst kısmında bu slaytı göster
+Show rows with zero values,Değeri sıfır olan satırları göster
+Show this slideshow at the top of the page,Sayfanın üstünde bu slayt gösterisini göster
 Sick Leave,Hastalık izni
-Signature,Imza
-Signature to be appended at the end of every email,Her e-postanın sonuna eklenecek İmza
+Signature,İmza
+Signature to be appended at the end of every email,Her e-postanın sonuna eklenecek imza
 Single,Tek
-Single unit of an Item.,Bir ürünün Tek birimi.
-Sit tight while your system is being setup. This may take a few moments.,Sistem kurulum edilirken otur. Bu işlem birkaç dakika sürebilir.
-Slideshow,Slayt göstersi
+Single unit of an Item.,Bir Ürünün tek birimi
+Sit tight while your system is being setup. This may take a few moments.,Sistem kurulurken birkaç dakika bekleyiniz
+Slideshow,Slayt Gösterisi
 Soap & Detergent,Sabun ve Deterjan
 Software,Yazılım
 Software Developer,Yazılım Geliştirici
-"Sorry, Serial Nos cannot be merged","Üzgünüz, Seri Nos birleştirilmiş olamaz"
-"Sorry, companies cannot be merged","Üzgünüz, şirketler birleşti edilemez"
+"Sorry, Serial Nos cannot be merged","Üzgünüz, seri numaraları birleştirilemiyor"
+"Sorry, companies cannot be merged","Üzgünüz, şirketler birleştirilemiyor"
 Source,Kaynak
 Source File,Kaynak Dosyası
 Source Warehouse,Kaynak Depo
-Source and target warehouse cannot be same for row {0},Kaynak ve hedef depo satır için aynı olamaz {0}
-Source of Funds (Liabilities),Fon kaynağı (Yükümlülükleri)
-Source warehouse is mandatory for row {0},Kaynak depo satır için zorunludur {0}
+Source and target warehouse cannot be same for row {0},Kaynak ve hedef depo Satır {0} için aynu olamaz
+Source of Funds (Liabilities),Fon kaynakları (Yükümlülükler)
+Source warehouse is mandatory for row {0},Satır {0} Kaynak depo zorunludur
 Spartan,Spartalı
-"Special Characters except ""-"" and ""/"" not allowed in naming series","Dışında özel karakterler ""-"" ve ""/"" serisi adlandırma izin yok"
-Specification Details,Teknik Detaylar
+"Special Characters except ""-"" and ""/"" not allowed in naming series","Seri isimlendirmede ""-"" ve ""/"" hariç özel karakterlere izin verilmez"
+Specification Details,Şartname Detayları
 Specifications,Özellikler
-"Specify a list of Territories, for which, this Price List is valid","Toprakları bir listesini belirtin, bunun için, bu Fiyat Listesi geçerlidir"
-"Specify a list of Territories, for which, this Shipping Rule is valid","Toprakları bir listesini belirtin, bunun için, bu Kargo Kural geçerlidir"
-"Specify a list of Territories, for which, this Taxes Master is valid","Toprakları bir listesini belirtin, bunun için, bu Usta geçerlidir Vergiler"
-"Specify the operations, operating cost and give a unique Operation no to your operations.","Işlemleri, işletme maliyeti belirtin ve operasyon için benzersiz bir operasyon hayır verir."
-Split Delivery Note into packages.,Paketler halinde İrsaliye Böl.
+"Specify a list of Territories, for which, this Price List is valid","Bu fiyat listesinin, geçerli olduğu Bölgeler listesini belirtin"
+"Specify a list of Territories, for which, this Shipping Rule is valid","Bu sevkiyat kuralının, geçerli olduğu Bölgeler listesini belirtin"
+"Specify a list of Territories, for which, this Taxes Master is valid","Bu vergi alanının, geçerli olduğu Bölgeler listesini belirtin"
+"Specify the operations, operating cost and give a unique Operation no to your operations.","İşlemleri, işlem maliyetlerini belirtiniz ve işlemlerinize kendilerine özgü işlem numaraları veriniz."
+Split Delivery Note into packages.,İrsaliyeyi ambalajlara böl.
 Sports,Spor
 Sr,Sr
 Standard,Standart
@@ -2733,599 +2733,599 @@
 Standard contract terms for Sales or Purchase.,Satış veya Satın Alma için standart sözleşme şartları.
 Start,Başlangıç
 Start Date,Başlangıç Tarihi
-Start date of current invoice's period,Start date of current invoice's period
-Start date should be less than end date for Item {0},Başlangıç ​​tarihi Ürün için bitiş tarihinden daha az olmalıdır {0}
+Start date of current invoice's period,Cari fatura döneminin Başlangıç tarihi
+Start date should be less than end date for Item {0},Başlangıç tarihi Ürün {0} için bitiş tarihinden daha az olmalıdır 
 State,Devlet
-Statement of Account,Hesap Tablosu
-Static Parameters,Statik Parametreler
+Statement of Account,Hesap Beyanı
+Static Parameters,Statik Parametreleri
 Status,Durum
-Status must be one of {0},Durum biri olmalıdır {0}
-Status of {0} {1} is now {2},{0} {1} şimdi durumu {2}
-Status updated to {0},Durum güncellendi {0}
-Statutory info and other general information about your Supplier,Yasal bilgi ve alanı ile ilgili diğer genel bilgiler
+Status must be one of {0},Durum şunlardan biri olmalıdır {0}
+Status of {0} {1} is now {2},Durum {0} {1} Şimdi {2} dir.
+Status updated to {0},Durum {0} olarak güncellendi
+Statutory info and other general information about your Supplier,Tedarikçiniz hakkında yasal bilgiler ve diğer genel bilgiler
 Stay Updated,Güncel Kalın
 Stock,Stok
 Stock Adjustment,Stok Ayarı
 Stock Adjustment Account,Stok Düzeltme Hesabı
-Stock Ageing,Stok Yaşlanma
-Stock Analytics,Stok Analytics
+Stock Ageing,Stok Yaşlanması
+Stock Analytics,Stok Analizi
 Stock Assets,Hazır Varlıklar
 Stock Balance,Stok Bakiye
-Stock Entries already created for Production Order ,Stock Entries already created for Production Order 
-Stock Entry,Stok Girişi
-Stock Entry Detail,Stok Giriş Detayı
+Stock Entries already created for Production Order ,Üretim Emri için Stok Girdileri zaten oluşturulmuş
+Stock Entry,Stok Girdisi
+Stock Entry Detail,Stok Girdisi Detayı
 Stock Expenses,Stok Giderleri
-Stock Frozen Upto,Stok Upto Frozen
-Stock Ledger,Stock Ledger
-Stock Ledger Entry,Stock Ledger Entry
-Stock Ledger entries balances updated,Stok Ledger güncellendi dengelerini girişleri
+Stock Frozen Upto,Stok Dondurulmuş
+Stock Ledger,Stok defteri
+Stock Ledger Entry,Stok Defter Girdisi
+Stock Ledger entries balances updated,Stok Defteri girdi bakiyeleri güncellendi
 Stock Level,Stok Düzeyi
-Stock Liabilities,Stok Yükümlülükler
-Stock Projected Qty,Stok Adet Öngörülen
-Stock Queue (FIFO),Stok Queue (FIFO)
-Stock Received But Not Billed,Stok Alınan Ama Faturalı değil
+Stock Liabilities,Stok Yükümlülükleri
+Stock Projected Qty,Öngörülen Stok Miktarı
+Stock Queue (FIFO),Stok Kuyruğu (FIFO)
+Stock Received But Not Billed,Alınmış ancak faturalanmamış stok
 Stock Reconcilation Data,Stok mutabakatı Verileri
-Stock Reconcilation Template,Stok mutabakatı Şablon
+Stock Reconcilation Template,Stok Mutabakato Şablonu
 Stock Reconciliation,Stok Uzlaşma
-"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stok Uzlaşma genellikle fiziksel envanter başına, belirli bir tarihte stok güncellemek için kullanılabilir."
+"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.",Stok Uzlaşma genellikle fiziksel envanter olarak stokları belirli bir tarihte güncellemek için kullanılabilir.
 Stock Settings,Stok Ayarları
-Stock UOM,Stok Ürün Birimi (ÜB)
-Stock UOM Replace Utility,Stok Ürün Birimi (ÜB) Replace Utility
-Stock UOM updatd for Item {0},Ürün için stok UoM updatd {0}
+Stock UOM,Stok Uom
+Stock UOM Replace Utility,Stok UOM Değiştirme
+Stock UOM updatd for Item {0},Stok UOM Ürün {0} için güncellendi
 Stock Uom,Stok uom
 Stock Value,Stok Değeri
 Stock Value Difference,Stok Değer Farkı
 Stock balances updated,Stok bakiyeleri güncellendi
-Stock cannot be updated against Delivery Note {0},Stok İrsaliye karşı güncellenen olamaz {0}
-Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Stok girişleri {0} 'Usta Adı' yeniden atamak ya da değiştiremez ambarında mevcuttur
-Stock transactions before {0} are frozen,{0} önce hisse senedi işlemleri dondurulur
-Stop,Dur
-Stop Birthday Reminders,Dur Birthday Reminders
-Stop Material Request,Dur Malzeme Talebi
-Stop users from making Leave Applications on following days.,Şu günlerde bırak Uygulamaları yapmasını durdurmak.
-Stop!,Durun!
+Stock cannot be updated against Delivery Note {0},Stok İrsaliye {0} karşısı güncellenmez
+Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',"Stok girdileri depo {0} karşılığı bulunur, 'Alan adı' yeniden atanamaz veya değiştirilemez"
+Stock transactions before {0} are frozen,{0} dan önceki stok işlemleri dondurulmuştur
+Stop,Durdur
+Stop Birthday Reminders,Doğum günü hatırlatıcılarını durdur
+Stop Material Request,Malzeme Talebini Durdur
+Stop users from making Leave Applications on following days.,Kullanıcıların şu günlerde İzin almasını engelle.
+Stop!,Dur!
 Stopped,Durduruldu
-Stopped order cannot be cancelled. Unstop to cancel.,Durduruldu sipariş iptal edilemez. Iptal etmek için unstop.
+Stopped order cannot be cancelled. Unstop to cancel.,Durdurulan Sipariş iptal edilemez. İptali kaldırın
 Stores,Mağazalar
 Stub,Koçan
 Sub Assemblies,Alt Kurullar
-"Sub-currency. For e.g. ""Cent""","Alt birimi. Örneğin ""içinCent """
+"Sub-currency. For e.g. ""Cent""","Alt para birimi. Örneğin: ""Cent"""
 Subcontract,Alt sözleşme
 Subject,Konu
-Submit Salary Slip,Maaş Slibi Gönder
-Submit all salary slips for the above selected criteria,Yukarıda seçilen ölçütler için tüm maaş makbuzları Gönder
-Submit this Production Order for further processing.,Daha fazla işlem için bu Üretim Siparişi gönderin.
+Submit Salary Slip,Maaş Makbuzu Gönder
+Submit all salary slips for the above selected criteria,Yukarıda seçilen kriterler için maaş makbuzları gönder
+Submit this Production Order for further processing.,Daha fazla işlem için bu Üretim Siparişini Gönderin.
 Submitted,Gönderildi
 Subsidiary,Yardımcı
-Successful: ,Successful: 
-Successfully Reconciled,Başarıyla uzlaşmış
+Successful: ,Başarılı
+Successfully Reconciled,Başarıyla Uzlaştırıldı
 Suggestions,Öneriler
 Sunday,Pazar
 Supplier,Tedarikçi
-Supplier (Payable) Account,Tedarikçi (Ödenecek) Hesap
-Supplier (vendor) name as entered in supplier master,Supplier (vendor) name as entered in supplier master
+Supplier (Payable) Account,Tedarikçi (Borç) Hesabı
+Supplier (vendor) name as entered in supplier master,Tedarikççi alanında girildiği şekliyle Tedarikçi (satıcı) adı
 Supplier > Supplier Type,Tedarikçi> Tedarikçi Türü
-Supplier Account Head,Tedarikçi Hesap Başkanı
+Supplier Account Head,Tedarikçi Hesap Başlığı
 Supplier Address,Tedarikçi Adresi
 Supplier Addresses and Contacts,Tedarikçi Adresler ve İletişim
-Supplier Details,Tedarikçi Bilgileri
-Supplier Intro,Tedarikçi Intro
+Supplier Details,Tedarikçi Ayrıntıları
+Supplier Intro,Tedarikçi Girişi
 Supplier Invoice Date,Tedarikçi Fatura Tarihi
 Supplier Invoice No,Tedarikçi Fatura No
 Supplier Name,Tedarikçi Adı
-Supplier Naming By,Tedarikçi İsimlendirme tarafından
-Supplier Part Number,Tedarikçi Parça Numarası
-Supplier Quotation,Tedarikçi Teklif
-Supplier Quotation Item,Tedarikçi Teklif Ürün
-Supplier Reference,Tedarikçi referansı
+Supplier Naming By,Tedarikçi İsimlendirme 
+Supplier Part Number,Tedarikçi Parti Numarası
+Supplier Quotation,Tedarikçi Teklifi
+Supplier Quotation Item,Tedarikçi Teklif ürünü
+Supplier Reference,Tedarikçi Referansı
 Supplier Type,Tedarikçi Türü
 Supplier Type / Supplier,Tedarikçi Türü / Tedarikçi
-Supplier Type master.,Tedarikçi Türü usta.
+Supplier Type master.,Tedarikçi Türü Alanı.
 Supplier Warehouse,Tedarikçi Deposu
-Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Taşeronluk Satın Alma Makbuzu için zorunlu alanı Depo
-Supplier database.,Tedarikçi veritabanı.
-Supplier master.,Tedarikçi usta.
-Supplier warehouse where you have issued raw materials for sub - contracting,Supplier warehouse where you have issued raw materials for sub - contracting
-Supplier-Wise Sales Analytics,Tedarikçi-Wise Satış Analytics
+Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Alt Sözleşmeye bağlı Alım makbuzu için Tedarikçi deposu zorunludur
+Supplier database.,Tedarikçi Veritabanı.
+Supplier master.,Tedarikçi Alanı.
+Supplier warehouse where you have issued raw materials for sub - contracting,Alt sözleşme için ham maddelerin verildiği tedarikçi deposu
+Supplier-Wise Sales Analytics,Tedarikçi Satış Analizi
 Support,Destek
-Support Analtyics,Destek Analtyics
-Support Analytics,Destek Analytics
-Support Email,E-posta desteği
+Support Analtyics,Destek Analizi
+Support Analytics,Destek Analizi
+Support Email,Destek E-posta
 Support Email Settings,Destek E-posta Ayarları
-Support Password,Destek Şifre
-Support Ticket,Support Ticket
-Support queries from customers.,Müşterilerden gelen desteği sorgular.
+Support Password,Destek Şifre
+Support Ticket,Destek Bildirimi
+Support queries from customers.,Müşterilerden gelen destek sorguları.
 Symbol,Sembol
-Sync Support Mails,Sync Support Mails
+Sync Support Mails,Senkronize Destek Postaları
 Sync with Dropbox,Dropbox ile senkronize
 Sync with Google Drive,Google Drive ile senkronize
 System,Sistem
 System Settings,Sistem Ayarları
-"System User (login) ID. If set, it will become default for all HR forms.","Sistem kullanıcı (giriş) kimliği. Ayarlarsanız, tüm İK formları için varsayılan olacaktır."
+"System User (login) ID. If set, it will become default for all HR forms.","Sistem kullanıcı (giriş) kimliği, bütün İK formları için varsayılan olacaktır"
 TDS (Advertisement),TDS (Reklam)
-TDS (Commission),TDS (Komisyon)
+TDS (Commission),TDS (Komisyon))
 TDS (Contractor),TDS (Müteahhit)
 TDS (Interest),TDS (Faiz)
 TDS (Rent),TDS (Kiralık)
 TDS (Salary),TDS (Maaş)
 Target  Amount,Hedef Miktarı
-Target Detail,Hedef Ayrıntısı
+Target Detail,Hedef Detayı
 Target Details,Hedef Detayları
-Target Details1,Hedef Detayları1
-Target Distribution,Hedef Dağıtım
-Target On,Hedef On
-Target Qty,Hedef Miktar
-Target Warehouse,Hedef Deposu
-Target warehouse in row {0} must be same as Production Order,Arka arkaya Hedef depo {0} aynı olmalıdır Üretim Sipariş
-Target warehouse is mandatory for row {0},Hedef depo satır için zorunludur {0}
+Target Details1,Hedef detayları 1
+Target Distribution,Hedef Dağıtımı
+Target On,Hedefi
+Target Qty,Hedef Miktarı
+Target Warehouse,Hedef Depo
+Target warehouse in row {0} must be same as Production Order,Satır {0} daki hedef depo Üretim Emrindekiyle aynı olmalıdır
+Target warehouse is mandatory for row {0},Satır {0} için hedef depo zorunludur
 Task,Görev
 Task Details,Görev Detayları
 Tasks,Görevler
 Tax,Vergi
-Tax Amount After Discount Amount,İndirim Tutarı Vergi Sonrası Tutar
-Tax Assets,Vergi Varlığı
-Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Vergi Kategori 'değerleme' veya 'Değerleme ve Total' tüm öğeleri olmayan stok öğeler gibi olamaz
-Tax Rate,Vergi oranı
-Tax and other salary deductions.,Vergi ve diğer maaş kesintileri.
-Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges
-Tax template for buying transactions.,Işlemleri satın almak için vergi şablonu.
-Tax template for selling transactions.,Satımın için vergi şablonu.
-Taxable,Vergilendirilebilir
+Tax Amount After Discount Amount,İndirim Tutarından sonraki vergi miktarı
+Tax Assets,Vergi Varlıkları
+Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"'Değerleme', 'Değerlendirme ve Toplam stok maddeleri olduğundan ötürü Vergi kategorisi bunlardan biri olamaz."
+Tax Rate,Vergi Oranı
+Tax and other salary deductions.,Vergi ve diğer Maaş kesintileri.
+Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Vergi detay tablosu Ürün alanından uzantı olarak getirilir ve bu alanda saklanır. Vergi ve Ücretler için kullanılır.
+Tax template for buying transactions.,Alım işlemleri için vergi şablonu.
+Tax template for selling transactions.,Satış işlemleri için vergi şablonu.
+Taxable,Vergiye tabi
 Taxes,Vergiler
-Taxes and Charges,Vergiler ve Harçlar
-Taxes and Charges Added,Vergi ve Masraflar eklendi
-Taxes and Charges Added (Company Currency),Eklenen Vergi ve Harçlar (Company Para)
-Taxes and Charges Calculation,Vergiler ve Ücretler Hesaplama
-Taxes and Charges Deducted,Mahsup Vergiler ve Harçlar
-Taxes and Charges Deducted (Company Currency),Mahsup Vergi ve Harçlar (Company Para)
-Taxes and Charges Total,Vergi ve Masraflar Toplam
+Taxes and Charges,Vergi ve Harçlar
+Taxes and Charges Added,Eklenen Vergi ve Harçlar
+Taxes and Charges Added (Company Currency),Eklenen Vergi ve Harçlar (Şirket Para Birimi)
+Taxes and Charges Calculation,Vergiler ve Ücretleri Hesaplama
+Taxes and Charges Deducted,Mahsup Vergi ve Harçlar
+Taxes and Charges Deducted (Company Currency),Mahsup Vergi ve Harçlar (Şirket Para Birimi)
+Taxes and Charges Total,Vergi ve Harçlar Toplam
 Taxes and Charges Total (Company Currency),Vergi ve Ücretler Toplamı (Şirket para birimi)
 Technology,Teknoloji
 Telecommunications,Telekomünikasyon
 Telephone Expenses,Telefon Giderleri
 Television,Televizyon
 Template,Şablon
-Template for performance appraisals.,Performans değerlendirmeleri için şablon.
-Template of terms or contract.,Template of terms or contract.
+Template for performance appraisals.,Performans değerlendirmeleri için Şablon.
+Template of terms or contract.,Şart veya sözleşmeler şablonu.
 Temporary Accounts (Assets),Geçici Hesaplar (Varlıklar)
 Temporary Accounts (Liabilities),Geçici Hesaplar (Yükümlülükler)
 Temporary Assets,Geçici Varlıklar
 Temporary Liabilities,Geçici Yükümlülükler
 Term Details,Dönem Ayrıntıları
-Terms,Tanımlar
+Terms,Şartlar
 Terms and Conditions,Şartlar ve Koşullar
-Terms and Conditions Content,Şartlar ve Koşullar İçerik
+Terms and Conditions Content,Şartlar ve Koşullar İçeriği
 Terms and Conditions Details,Şartlar ve Koşullar Detayları
 Terms and Conditions Template,Şartlar ve Koşullar Şablon
-Terms and Conditions1,Terms and Conditions2
-Terretory,Terretory
+Terms and Conditions1,Şartlar ve Koşullar 1
+Terretory,Bölge
 Territory,Bölge
-Territory / Customer,Eyalet / Müşteri
+Territory / Customer,Bölge / Müşteri
 Territory Manager,Bölge Müdürü
-Territory Name,Bölge isim
-Territory Target Variance Item Group-Wise,Eyalet Hedef Varyans Ürün Grup-Wise
+Territory Name,Bölge Adı
+Territory Target Variance Item Group-Wise,Bölge Hedef Varyans Ürün Grubu
 Territory Targets,Bölge Hedefleri
 Test,Test
 Test Email Id,Test E-posta Kimliği
-Test the Newsletter,Bülten sınayın
-The BOM which will be replaced,Değiştirilir Ürün Birimi (ÜB)
+Test the Newsletter,Haber sınayın
+The BOM which will be replaced,Değiştirilecek BOM
 The First User: You,İlk Kullanıcı: Sen
-"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Paketi temsil Item. ""Hayır"" ve ""Evet"" olarak ""Satış Item Is"" Bu Öğe ""Stok Öğe mi"" olmalı"
+"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Ambalajı temsil eden Ürün. Bu Üründe ""Stok Ürünleri"" ""Hayır"", ""Satış Ürünü ""Evet"" olarak işaretlenmelidir"
 The Organization,Organizasyon
-"The account head under Liability, in which Profit/Loss will be booked","Kar / Zarar rezerve edileceği Sorumluluk altında hesap kafası,"
-The date on which next invoice will be generated. It is generated on submit.,Sonraki fatura oluşturulur hangi tarih. Bu teslim oluşturulur.
-The date on which recurring invoice will be stop,Yinelenen fatura durdurmak edileceği tarih
-"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","The day of the month on which auto invoice will be generated e.g. 05, 28 etc "
-The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Eğer izni için başvuran hangi gün (ler) tatil vardır. Sen izin talebinde gerekmez.
-The first Leave Approver in the list will be set as the default Leave Approver,Listedeki ilk bırak Approver varsayılan bırak Approver olarak kurulacaktır
-The first user will become the System Manager (you can change that later).,İlk kullanıcı (bunu daha sonra değiştirebilirsiniz) Sistem Yöneticisi olacaktır.
-The gross weight of the package. Usually net weight + packaging material weight. (for print),Paketin brüt ağırlığı. Genellikle net ağırlığı + ambalaj malzemesi ağırlığı. (Baskı için)
-The name of your company for which you are setting up this system.,Bu sistemi kurmak için hangi şirket ismi.
-The net weight of this package. (calculated automatically as sum of net weight of items),Bu paketin net ağırlığı. (Öğelerin net ağırlığı toplamı otomatik olarak hesaplanır)
-The new BOM after replacement,Değişiminden sonra yeni  Ürün Birimi (ÜB)
-The rate at which Bill Currency is converted into company's base currency,The rate at which Bill Currency is converted into company's base currency
-The unique id for tracking all recurring invoices. It is generated on submit.,Tüm yinelenen faturaların takibi için benzersiz kimliği. Bu teslim oluşturulur.
+"The account head under Liability, in which Profit/Loss will be booked",Kar/Zararın ayrılacağı hesap başlığı altındaki Yükümlülük
+The date on which next invoice will be generated. It is generated on submit.,Sonraki faturanın kesileceği tarih. Teslim zamanı kesilir.
+The date on which recurring invoice will be stop,Yinelenen faturanın durdurulacağı tarih
+"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Otomatik faturanın kesileceği tarih, örneğin 05, 28"
+The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Listedeki ilk izin onaylayıcı varsayılan izin onaylayıcı olarak atanacaktır.
+The first Leave Approver in the list will be set as the default Leave Approver,İlk kullanıcı sistem yöneticisi olacaktır (daha sonra değiştirebilirsiniz)
+The first user will become the System Manager (you can change that later).,Paketin brüt ağırlığı Genellikle net ağırlık+ambalaj Ürünü ağırlığıdır.
+The gross weight of the package. Usually net weight + packaging material weight. (for print),Paketin brüt ağırlığı. Genellikle net ağırlığı + ambalaj Ürünü ağırlığı. (Baskı için)
+The name of your company for which you are setting up this system.,Bu sistemi kurduğunu şirketinizin adı
+The net weight of this package. (calculated automatically as sum of net weight of items),Bu paketin net ağırlığı (Ürünlerin net toplamından otomatik olarak hesaplanır)
+The new BOM after replacement,Değiştirilmesinden sonra yeni BOM
+The rate at which Bill Currency is converted into company's base currency,Fatura Para biriminin şirketin temel para birimine dönüştürülme oranı
+The unique id for tracking all recurring invoices. It is generated on submit.,Bütün mükerrer faturaları izlemek için özel kimlik. Teslimatta oluşturulacaktır.
 "Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Sonra Fiyatlandırma Kurallar Müşteri dayalı filtre edilir, Müşteri Grubu, Territory, Tedarikçi, Tedarikçi Tipi, Kampanya, Satış Ortağı vb"
-There are more holidays than working days this month.,Bu ay iş günü daha tatil vardır.
+There are more holidays than working days this month.,Bu ayda çalışma günlerinden daha fazla tatil vardır.
 "There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Sadece ""değerini"" için 0 veya boş değere sahip bir Nakliye Kural Durumu olabilir"
-There is not enough leave balance for Leave Type {0},Bırak Tip için yeterli izni denge yok {0}
-There is nothing to edit.,Düzenlemek için bir şey yok.
-There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Bir hata oluştu. Bir muhtemel nedeni formu kaydettiğiniz değil ki olabilir. Sorun devam ederse support@erpnext.com başvurun.
-There were errors.,Hataları vardı.
-This Currency is disabled. Enable to use in transactions,Bu para devre dışı bırakılır. Işlemler kullanmak için etkinleştirin
-This Leave Application is pending approval. Only the Leave Apporver can update status.,Bu bırak Uygulama onayı bekliyor. Sadece bırak Apporver durumunu güncelleyebilirsiniz.
-This Time Log Batch has been billed.,Bu Saat Günlük Toplu fatura edilmiştir.
-This Time Log Batch has been cancelled.,Bu Saat Günlük Toplu iptal edildi.
-This Time Log conflicts with {0},This Time Log ile çakışan {0}
-This format is used if country specific format is not found,Ülkeye özgü biçimi bulunamadı değilse bu formatı kullanılır
-This is a root account and cannot be edited.,Bu root hesabı ve düzenlenemez.
-This is a root customer group and cannot be edited.,Bu bir kök müşteri grubu ve düzenlenemez.
-This is a root item group and cannot be edited.,Bu bir kök öğe grup ve düzenlenemez.
-This is a root sales person and cannot be edited.,Bu bir kök satış kişi ve düzenlenemez.
-This is a root territory and cannot be edited.,Bu bir kök bölge ve düzenlenemez.
-This is an example website auto-generated from ERPNext,Bu ERPNext itibaren otomatik olarak üretilen bir örnek web sitesi
-This is the number of the last created transaction with this prefix,This is the number of the last created transaction with this prefix
-This will be used for setting rule in HR module,This will be used for setting rule in HR module
+There is not enough leave balance for Leave Type {0},İzin tipi{0} için yeterli izin bakiyesi yok
+There is nothing to edit.,Düzenlenecek bir şey yok
+There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Hata oluştu. Bunun sebebi formu kaydetmemeniz olabilir. Sorun devam ederse support@erpnext.com adresi ile iltişime geçiniz
+There were errors.,Hatalar Oluştu.
+This Currency is disabled. Enable to use in transactions,Bu para birimi devre dışıdır. İşlemlerde kullanmak için etkinleştirin
+This Leave Application is pending approval. Only the Leave Apporver can update status.,İzin başvurusu onay bekliyor. Durumu yalnızca izin onaylayıcı güncelleyebilir.
+This Time Log Batch has been billed.,Bu Günlük Partisi faturalandı.
+This Time Log Batch has been cancelled.,Bu Günlük partisi iptal edildi.
+This Time Log conflicts with {0},Bu günlük {0} ile çelişiyor
+This format is used if country specific format is not found,Ülkeye özgü format bulunamazsa bu format kullanılır
+This is a root account and cannot be edited.,Bu bir kök hesabıdır ve düzenlenemez.
+This is a root customer group and cannot be edited.,Bu bir kök müşteri grubudur ve düzenlenemez.
+This is a root item group and cannot be edited.,Bu bir kök Ürün grubudur ve düzenlenemez.
+This is a root sales person and cannot be edited.,Bu bir kök satış kişisidir ve düzenlenemez.
+This is a root territory and cannot be edited.,Bu bir kök bölgedir ve düzenlenemez.
+This is an example website auto-generated from ERPNext,Bu ERPNextten otomatik olarak üretilmiş bir örnek web sitedir.
+This is the number of the last created transaction with this prefix,Bu ön ekle son oluşturulmuş işlemlerin sayısıdır
+This will be used for setting rule in HR module,Bu İK modunda ayarlama kuralı için kullanılacaktır
 Thread HTML,Konu HTML
 Thursday,Perşembe
-Time Log,Zaman yap
-Time Log Batch,Saat Günlük Toplu
-Time Log Batch Detail,Saat Günlük Toplu Detay
-Time Log Batch Details,Saat Günlük Toplu Detayları
-Time Log Batch {0} must be 'Submitted',Saat Günlük Toplu {0} 'Ekleyen' olmalı
-Time Log Status must be Submitted.,Zaman Günlüğü Durum gönderildi gerekir.
-Time Log for tasks.,Görevler için Zaman yap.
-Time Log is not billable,Zaman yap faturalandırılabilir değil
-Time Log {0} must be 'Submitted',Zaman yap {0} 'Ekleyen' olmalı
-Time Zone,Zaman Dilimi
+Time Log,Günlük
+Time Log Batch,Günlük Seri
+Time Log Batch Detail,Günlük Seri Detayı
+Time Log Batch Details,Günlük Seri Detayları
+Time Log Batch {0} must be 'Submitted',Günlük Seri {0} 'Teslim edilmelidir'
+Time Log Status must be Submitted.,Günlük durumu Teslim Edildi olmalıdır.
+Time Log for tasks.,Görevler için günlük.
+Time Log is not billable,Günlük faturalandırılamaz
+Time Log {0} must be 'Submitted',Günlük {0} 'Teslim edilmelidir'
+Time Zone,Saat Dilimi
 Time Zones,Saat Dilimleri
 Time and Budget,Zaman ve Bütçe
-Time at which items were delivered from warehouse,Depodan çıkış zamanı
-Time at which materials were received,Malzemelerin depoya giriş saati
+Time at which items were delivered from warehouse,Malzemlerine depodan teslim edildiğı zaman
+Time at which materials were received,Malzemelerin alındığı zaman
 Title,Başlık
-Titles for print templates e.g. Proforma Invoice.,Baskı şablonları için Başlıklar Proforma Fatura örneğin.
-To,to
+Titles for print templates e.g. Proforma Invoice.,"Baskı Şablonları için başlıklar, örneğin Proforma Fatura"
+To,(hesaba)
 To Currency,Para Birimi
-To Date,Bu tarihe kadar
-To Date should be same as From Date for Half Day leave,Tarih Yarım Gün izni Tarihten itibaren aynı olmalıdır
-To Date should be within the Fiscal Year. Assuming To Date = {0},Tarih Mali Yılı içinde olmalıdır. Tarihi varsayarsak = {0}
-To Discuss,To Discuss
+To Date,Tarihine kadar
+To Date should be same as From Date for Half Day leave,Tarihine Kadar ile Tarihinden itibaren aynı olmalıdır
+To Date should be within the Fiscal Year. Assuming To Date = {0},Tarih Mali Yıl içinde olmalıdır. Tarih = {0}
+To Discuss,Görüşülecek
 To Do List,Yapılacaklar Listesi
-To Package No.,To Package No.
-To Produce,Üretiliyor
-To Time,Time
+To Package No.,Ambalaj No.
+To Produce,Üretilecek
+To Time,Zamana
 To Value,Değer Vermek
-To Warehouse,To Warehouse
-"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Alt düğümlerin eklemek için, ağaç keşfetmek ve daha fazla düğüm eklemek istediğiniz altında düğüm üzerine tıklayın."
-"To assign this issue, use the ""Assign"" button in the sidebar.","Bu sorunu atamak kenar çubuğunda ""Ata"" düğmesini kullanın."
+To Warehouse,Depoya
+"To add child nodes, explore tree and click on the node under which you want to add more nodes.",Çocuk bölümü eklemek için ağacı inceleyin ve daha fazla hücre eklemek istediğiniz hücreye tıklayın
+"To assign this issue, use the ""Assign"" button in the sidebar.","Bu konuyu atamak için, yan taraftaki ""Ata"" butonunu kullanın"
 To create a Bank Account,Banka Hesabı oluşturmak için
 To create a Tax Account,Vergi Hesabı oluşturmak için
-"To create an Account Head under a different company, select the company and save customer.","Farklı bir şirket altında bir Hesap Başkanı oluşturmak için, şirket seçmek ve müşteri kaydedin."
-To date cannot be before from date,Tarihten itibaren bugüne kadar önce olamaz
-To enable <b>Point of Sale</b> features,Satış <b> Noktası </ b> özelliklerini etkinleştirmek için
-To enable <b>Point of Sale</b> view,Satış </ b> bakış <b> Noktası etkinleştirmek için
-To get Item Group in details table,Detay tabloda Ürün Grubu almak için
-"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Arka arkaya vergi dahil {0} Ürün fiyatına, satırlara vergiler {1} da dahil edilmelidir"
-"To merge, following properties must be same for both items","Birleştirmek için, aşağıdaki özellikleri hem öğeler için aynı olmalıdır"
-"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Belirli bir işlem Fiyatlandırma Kuralı uygulamak değil, tüm uygulanabilir Fiyatlandırması Kuralları devre dışı bırakılmalıdır."
+"To create an Account Head under a different company, select the company and save customer.",Farklı bir şirket altında hesap başlığı oluşturmak için şirket seçin ve müşteriyi kaydedin
+To date cannot be before from date,Tarihine kadar kısmı tarihinden itibaren kısmından önce olamaz
+To enable <b>Point of Sale</b> features,<b> satış noktası  <b> özelliklerini etkinleştirmek için
+To enable <b>Point of Sale</b> view,<b>Satış Noktası  <b> görüntüle etkinleştirmek için
+To get Item Group in details table,Detaylar tablosunda Ürün Grubu almak için
+"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",Satır {0} a vergi eklemek için  {1} satırlarındaki vergiler de dahil edilmelidir
+"To merge, following properties must be same for both items","Birleştirmek için, aşağıdaki özellikler her iki Ürün için de aynı olmalıdır"
+"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.",Belli bir işlemde Fiyatlandırma kuralını uygulamamak için bütün mevcut Fiyatlandırma Kuralları devre dışı bırakılmalıdır.
 "To set this Fiscal Year as Default, click on 'Set as Default'","Varsayılan olarak bu Mali Yılı ayarlamak için, 'Varsayılan olarak ayarla' seçeneğini tıklayın"
-To track any installation or commissioning related work after sales,Satış sonrası herhangi bir kurulum veya devreye alma ile ilgili çalışma izlemek için
-"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Aşağıdaki dokümanlar İrsaliye, Fırsat, Malzeme Request, Öğe, Sipariş, Satın Alma Fişi, Alıcı Alındı, Teklifi, Satış Fatura, Satış BOM, Satış Siparişi, Seri No markası izlemek için"
-To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Bunların seri nos dayalı satış ve satın alma belgeleri öğeyi izlemek için. Bu
-To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Toplu nos <br> <b> Tercih Sanayi ile satış ve satın alma belgeleri öğeleri izlemek için: Kimya vb </ b>
-To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Barkod kullanarak öğeleri izlemek için. Sen öğenin barkod tarayarak İrsaliye ve Satış Faturası öğelere girmek mümkün olacak.
-Too many columns. Export the report and print it using a spreadsheet application.,Çok fazla sütun. Raporu vermek ve bir elektronik tablo uygulaması kullanarak yazdırın.
+To track any installation or commissioning related work after sales,Satış sonrası bütün kurulum veya işletmeye alma işlerini izlemek için
+"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Şu belgelerde marka adını aramak için İrsaliye, Fırsat, Ürün Request, Öğe, Sipariş, Satın Alma Fişi, Alıcı Alındı, Teklifi, Satış Fatura, Satış BOM, Satış Siparişi"
+To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Ürünleri seri numaralarına bağlı olarak alım ve satış belgelerinde izlemek için. Bu aynı zamanda ürünün garanti ayarları için de kullanılabilir.
+To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Ürünleri seri numaralarıyla satış ve alım belgelerinde izlemek için
+To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Ürünleri barkod kullanarak aramak için. Ürünlerin barkodunu taratarak Ürünleri İrsaliye ev Satış Faturasına girebilirsiniz
+Too many columns. Export the report and print it using a spreadsheet application.,Çok fazla sütun. Raporu çıkarın ve spreadsheet uygulaması kullanarak yazdırın.
 Tools,Araçlar
 Total,Toplam
 Total ({0}),Toplam ({0})
-Total Advance,Toplam Peşin
+Total Advance,Toplam Advance
 Total Amount,Toplam Tutar
 Total Amount To Pay,Toplam Ödenecek Tutar
-Total Amount in Words,Yazı  ile Toplam Tutar
-Total Billing This Year: ,Total Billing This Year: 
+Total Amount in Words,Sözlü Toplam Tutar
+Total Billing This Year: , Bu yıl toplam ödenen fatura
 Total Characters,Toplam Karakterler
-Total Claimed Amount,Total Claimed Amount
+Total Claimed Amount,Toplam İade edilen Tutar
 Total Commission,Toplam Komisyon
 Total Cost,Toplam Maliyet
-Total Credit,Toplam Alacak
+Total Credit,Toplam Kredi
 Total Debit,Toplam Borç
-Total Debit must be equal to Total Credit. The difference is {0},"Toplam Bankamatik Toplam Kredi eşit olmalıdır. Aradaki fark, {0}"
+Total Debit must be equal to Total Credit. The difference is {0},"Toplam Borç Toplam Krediye eşit olmalıdırr. Aradaki fark, {0}"
 Total Deduction,Toplam Kesinti
 Total Earning,Toplam Kazanç
 Total Experience,Toplam Deneyim
 Total Hours,Toplam Saat
 Total Hours (Expected),Toplam Saat (Beklenen)
-Total Invoiced Amount,Toplam Faturalanan Tutar
-Total Leave Days,Toplam izin günü
-Total Leaves Allocated,Toplam  Ayrılanlar
+Total Invoiced Amount,Toplam Faturalanmış Tutar
+Total Leave Days,Toplam bırak Günler
+Total Leaves Allocated,Ayrılan toplam izinler
 Total Message(s),Toplam Mesaj (lar)
 Total Operating Cost,Toplam İşletme Maliyeti
-Total Points,Toplam Sayı
+Total Points,Toplam Puan
 Total Raw Material Cost,Toplam Hammadde Maliyeti
-Total Sanctioned Amount,Toplam Yaptırım Tutar
-Total Score (Out of 5),Toplam Puan (5 Üzerinden)
+Total Sanctioned Amount,Toplam Tasdiklenmiş Tutar
+Total Score (Out of 5),Toplam Puan (5 üzerinden)
 Total Tax (Company Currency),Toplam Vergi (Şirket para birimi)
-Total Taxes and Charges,Toplam Vergiler ve Harçlar
-Total Taxes and Charges (Company Currency),Toplam Vergi ve Harçlar (Company Para)
+Total Taxes and Charges,Toplam Vergi ve Harçlar
+Total Taxes and Charges (Company Currency),Toplam Vergi ve Harçlar (Şirket Para Birimi)
 Total allocated percentage for sales team should be 100,Satış ekibi için ayrılan toplam yüzde 100 olmalıdır
-Total amount of invoices received from suppliers during the digest period,Sindirmek dönemde tedarikçilerden alınan faturaların toplam tutarı
-Total amount of invoices sent to the customer during the digest period,Özet döneminde müşteriye gönderilen faturaların toplam tutarı
+Total amount of invoices received from suppliers during the digest period,Düzenleme döneminde tedarikçilerden alınan toplam fatura tutarı
+Total amount of invoices sent to the customer during the digest period,Düzenleme Döneminde Müşteriye Gönderilen faturaların toplam Tutarı
 Total cannot be zero,Toplam sıfır olamaz
-Total in words,Yazı ile toplam
-Total points for all goals should be 100. It is {0},Tüm hedefler için toplam puan 100 olmalıdır. Bu {0}
-Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Üretilen veya repacked öğe (ler) için Toplam değerleme hammadde toplam değerlemesi az olamaz
-Total weightage assigned should be 100%. It is {0},Atanan toplam weightage% 100 olmalıdır. Bu {0}
+Total in words,Sözlü Toplam
+Total points for all goals should be 100. It is {0}, Hedefler için toplam puan 100 olmalıdır Bu {0} dır
+Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Üretilen veya yeniden ambalajlanan Ürünler için toplam değerlendirme ham maddelerin toplam değerinden az olamaz.
+Total weightage assigned should be 100%. It is {0},Atanan toplam ağırlık % 100 olmalıdır. Bu {0} dır
 Totals,Toplamlar
-Track Leads by Industry Type.,Parça Sanayi Türüne göre Talepleri.
-Track this Delivery Note against any Project,Track this Delivery Note against any Project
-Track this Sales Order against any Project,Track this Sales Order against any Project
-Transaction,Işlem
+Track Leads by Industry Type.,Sanayi Tipine Göre izleme talebi.
+Track this Delivery Note against any Project,Bu irsaliyeyi bütün Projelere karşı takip et
+Track this Sales Order against any Project,Bu satış emrini bütün Projelere karşı takip et
+Transaction,İşlem
 Transaction Date,İşlem Tarihi
-Transaction not allowed against stopped Production Order {0},İşlem durduruldu Üretim Emri karşı izin {0}
+Transaction not allowed against stopped Production Order {0},Durdurulmuş Üretim Emrine {0} karşı işleme izin verilmez
 Transfer,Transfer
-Transfer Material,Transferi Malzeme
-Transfer Raw Materials,Hammaddeleri Transferi
-Transferred Qty,Adet Aktarılan
+Transfer Material,Transfer Malzemesi
+Transfer Raw Materials,Hammaddelerin Transferi
+Transferred Qty,Transfer Edilen Miktar
 Transportation,Taşıma
-Transporter Info,Transporter Bilgiler
-Transporter Name,Transporter Adı
-Transporter lorry number,Transporter kamyon sayısı
+Transporter Info,Taşıyıcı Bilgisi
+Transporter Name,Taşıyıcı Adı
+Transporter lorry number,Taşıyıcı kamyon numarası
 Travel,Gezi
 Travel Expenses,Seyahat Giderleri
-Tree Type,Ağaç Type
-Tree of Item Groups.,Ürün Grupları ağaç.
-Tree of finanial Cost Centers.,Finanial Maliyet Merkezlerinin ağaç.
-Tree of finanial accounts.,Finanial hesapların ağaç.
+Tree Type,Ağaç Tipi
+Tree of Item Groups.,Ürün Grupları Ağacı
+Tree of finanial Cost Centers.,Finansal Maliyet Merkezleri Ağacı
+Tree of finanial accounts.,Finansal Hesaplar Ağacı
 Trial Balance,Mizan
 Tuesday,Salı
 Type,Tip
-Type of document to rename.,Yeniden adlandırmak için belge türü.
-"Type of leaves like casual, sick etc.","Casual, hasta vs gibi yaprakların Türü"
-Types of Expense Claim.,Gider  türleri.
-Types of activities for Time Sheets,Zaman Levhalar için etkinlikler Türleri
-"Types of employment (permanent, contract, intern etc.).","Istihdam (daimi, sözleşmeli, stajyer vb) Türleri."
-UOM Conversion Detail,Ürün Birimi (ÜB) Dönüşüm Ayrıntısı
-UOM Conversion Details,Ürün Birimi (ÜB) Dönüşümü Detayları
-UOM Conversion Factor,Ürün Birimi (ÜB) Dönüşüm Faktörü
-UOM Conversion factor is required in row {0},UOM Dönüşüm faktörü satırda gereklidir {0}
-UOM Name,Ürün Birimi (ÜB) Adı
-UOM coversion factor required for UOM: {0} in Item: {1},UOM için gerekli UoM coversion faktörü: {0} Öğe: {1}
+Type of document to rename.,Yeniden adlandırılacak Belge Türü.
+"Type of leaves like casual, sick etc.","Normal, hastalık vb izin tipleri"
+Types of Expense Claim.,Gider talebi Türleri.
+Types of activities for Time Sheets,Zaman Cetveli için faaliyet türleri
+"Types of employment (permanent, contract, intern etc.).","İstihdam (daimi, sözleşmeli, stajyer vb) Türleri."
+UOM Conversion Detail,UOM Dönüşüm Detayı
+UOM Conversion Details,UOM Dönüşüm Detayları
+UOM Conversion Factor,UOM Dönüşüm Katsayısı
+UOM Conversion factor is required in row {0},UOM Dönüşüm katsayısı satır {0} da gereklidir
+UOM Name,UOM Adı
+UOM coversion factor required for UOM: {0} in Item: {1},Ürün {1} de UOM: {0} için UOM dönüştürme katsayısı gereklidir.
 Under AMC,AMC altında
-Under Graduate,Lisans Altı
+Under Graduate,Lisans Altında
 Under Warranty,Garanti Altında
 Unit,Birim
 Unit of Measure,Ölçü Birimi
-Unit of Measure {0} has been entered more than once in Conversion Factor Table,Ölçü Birimi {0} daha Katsayı Tablo kez daha girildi
-"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Bu madde (örneğin Kg, Ünitesi, Hayır, Pair) ölçü birimi."
+Unit of Measure {0} has been entered more than once in Conversion Factor Table,Ölçü Birimi {0} Dönüşüm katsayısı tablosunda birden fazla kez girildi.
+"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Bu Ürünün ölçü birimi (örneğin Kg, Birim, Adet, Çift)"
 Units/Hour,Birimler / Saat
-Units/Shifts,Birimler / vardiya
+Units/Shifts,Birimler / Vardiya
 Unpaid,Ödenmemiş
 Unreconciled Payment Details,Uzlaşmayan Ödeme Ayrıntıları
-Unscheduled,Planlanmamış
+Unscheduled,Plânlanmamış
 Unsecured Loans,Teminatsız Krediler
-Unstop,Tıpasını çıkarmak
-Unstop Material Request,Dolgusu Malzeme Talebi
-Unstop Purchase Order,Dolgusu Sipariş
-Unsubscribed,Üyelikten çıkanlar
-Update,Güncelleştir
-Update Clearance Date,Update Clearance Date
+Unstop,Durdurmayı iptal etmek
+Unstop Material Request,Malzeme Talebini Durdurmayı iptal et
+Unstop Purchase Order,Satın alma siparişini Durdurmayı iptal et
+Unsubscribed,Kaydolmamış
+Update,Güncelleme
+Update Clearance Date,Güncelleme Alma Tarihi
 Update Cost,Güncelleme Maliyeti
-Update Finished Goods,Güncelleme Mamüller
-Update Landed Cost,Güncelleme Maliyet indi
-Update Series,Update Serisi
-Update Series Number,Update Serisi sayısı
-Update Stock,Stok Güncelleme
-Update bank payment dates with journals.,Update bank payment dates with journals.
-Update clearance date of Journal Entries marked as 'Bank Vouchers',Journal Entries Update temizlenme tarihi 'Banka Fişler' olarak işaretlenmiş
+Update Finished Goods,Mamülleri Güncelle
+Update Landed Cost,İnen Maliyeti Güncelle
+Update Series,Seriyi Güncelle
+Update Series Number,Seri Numarasını Güncelle
+Update Stock,Stok güncelle
+Update bank payment dates with journals.,Günlüklerle ödeme tarihlerini güncelle.
+Update clearance date of Journal Entries marked as 'Bank Vouchers','Banka Föyleri' olarak işaretlenmiş Günlük girdilerinin çekim tarihlerini güncelle
 Updated,Güncellenmiş
-Updated Birthday Reminders,Güncelleme Birthday Reminders
-Upload Attendance,Katılımcı ekle
-Upload Backups to Dropbox,Dropbox Yedekler yükle
-Upload Backups to Google Drive,Google Drive'a Yedekler yükle
-Upload HTML,HTML yükle
-Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Eski adı ve yeni adı:. İki sütunlu bir csv dosyası yükleyin. Max 500 satırlar.
-Upload attendance from a .csv file,Upload attendance from a .csv file
-Upload stock balance via csv.,Upload stock balance via csv.
-Upload your letter head and logo - you can edit them later.,Mektup baş ve logo yükleyin - daha sonra bunları düzenleyebilirsiniz.
+Updated Birthday Reminders,Doğumgünü hatırlatıcılarını güncelle
+Upload Attendance,Devamlılığı Güncelle
+Upload Backups to Dropbox,Yedekleri Dropbox'a yükle
+Upload Backups to Google Drive,Yedekleri Google Drive'a yükle
+Upload HTML,HTML Yükle
+Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,İki sütunlu bir csv dosyası yükle eski isim ve yeni isim. Maksimum 500 satır
+Upload attendance from a .csv file,Bir. Csv dosyasından devamlılığı yükle
+Upload stock balance via csv.,Csv üzerinden stok bakiyesini yükle.
+Upload your letter head and logo - you can edit them later.,Antet ve logonuzu yükleyin bunları daha sonra düzenleyebilirsiniz
 Upper Income,Üst Gelir
 Urgent,Acil
-Use Multi-Level BOM,Multi-Level Malzeme Listesi (ML) kullanın
+Use Multi-Level BOM,Çok Seviyeli BOM kullan
 Use SSL,SSL kullan
 Used for Production Plan,Üretim Planı için kullanılan
 User,Kullanıcı
-User ID,Kullanıcı Kimliği
-User ID not set for Employee {0},Kullanıcı kimliği Çalışanlara ayarlı değil {0}
-User Name,Kullanıcı adı
-User Name or Support Password missing. Please enter and try again.,Kullanıcı Adı veya Destek Şifre eksik. Girin ve tekrar deneyin.
-User Remark,Kullanıcı Açıklama
-User Remark will be added to Auto Remark,User Remark will be added to Auto Remark
-User Remarks is mandatory,Kullanıcı zorunludur Açıklamalar
-User Specific,Kullanıcı Özgül
-User must always select,Kullanıcı her zaman seçmeli
-User {0} is already assigned to Employee {1},Kullanıcı {0} zaten Çalışan atanmış {1}
+User ID,Kullanıcı kimliği
+User ID not set for Employee {0},Çalışan {0} için Kullanıcı Kimliği ayarlanmamış
+User Name,Kullanıcı Adı
+User Name or Support Password missing. Please enter and try again.,Kullanıcı Adı veya Destek Şifre eksik. Girin ve tekrar deneyin.
+User Remark,Kullanıcı Açıklaması
+User Remark will be added to Auto Remark,Kullanıcı Açıklaması Otomatik açıklamaya eklenecektir
+User Remarks is mandatory,Kullanıcı açıklamaları zorunludur
+User Specific,Kullanıcıya Özgü
+User must always select,Kullanıcı her zaman seçmelidir
+User {0} is already assigned to Employee {1},Kullanıcı {0} zaten Çalışan {1} e atanmış
 User {0} is disabled,Kullanıcı {0} devre dışı
 Username,Kullanıcı Adı
-Users with this role are allowed to create / modify accounting entry before frozen date,Bu role sahip kullanıcılar dondurulmuş tarihten önce muhasebe girdisini değiştirmek / oluşturmak için izin verilir
-Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Bu role sahip kullanıcılar dondurulmuş hesaplara karşı muhasebe kayıtlarını değiştirmek / dondurulmuş hesapları ayarlamak ve oluşturmak için izin verilir
-Utilities,Kamu hizmetleri
+Users with this role are allowed to create / modify accounting entry before frozen date,Bu role sahip kullanıcıların dondurulma tarihinden önce girdiyi oluşturma/düzenleme yetkileri vardır
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Bu role sahip kullanıcıların dondurulmuş hesapları ayarlama ve dondurulmuş hesaplara karşı muhasebe girdileri oluşturma/düzenleme yetkileri vardır
+Utilities,Programlar
 Utility Expenses,Yardımcı Giderleri
-Valid For Territories,Toprakları için geçerli
+Valid For Territories,Bölgeler için geçerli
 Valid From,Itibaren geçerli
-Valid Upto,geçerlidir
-Valid for Territories,Toprakları için geçerli
+Valid Upto,tarihine kadar geçerli  
+Valid for Territories,Bölgeler için geçerli
 Validate,Onayla
 Valuation,Değerleme
 Valuation Method,Değerleme Yöntemi
 Valuation Rate,Değerleme Oranı
-Valuation Rate required for Item {0},Ürün için gerekli Değerleme Oranı {0}
+Valuation Rate required for Item {0},Ürün {0} için gerekli Değereme Oranı
 Valuation and Total,Değerleme ve Toplam
 Value,Değer
-Value or Qty,Değer veya Adet
+Value or Qty,Değer veya Miktar
 Vehicle Dispatch Date,Araç Sevk Tarihi
-Vehicle No,Araç yok
+Vehicle No,Araç No
 Venture Capital,Girişim Sermayesi
-Verified By,Verified By
-View Ledger,Görünüm Ledger
+Verified By,Onaylı
+View Ledger,Değerlendirme Defteri
 View Now,Şimdi görüntüle
-Visit report for maintenance call.,Bakım çağrısı için rapor alır.
-Voucher #,Çeki #
-Voucher Detail No,Fiş Detay no
-Voucher Detail Number,Fiş Detay Numarası
-Voucher ID,Fiş numarası
-Voucher No,Fiş no
-Voucher Type,Fiş Tipi
-Voucher Type and Date,Fiş Tipi ve Tarih
-Walk In,Walk In
+Visit report for maintenance call.,Bakım araması için ziyaret raporu.
+Voucher #,Föy #
+Voucher Detail No,Föy Detay no
+Voucher Detail Number,Föy Detay Numarası
+Voucher ID,Föy Kimliği
+Voucher No,Föy No
+Voucher Type,Föy Türü
+Voucher Type and Date,Föy Tipi ve Tarih
+Walk In,Rezervasyonsuz Müşteri
 Warehouse,Depo
 Warehouse Contact Info,Depo İletişim Bilgileri
-Warehouse Detail,Depo Detay
+Warehouse Detail,Depo Detayı
 Warehouse Name,Depo Adı
 Warehouse and Reference,Depo ve Referans
-Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Hisse senedi defteri girişi, bu depo için var gibi depo silinemez."
-Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Depo sadece Stok Giriş / İrsaliye / Satın Alma Makbuzu ile değiştirilebilir
+Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Bu depo için defter girdisi mevcutken depo silinemez.
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Depo yalnızca Stok Girdisi / İrsaliye / Satın Alım Makbuzu üzerinden değiştirilebilir
 Warehouse cannot be changed for Serial No.,Depo Seri No için değiştirilemez
-Warehouse is mandatory for stock Item {0} in row {1},Depo stok Ürün için zorunludur {0} üst üste {1}
-Warehouse is missing in Purchase Order,Depo Satınalma Siparişi eksik
-Warehouse not found in the system,Sistemde bulunan değildir Depo
-Warehouse required for stock Item {0},Stok Öğe için gerekli depo {0}
-Warehouse where you are maintaining stock of rejected items,Warehouse where you are maintaining stock of rejected items
-Warehouse {0} can not be deleted as quantity exists for Item {1},Ürün miktarı için var gibi depo {0} silinemez {1}
-Warehouse {0} does not belong to company {1},Depo {0} ait değil şirket {1}
-Warehouse {0} does not exist,Depo {0} yok
+Warehouse is mandatory for stock Item {0} in row {1},Satır {1} de stok Ürünü {0} için depo zorunludur
+Warehouse is missing in Purchase Order,Satış Emrinde Depo eksik
+Warehouse not found in the system,Sistemde depo bulunmadı
+Warehouse required for stock Item {0},Stok Ürünü {0} için depo gereklidir
+Warehouse where you are maintaining stock of rejected items,Reddedilen Ürün stoklarını muhafaza ettiğiniz depo
+Warehouse {0} can not be deleted as quantity exists for Item {1},Ürün {1} için miktar mevcut olduğundan depo {0} silinemez
+Warehouse {0} does not belong to company {1},Depo {0} Şirket {1}e ait değildir
+Warehouse {0} does not exist,Depo {0} yoktur
 Warehouse {0}: Company is mandatory,Depo {0}: Şirket zorunludur
-Warehouse {0}: Parent account {1} does not bolong to the company {2},Depo {0}: Ana hesap {1} şirkete BOLONG gelmez {2}
-Warehouse-Wise Stock Balance,Depo-Wise Stok Bakiye
-Warehouse-wise Item Reorder,Depo-bilge Ürün Reorder
+Warehouse {0}: Parent account {1} does not bolong to the company {2},Depo {0}: Ana hesap {1} Şirket {2} ye ait değildir
+Warehouse-Wise Stock Balance,Depo- Stok Bakiye
+Warehouse-wise Item Reorder,Depo-bilgi Ürün Yeniden siparişi
 Warehouses,Depolar
 Warehouses.,Depolar.
-Warn,Uyarı
-Warning: Leave application contains following block dates,Uyarı: Uygulama aşağıdaki blok tarih içeriyor bırak
-Warning: Material Requested Qty is less than Minimum Order Qty,Uyarı: Adet İstenen Malzeme Minimum Sipariş Miktar az
-Warning: Sales Order {0} already exists against same Purchase Order number,Uyarı: Satış Sipariş {0} zaten Aynı Sipariş sayıda karşı var
-Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Uyarı: Sistem {0} {1} sıfır olarak Ürün için bir miktar beri overbilling kontrol olmaz
+Warn,Uyarmak
+Warning: Leave application contains following block dates,Uyarı: İzin uygulamasında aşağıdaki engel tarihleri bulunmaktadır
+Warning: Material Requested Qty is less than Minimum Order Qty,Uyarı: İstenen Ürün Miktarı Minimum Sipariş Miktarından az 
+Warning: Sales Order {0} already exists against same Purchase Order number,Uyarı: Satış Siparişi {0} aynı Satın Alma siparişi ile zaten kayıtlı
+Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Uyarı: {1} deki {0} ürünü miktarı sıfır olduğu için sistem fazla faturalamayı kontrol etmeyecektir
 Warranty / AMC Details,Garanti / AMC Detayları
 Warranty / AMC Status,Garanti / AMC Durum
 Warranty Expiry Date,Garanti Son Kullanma Tarihi
 Warranty Period (Days),Garanti Süresi (Gün)
-Warranty Period (in days),Garanti Süresi (gün)
-We buy this Item,Bu Ürün satın
-We sell this Item,Biz bu Ürün satmak
+Warranty Period (in days),(Gün) Garanti Süresi
+We buy this Item,Bu Ürünyi satın alıyoruz
+We sell this Item,Bu Ürünyi satıyoruz
 Website,Web sitesi
-Website Description,Web Sitesi Tanıtım
+Website Description,Web Sitesi Açıklaması
 Website Item Group,Web Sitesi Ürün Grubu
 Website Item Groups,Web Sitesi Ürün Grupları
 Website Settings,Web Sitesi Ayarları
-Website Warehouse,Web Sitesi Atölyesi
+Website Warehouse,Web Sitesi Depo
 Wednesday,Çarşamba
 Weekly,Haftalık
-Weekly Off,Weekly Off
-Weight UOM,Ağırlık ÜB
-"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Ağırlık belirtilen, \n ""Ağırlık uom"" belirtiniz çok"
-Weightage,Weightage
-Weightage (%),Weightage (%)
+Weekly Off,Haftalık İzin
+Weight UOM,Ağırlık UOM
+"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Ağırlık Belirtilmemiş, \nLütfen Ağırlık UOM'u da belirtiniz"
+Weightage,Ağırlık
+Weightage (%),Ağırlık (%)
 Welcome,Hoşgeldiniz
-Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,ERPNext hoşgeldiniz. Önümüzdeki birkaç dakika içinde biz size kurulum sizin ERPNext hesap yardımcı olacaktır. Deneyin ve biraz uzun sürecek olsa bile sahip olduğu kadar çok bilgi doldurun. Bu size daha sonra çok zaman kazandıracak. Iyi şanslar!
+Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,ERPNext'e hoşgeldiniz. Birkaç dakika boyunca ERNext hesabınızı kurmanıza yardım edeceğiz. Uzun sürse de mümkün olduğunca fazla bilgi girmeye çalışın. İyi Şanslar
 Welcome to ERPNext. Please select your language to begin the Setup Wizard.,ERPNext hoşgeldiniz. Kurulum Sihirbazı başlatmak için dilinizi seçiniz.
 What does it do?,Ne yapar?
-"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Kontrol işlemlerin herhangi bir ""gönderildi"" zaman, bir e-posta pop-up otomatik ek olarak işlem ile, bu işlem ilişkili ""İletişim"" bir e-posta göndermek için açıldı. Kullanıcı veya e-posta göndermek olmayabilir."
-"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Teslim olduğunda, sistem bu tarihte verilen stok ve değerleme ayarlamak için fark girdilerini oluşturur."
-Where items are stored.,Ürünlerin depolandığı yer
-Where manufacturing operations are carried out.,Üretim faaliyetlerinin yürütüldüğü yerlerde.
+"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","İşaretli işlemlerden biri ""Teslim Edildiğinde"" işlemdeki ilgili ""Kişi""ye e-mail gönderecek bir e-mail penceresi açılacaktır, işlemi ekte gönderecektir."
+"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Teslim edildiğinde, sistem bu tarihte verilen stok ve değerlemeyi ayarlamak için farklılık yaratır."
+Where items are stored.,Ürünlerin saklandığı yer
+Where manufacturing operations are carried out.,İmalat işlemlerinin yürütüldüğü yer
 Widowed,Dul
-Will be calculated automatically when you enter the details,Eğer detayları girdiğinizde otomatik olarak hesaplanır
-Will be updated after Sales Invoice is Submitted.,Satış Faturası Ekleyen sonra güncellenecektir.
-Will be updated when batched.,Batched zaman güncellenecektir.
-Will be updated when billed.,Gagalı zaman güncellenecektir.
+Will be calculated automatically when you enter the details,Detayları girdiğinizde otomatik olarak hesaplanacaktır
+Will be updated after Sales Invoice is Submitted.,Satış Faturası verildikten sonra güncellenecektir.
+Will be updated when batched.,Serilendiğinde güncellenecektir.
+Will be updated when billed.,Faturalandığında güncellenecektir.
 Wire Transfer,Elektronik transfer
 With Operations,Operasyon ile
-With Period Closing Entry,Dönem Kapanış Girişi ile
+With Period Closing Entry,Dönem Kapanış Girdisi ile
 Work Details,İş Detayları
-Work Done,Çalışma bitti
-Work In Progress,Çalışmalar Devam Ediyor
-Work-in-Progress Warehouse,Work-in-Progress Warehouse
-Work-in-Progress Warehouse is required before Submit,Work-in-Progress Warehouse sun önce gerekli
-Working,Çalışma
+Work Done,Yapılan İş
+Work In Progress,Devam eden iş
+Work-in-Progress Warehouse,Devam eden depo işi
+Work-in-Progress Warehouse is required before Submit,Devam eden depo işi teslimden önce gereklidir
+Working,Çalışıyor
 Working Days,Çalışma Günleri
 Workstation,İş İstasyonu
 Workstation Name,İş İstasyonu Adı
-Write Off Account,Write Off Account
-Write Off Amount,Write Off Amount
-Write Off Amount <=,Write Off Amount <=
-Write Off Based On,Write Off Based On
-Write Off Cost Center,Write Off Cost Center
-Write Off Outstanding Amount,Write Off Outstanding Amount
-Write Off Voucher,Write Off Voucher
-Wrong Template: Unable to find head row.,Yanlış Şablon: kafa satır bulmak için açılamıyor.
+Write Off Account,Hesabı Kapat
+Write Off Amount,Borç Silme Miktarı
+Write Off Amount <=,Borç Silme Miktarı <=
+Write Off Based On,Dayalı Borç Silme
+Write Off Cost Center,Borç Silme Maliyet Merkezi
+Write Off Outstanding Amount,Bekleyen Miktarı Sil
+Write Off Voucher,Föyü Kapat
+Wrong Template: Unable to find head row.,Yanlış Şablon: başlık satırı bulunamıyor.
 Year,Yıl
 Year Closed,Yıl Kapalı
 Year End Date,Yıl Bitiş Tarihi
 Year Name,Yıl Adı
 Year Start Date,Yıl Başlangıç ​​Tarihi
-Year of Passing,Geçmiş Yıllar
+Year of Passing,Geçiş Yılı
 Yearly,Yıllık
 Yes,Evet
-You are not authorized to add or update entries before {0},Sen önce girdilerini eklemek veya güncellemek için yetkiniz yok {0}
-You are not authorized to set Frozen value,Sen Frozen değerini ayarlamak için yetkiniz yok
-You are the Expense Approver for this record. Please Update the 'Status' and Save,Siz bu kayıt için Gider Onaylayan vardır. 'Durum' güncelleyin ve kaydet Lütfen
-You are the Leave Approver for this record. Please Update the 'Status' and Save,Siz bu kayıt için bırak Onaylayan vardır. 'Durum' güncelleyin ve kaydet Lütfen
-You can enter any date manually,Elle herhangi bir tarih girebilirsiniz
-You can enter the minimum quantity of this item to be ordered.,Sen sipariş için bu maddenin minimum miktar girebilirsiniz.
-You can not change rate if BOM mentioned agianst any item,BOM herhangi bir öğenin agianst söz eğer hızını değiştiremezsiniz
-You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Hayır hem Teslim Not giremezsiniz ve Satış Fatura No birini girin.
-You can not enter current voucher in 'Against Journal Voucher' column,Sen sütununda 'Journal Fiş Karşı' cari fiş giremezsiniz
-You can set Default Bank Account in Company master,Siz Firma master Varsayılan Banka Hesap ayarlayabilirsiniz
-You can start by selecting backup frequency and granting access for sync,Yedekleme sıklığını seçme ve senkronizasyon için erişim sağlayarak başlayabilirsiniz
-You can submit this Stock Reconciliation.,Bu Stok Uzlaşma gönderebilirsiniz.
-You can update either Quantity or Valuation Rate or both.,Siz Miktar veya Değerleme Oranı ya da her ikisini güncelleyebilirsiniz.
-You cannot credit and debit same account at the same time,Sen kredi ve aynı anda aynı hesap borçlandıramıyoruz
-You have entered duplicate items. Please rectify and try again.,Sen yinelenen öğeleri girdiniz. Düzeltmek ve tekrar deneyin.
-You may need to update: {0},Güncellemeniz gerekebilir: {0}
-You must Save the form before proceeding,Ilerlemeden önce formu kaydedin gerekir
-Your Customer's TAX registration numbers (if applicable) or any general information,Sizin Müşteri VERGİ sicil numaraları (varsa) veya herhangi bir genel bilgi
+You are not authorized to add or update entries before {0},{0} dan önceki girdileri ekleme veya güncelleme yetkiniz yok
+You are not authorized to set Frozen value,Donmuş değer ayarlama yetkiniz yok
+You are the Expense Approver for this record. Please Update the 'Status' and Save,Bu Kayıt için Gider Onaylayıcısınız. Lütfen 'durumu' güncelleyip kaydedin.
+You are the Leave Approver for this record. Please Update the 'Status' and Save,Bu Kayıt için İzin Onaylayıcısınız. Lütfen durumu güncelleyip kaydedin.
+You can enter any date manually,Elle tarih girebilirsiniz
+You can enter the minimum quantity of this item to be ordered.,"Bu Ürünnin, minimum sipariş tutarını girebilirsiniz"
+You can not change rate if BOM mentioned agianst any item,Herhangi bir Ürünye karşo BOM belirtildiyse oran değiştiremezsiniz.
+You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,İrsaliye hem Satş Faturası giremezsiniz. Lütfen sadece birini girin.
+You can not enter current voucher in 'Against Journal Voucher' column,'Karşıt Banka Dekontu' sütununda cari föy giremezsiniz
+You can set Default Bank Account in Company master,Firma alanında Varsayılan Banka Hesap ayarlayabilirsiniz
+You can start by selecting backup frequency and granting access for sync,Yedekleme sıklığı seçerek ve senkronizasyon için erişim izni vererek başlayabilirsiniz
+You can submit this Stock Reconciliation.,Bu Stok mutabakatını Gönderebilirsiniz.
+You can update either Quantity or Valuation Rate or both.,Miktarı veya Değerleme Oranını veya her ikisini birden güncelleyebilirsiniz
+You cannot credit and debit same account at the same time,Aynı hesabı aynı anda kredilendirip borçlandıramazsınız
+You have entered duplicate items. Please rectify and try again.,Yinelenen Ürünler girdiniz. Lütfen düzeltip yeniden deneyin.
+You may need to update: {0},Şunu güncellemeniz gerekebilir: {0}
+You must Save the form before proceeding,Devam etmeden önce formu kaydetmelisiniz
+Your Customer's TAX registration numbers (if applicable) or any general information,Müşterinizin vergi sicil numarası (varsa) veya diğer genel bilgiler
 Your Customers,Müşterileriniz
 Your Login Id,Giriş Kimliğiniz
-Your Products or Services,ürün veya hizmetleriniz
+Your Products or Services,Ürünleriniz veya hizmetleriniz
 Your Suppliers,Tedarikçileriniz
 Your email address,Eposta adresiniz
-Your financial year begins on,mali yılınız başlıyor
-Your financial year ends on,mali yılınız sona eriyor
-Your sales person who will contact the customer in future,Gelecekte müşteriyle irtibata geçecek satış temsilcisi
-Your sales person will get a reminder on this date to contact the customer,Your sales person will get a reminder on this date to contact the customer
+Your financial year begins on,Mali yılınız şu tarihte başlıyor:
+Your financial year ends on,Mali yılınız şu tarihte sona eriyor:
+Your sales person who will contact the customer in future,Müşteriyle ileride irtibat kuracak satış kişiniz
+Your sales person will get a reminder on this date to contact the customer,Satış kişiniz bu tarihte müşteriyle irtibata geçmek için bir hatırlama alacaktır
 Your setup is complete. Refreshing...,Kurulum tamamlandı. Yenileniyor ...
-Your support email id - must be a valid email - this is where your emails will come!,Your support email id - must be a valid email - this is where your emails will come!
+Your support email id - must be a valid email - this is where your emails will come!,Destek e posta kimliğini geçerli bir e posta adresi olmalıdır- e postalarınız buraya gelecektir!
 [Error],[Hata]
 [Select],[Seç]
-`Freeze Stocks Older Than` should be smaller than %d days.,`Daha Eski Freeze Hisse`% d gün daha küçük olmalıdır.
+`Freeze Stocks Older Than` should be smaller than %d days.,'Şundan eski stokları dondur' %günden daha küçük olmalıdır
 and,ve
-are not allowed.,izin verilmez.
-assigned by,tarafından atandı
+are not allowed.,İzin verilmez.
+assigned by,tarafından atanan
 cannot be greater than 100,100 'den daha büyük olamaz
-"e.g. ""Build tools for builders""","örneğin """"Inşaatçılar için araçlar inşa"
+"e.g. ""Build tools for builders""","örneğin """"İnşaatçılar için inşaat araçları"
 "e.g. ""MC""","örneğin ""MC """
-"e.g. ""My Company LLC""","örneğin ""Benim Company LLC """
+"e.g. ""My Company LLC""","Örneğin ""Benim Şirketim LLC """
 e.g. 5,örneğin 5
-"e.g. Bank, Cash, Credit Card","örn: Banka, Nakit, Kredi Kartı"
-"e.g. Kg, Unit, Nos, m","örneğin Kg, Birimi, Nos, m"
-e.g. VAT,örneğin KDV
-eg. Cheque Number,örn. Çek Numarası
-example: Next Day Shipping,örnek: Next Day Shipping
+"e.g. Bank, Cash, Credit Card","Örneğin: Banka, Nakit, Kredi Kartı"
+"e.g. Kg, Unit, Nos, m","Örneğin Kg, Birimi, No, m"
+e.g. VAT,Örneğin KDV
+eg. Cheque Number,Örneğin Çek Numarası
+example: Next Day Shipping,Örnek: Bir sonraki gün sevkiyat
 lft,lft
 old_parent,old_parent
 rgt,rgt
 subject,konu
 to,(hesaba)
-website page link,website page link
-{0} '{1}' not in Fiscal Year {2},{0} '{1}' değil Mali Yılı {2}
+website page link,web sayfa linki
+{0} '{1}' not in Fiscal Year {2},{0} '{1}' mali yıl {2}'de değil
 {0} Credit limit {0} crossed,{0} Kredi limiti {0} geçti
-{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} öğesi için gerekli Seri Numaraları {0}. Sadece {0} sağlanmaktadır.
-{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} Hesabı için bütçe {1} Maliyet Merkezi karşı {2} {3} tarafından aşacaktır
+{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} ürünü için {0} seri numarası gerekir Yalnızca {0} verilmiştir.
+{0} budget for Account {1} against Cost Center {2} will exceed by {3},Maliyet Merkezi {2}'ye karşı {1} hesabı için {0} bütçesi {3} ile aşılmıştır.
 {0} can not be negative,{0} negatif olamaz
 {0} created,{0} oluşturuldu
-{0} does not belong to Company {1},{0} Şirket'e ait olmayan {1}
-{0} entered twice in Item Tax,{0} Ürün Vergi iki kez girdi
-{0} is an invalid email address in 'Notification Email Address',{0} 'Bildirim E-posta Adresi' Geçersiz bir e-posta adresi
+{0} does not belong to Company {1},{0} Şirket {1}E ait değildir
+{0} entered twice in Item Tax,{0} Ürün Vergisine iki kez girildi
+{0} is an invalid email address in 'Notification Email Address',{0} 'Bildirim E posta' adresinde geçersiz bir e-posta adresi
 {0} is mandatory,{0} zorunludur
-{0} is mandatory for Item {1},{0} Ürün için zorunludur {1}
-{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} zorunludur. Belki Döviz rekor {2} ile {1} için yaratılmış değildir.
-{0} is not a stock Item,"{0}, bir hisse senedi değil Öğe"
-{0} is not a valid Batch Number for Item {1},{0} Ürün için geçerli bir parti numarası değil {1}
-{0} is not a valid Leave Approver. Removing row #{1}.,{0} geçerli bir ara Onaylayan değildir. Çıkarma satır # {1}.
-{0} is not a valid email id,{0} geçerli bir e-posta id değil
-{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} şimdi varsayılan Mali Yılı. Etkili olması değişim için tarayıcınızı yenileyin.
+{0} is mandatory for Item {1},{0} Ürün {1} için zorunludur 
+{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} zorunludur. {1} ve {2} için Döviz kaydı oluşturulmayabilir.
+{0} is not a stock Item,"{0}, bir stok ürünü değildir."
+{0} is not a valid Batch Number for Item {1},{0} Ürün {1} için geçerli bir parti numarası değildir
+{0} is not a valid Leave Approver. Removing row #{1}.,{0} geçerli bir İzin Onaylayıı değildir. Satır # {1} kaldırılıyor.
+{0} is not a valid email id,{0} geçerli bir e-posta id değildir
+{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} varsayılan Mali Yıldır. Değiştirmek için tarayıcınızı yenileyiniz
 {0} is required,{0} gereklidir
-{0} must be a Purchased or Sub-Contracted Item in row {1},{0} aralıksız bir satın veya Alt-Sözleşmeli Ürün olmalı {1}
-{0} must be reduced by {1} or you should increase overflow tolerance,{0} {1} azaltılabilir olmalıdır ya taşma toleransını artırmak gerekir
-{0} must have role 'Leave Approver',{0} rol 'bırak Approver' olmalı
-{0} valid serial nos for Item {1},Ürün için {0} geçerli bir seri no {1}
-{0} {1} against Bill {2} dated {3},{0} {1} Bill karşı {2} tarihli {3}
-{0} {1} against Invoice {2},{0} {1} Faturaya karşı {2}
-{0} {1} has already been submitted,{0} {1} zaten gönderildi
-{0} {1} has been modified. Please refresh.,"{0}, {1} modifiye edilmiştir. Lütfen yenileyin."
-{0} {1} is not submitted,{0} {1} teslim edilmez
-{0} {1} must be submitted,{0} {1} sunulmalıdır
-{0} {1} not in any Fiscal Year,{0} {1} hiçbir Mali Yılı
-{0} {1} status is 'Stopped',{0} {1} status 'Durduruldu' olduğunu
+{0} must be a Purchased or Sub-Contracted Item in row {1},{0} satır {1} de Alınan veya Taşerona verilen bir Ürün olmalıdır.
+{0} must be reduced by {1} or you should increase overflow tolerance,{0} {1} tarafından azaltılabilir veya artma toleransını artırabilirsiniz
+{0} must have role 'Leave Approver',{0} 'İzin onaylayıcı' rolüne sahip olmalıdır
+{0} valid serial nos for Item {1},Ürün {1} için {0} seri numaraları
+{0} {1} against Bill {2} dated {3},{3} tarihli Fatura  {2} karşılığı {0} {1}
+{0} {1} against Invoice {2},Faturaya {2}'ye karşı {0} {1}
+{0} {1} has already been submitted,{0} {1} zaten Gönderildi
+{0} {1} has been modified. Please refresh.,"{0}, {1} düzenlenmiştir. Lütfen yenileyin."
+{0} {1} is not submitted,{0} {1} teslim edilmedi
+{0} {1} must be submitted,{0} {1} teslim edilmelidir
+{0} {1} not in any Fiscal Year,{0} {1} Mali Yıllardan birinde değil
+{0} {1} status is 'Stopped',{0} {1} durumu Durduruldu
 {0} {1} status is Stopped,{0} {1} durumu Durduruldu
-{0} {1} status is Unstopped,{0} {1} durumu Unstopped olduğunu
-{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Maliyet Merkezi Ürün için zorunludur {2}
+{0} {1} status is Unstopped,{0} {1} durumu Durdurulma iptal edildi
+{0} {1}: Cost Center is mandatory for Item {2},Ürün{2} için {0} {1}: Maliyert Merkezi zorunludur
 {0}: {1} not found in Invoice Details table,{0}: {1} Fatura Ayrıntıları tablosunda bulunamadı
