diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index 98e1663..025c8b7 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -1153,7 +1153,7 @@
 "In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",V prípade viacvrstvového programu budú zákazníci automaticky priradení príslušnému vrstvu podľa ich vynaložených prostriedkov,
 Inactive,neaktívne,
 Incentives,Pobídky,
-Include Default Book Entries,Zahrnúť predvolené položky knihy,
+Include Default FB Entries,Zahrnúť predvolené položky knihy,
 Include Exploded Items,Zahrňte explodované položky,
 Include POS Transactions,Zahrňte POS transakcie,
 Include UOM,Zahrňte UOM,
