diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index 025c8b7..e3323dd 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -2273,7 +2273,6 @@
 Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Riadok {0}: V Dane z obratu a poplatkoch nastavte prosím na dôvod oslobodenia od dane,
 Row {0}: Please set the Mode of Payment in Payment Schedule,Riadok {0}: Nastavte si spôsob platby v pláne platieb,
 Row {0}: Please set the correct code on Mode of Payment {1},Riadok {0}: Nastavte správny kód v platobnom režime {1},
-Row {0}: Qty is mandatory,Row {0}: Množství je povinný,
 Row {0}: Quality Inspection rejected for item {1},Riadok {0}: Kontrola kvality zamietnutá pre položku {1},
 Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný,
 Row {0}: select the workstation against the operation {1},Riadok {0}: vyberte pracovnú stanicu proti operácii {1},
@@ -3461,7 +3460,6 @@
 "It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Zdá sa, že existuje problém s konfiguráciou pásma servera. V prípade zlyhania bude suma vrátená na váš účet.",
 Item Reported,Položka bola nahlásená,
 Item listing removed,Zoznam položiek bol odstránený,
-Item quantity can not be zero,Množstvo položky nemôže byť nula,
 Item taxes updated,Dane z tovaru boli aktualizované,
 Item {0}: {1} qty produced. ,Položka {0}: {1} vyprodukované množstvo.,
 Joining Date can not be greater than Leaving Date,Dátum vstupu nemôže byť väčší ako dátum odchodu,
@@ -3633,6 +3631,7 @@
 Row #{0}: Cost Center {1} does not belong to company {2},Riadok # {0}: Nákladové stredisko {1} nepatrí spoločnosti {2},
 Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Riadok # {0}: Operácia {1} nie je dokončená pre {2} množstvo hotového tovaru v objednávke {3}. Aktualizujte prevádzkový stav prostredníctvom Job Card {4}.,
 Row #{0}: Payment document is required to complete the transaction,Riadok # {0}: Na dokončenie transakcie je potrebný platobný doklad,
+Row #{0}: Quantity for Item {1} cannot be zero.,Riadok # {0}: Množstvo položky {1} nemôže byť nula.,
 Row #{0}: Serial No {1} does not belong to Batch {2},Riadok # {0}: Poradové číslo {1} nepatrí do šarže {2},
 Row #{0}: Service End Date cannot be before Invoice Posting Date,Riadok # {0}: Dátum ukončenia služby nemôže byť pred dátumom zaúčtovania faktúry,
 Row #{0}: Service Start Date cannot be greater than Service End Date,Riadok # {0}: Dátum začatia služby nemôže byť väčší ako dátum ukončenia služby,
