diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index 587450e..f48027b 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -23,6 +23,9 @@
 A question must have more than one options,Otázka musí mať viac ako jednu možnosť,
 A qustion must have at least one correct options,Spálenie musí mať aspoň jednu správnu voľbu,
 A {0} exists between {1} and {2} (,A {0} existuje medzi {1} a {2} (,
+A4,A4,
+API Endpoint,Koncový bod rozhrania API,
+API Key,Kľúč API,
 Abbr can not be blank or space,Skrátená nemôže byť prázdne alebo priestor,
 Abbreviation already used for another company,Skratka už použitý pre inú spoločnosť,
 Abbreviation cannot have more than 5 characters,Skratka nesmie mať viac ako 5 znakov,
@@ -36,6 +39,7 @@
 Academic Year,Akademický rok,
 Academic Year: ,Akademický rok:,
 Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamietnuté množstvo sa musí rovnať Prijatému množstvu pre položku {0},
+Access Token,Prístupový token,
 Accessable Value,Prístupná hodnota,
 Account,účet,
 Account Number,Číslo účtu,
@@ -74,10 +78,12 @@
 Accounting Ledger,Účtovné Ledger,
 Accounting journal entries.,Zápisy v účetním deníku.,
 Accounts,účty,
+Accounts Manager,Manažér účtov,
 Accounts Payable,Účty za úplatu,
 Accounts Payable Summary,Splatné účty Shrnutí,
 Accounts Receivable,Pohledávky,
 Accounts Receivable Summary,Pohledávky Shrnutí,
+Accounts User,Uživatel Účtů,
 Accounts table cannot be blank.,Účty tabuľka nemôže byť prázdne.,
 Accrual Journal Entry for salaries from {0} to {1},Záznam o účtovaní časového rozlíšenia pre platy od {0} do {1},
 Accumulated Depreciation,oprávky,
@@ -196,10 +202,12 @@
 Allocated Amount,Přidělené sumy,
 Allocated Leaves,Pridelené listy,
 Allocating leaves...,Prideľovanie listov ...,
+Allow Delete,Povolit mazání,
 Already record exists for the item {0},Už existuje záznam pre položku {0},
 "Already set default in pos profile {0} for user {1}, kindly disabled default",Už bolo nastavené predvolené nastavenie profilu {0} pre používateľa {1},
 Alternate Item,Alternatívna položka,
 Alternative item must not be same as item code,Alternatívna položka nesmie byť rovnaká ako kód položky,
+Amended From,Platném znění,
 Amount,Částka,
 Amount After Depreciation,Suma po odpisoch,
 Amount of Integrated Tax,Výška integrovanej dane,
@@ -225,6 +233,7 @@
 Another Sales Person {0} exists with the same Employee id,Ďalšia predaja osoba {0} existuje s rovnakým id zamestnanca,
 Antibiotic,antibiotikum,
 Apparel & Accessories,Oblečení a doplňky,
+Applicable For,Použitelné pro,
 "Applicable if the company is SpA, SApA or SRL","Uplatniteľné, ak je spoločnosť SpA, SApA alebo SRL",
 Applicable if the company is a limited liability company,"Uplatniteľné, ak je spoločnosť spoločnosť s ručením obmedzeným",
 Applicable if the company is an Individual or a Proprietorship,"Uplatniteľné, ak je spoločnosť fyzická osoba alebo vlastníčka",
@@ -243,6 +252,7 @@
 Appointments and Patient Encounters,Schôdzky a stretnutia s pacientmi,
 Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období,
 Apprentice,učeň,
+Approval Status,Stav schválení,
 Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto""",
 Approve,schvaľovať,
 Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na,
@@ -283,6 +293,7 @@
 Assets,Aktíva,
 Assign,Priradiť,
 Assign Salary Structure,Priraďte štruktúru platu,
+Assign To,Priradiť (komu),
 Assign to Employees,Priradenie zamestnancom,
 Assigning Structures...,Priradenie štruktúr ...,
 Associate,spolupracovník,
@@ -291,6 +302,7 @@
 Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena,
 Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný,
 Attach Logo,Pripojiť logo,
+Attachment,Príloha,
 Attachments,prílohy,
 Attendance,Účast,
 Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná,
@@ -304,8 +316,10 @@
 Attendance not submitted for {0} as {1} on leave.,Účasť sa nepodala za {0} ako {1} v dovolenke.,
 Attribute table is mandatory,Atribút tabuľka je povinné,
 Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke,
+Author,autor,
 Authorized Signatory,Prokurista,
 Auto Material Requests Generated,Žiadosti Auto materiál vygenerovaný,
+Auto Repeat,Automatické opakovanie,
 Auto repeat document updated,Dokument bol aktualizovaný automaticky,
 Automotive,Automobilový,
 Available,K dispozici,
@@ -358,6 +372,7 @@
 Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1},
 Barcode {0} is not a valid {1} code,Čiarový kód {0} nie je platný {1} kód,
 Base,Základ,
+Base URL,Základná adresa URL,
 Based On,Založené na,
 Based On Payment Terms,Na základe platobných podmienok,
 Basic,základné,
@@ -373,6 +388,7 @@
 Batch: ,šarže:,
 Batches,Šarže,
 Become a Seller,Staňte sa predajcom,
+Beginner,začiatočník,
 Bill,Účtenka,
 Bill Date,Bill Datum,
 Bill No,Bill No,
@@ -493,6 +509,8 @@
 Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního,
 Cashier Closing,Uzávierka pokladníka,
 Casual Leave,Bežná priepustka,
+Category,Kategória,
+Category Name,Názov kategórie,
 Caution,pozor,
 Central Tax,Centrálna daň,
 Certification,osvedčenie,
@@ -532,6 +550,9 @@
 Clearance Date,Výprodej Datum,
 Clearance Date not mentioned,Výprodej Datum není uvedeno,
 Clearance Date updated,Svetlá Dátum aktualizované,
+Client,Klient,
+Client ID,ID klienta,
+Client Secret,Klientské tajomstvo,
 Clinical Procedure,Klinický postup,
 Clinical Procedure Template,Šablóna klinického postupu,
 Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.,
@@ -544,7 +565,9 @@
 Closing (Opening + Total),Uzávierka (otvorenie + celkom),
 Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu zodpovednosti / Equity,
 Closing Balance,Konečný zostatok,
+Code,kód,
 Collapse All,Zbaliť všetko,
+Color,farba,
 Colour,farba,
 Combined invoice portion must equal 100%,Kombinovaná časť faktúry sa musí rovnať 100%,
 Commercial,Obchodné,
@@ -569,6 +592,7 @@
 Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby""",
 Completion Date,Dokončení Datum,
 Computer,Počítač,
+Condition,podmienka,
 Configure,konfigurácia,
 Configure {0},Konfigurovať {0},
 Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.,
@@ -585,9 +609,13 @@
 Consumed Amount,Spotřebovaném množství,
 Consumed Qty,Spotřeba Množství,
 Consumer Products,Zákaznícke produkty,
+Contact,Kontakt,
+Contact Details,Kontaktné údaje,
 Contact Number,Kontaktné číslo,
 Contact Us,Kontaktuj nás,
+Content,obsah,
 Content Masters,Obsahové mastery,
+Content Type,Typ obsahu,
 Continue Configuration,Pokračovať v konfigurácii,
 Contract,zmluva,
 Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování,
@@ -676,6 +704,7 @@
 "Create and manage daily, weekly and monthly email digests.","Tvorba a správa denných, týždenných a mesačných emailových spravodajcov",
 Create customer quotes,Vytvoriť zákaznícke ponuky,
 Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.,
+Created By,Vytvorené (kým),
 Created {0} scorecards for {1} between: ,Vytvorili {0} scorecards pre {1} medzi:,
 Creating Company and Importing Chart of Accounts,Založenie spoločnosti a importná účtovná osnova,
 Creating Fees,Vytváranie poplatkov,
@@ -714,6 +743,8 @@
 Current Liabilities,Krátkodobé závazky,
 Current Qty,Aktuálne Množstvo,
 Current invoice {0} is missing,Aktuálna faktúra {0} chýba,
+Custom HTML,Vlastné HTML,
+Custom?,Prispôsobené?,
 Customer,zákazník,
 Customer Addresses And Contacts,Adresy zákazníkov a kontakty,
 Customer Contact,Zákaznícky kontakt,
@@ -741,6 +772,7 @@
 Data Import and Export,Import dát a export,
 Data Import and Settings,Import a nastavenie údajov,
 Database of potential customers.,Databáze potenciálních zákazníků.,
+Date Format,Formát dátumu,
 Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování",
 Date is repeated,Dátum sa opakuje,
 Date of Birth,Dátum narodenia,
@@ -749,6 +781,8 @@
 Date of Joining,Datum přistoupení,
 Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození,
 Date of Transaction,Dátum transakcie,
+Datetime,Datum a čas,
+Day,deň,
 Debit,Debet,
 Debit ({0}),Debet ({0}),
 Debit A/C Number,Číslo debetnej platby,
@@ -766,6 +800,7 @@
 Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny,
 Default BOM for {0} not found,Predvolené BOM pre {0} nebol nájdený,
 Default BOM not found for Item {0} and Project {1},Predvolený kusovník sa nenašiel pre položku {0} a projekt {1},
+Default Letter Head,Predvolená tlačová hlavička,
 Default Tax Template,Štandardná daňová šablóna,
 Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Východzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM.",
 Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Východzí merná jednotka varianty &#39;{0}&#39; musí byť rovnaký ako v Template &#39;{1}&#39;,
@@ -773,6 +808,7 @@
 Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.,
 Default tax templates for sales and purchase are created.,Predvolené daňové šablóny pre predaj a nákup sú vytvorené.,
 Default warehouse is required for selected item,Predvolené sklad je vyžadované pre vybraná položka,
+Defaults,predvolené,
 Defense,obrana,
 Define Project type.,Definujte typ projektu.,
 Define budget for a financial year.,Definovať rozpočet pre finančný rok.,
@@ -824,6 +860,7 @@
 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ůzné UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných.",
 Direct Expenses,Priame náklady,
 Direct Income,Priame príjmy,
+Disable,Vypnúť,
 Disabled template must not be default template,Bezbariérový šablóna nesmie byť predvolenú šablónu,
 Disburse Loan,Vyplatiť pôžičku,
 Disbursed,vyplatená,
@@ -848,9 +885,11 @@
 Doc Name,Doc Name,
 Doc Type,DokTyp,
 Docs Search,Vyhľadávanie dokumentov,
+Document Name,Názov dokumentu,
 Document Status,Stav dokumentu,
 Document Type,typ dokumentu,
 Documentation,dokumentácia,
+Domain,doména,
 Domains,domény,
 Done,hotový,
 Donor,darcu,
@@ -890,9 +929,13 @@
 Electronic Equipments,elektronické zariadenia,
 Electronics,elektronika,
 Eligible ITC,Oprávnené ITC,
+Email Account,E-mailový účet,
+Email Address,Emailová adresa,
 "Email Address must be unique, already exists for {0}","E-mailová adresa musí byť jedinečná, už existuje pre {0}",
 Email Digest: ,E-mail Digest:,
 Email Reminders will be sent to all parties with email contacts,Pripomienky e-mailu budú zaslané všetkým stranám s e-mailovými kontaktmi,
+Email Sent,Email odoslaný,
+Email Template,Šablóna e-mailu,
 Email not found in default contact,E-mail sa v predvolenom kontakte nenachádza,
 Email sent to supplier {0},E-mail zaslaný na dodávateľa {0},
 Email sent to {0},Email odoslaný na {0},
@@ -918,7 +961,9 @@
 Employee {0} is on Leave on {1},Zamestnanec {0} je zapnutý Opustiť dňa {1},
 Employee {0} of grade {1} have no default leave policy,Zamestnanec {0} v platovej triede {1} nemá žiadne predvolené pravidlá pre dovolenku,
 Employee {0} on Half day on {1},Zamestnancov {0} o pol dňa na {1},
+Enable,Zapnout,
 Enable / disable currencies.,Povolit / zakázat měny.,
+Enabled,Zapnuto,
 "Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolenie &quot;použitia na nákupného košíka&quot;, ako je povolené Nákupný košík a tam by mala byť aspoň jedna daňové pravidlá pre Košík",
 End Date,Datum ukončení,
 End Date can not be less than Start Date,Dátum ukončenia nemôže byť menší ako dátum začiatku,
@@ -943,6 +988,7 @@
 Entertainment & Leisure,Entertainment & Leisure,
 Entertainment Expenses,Výdaje na reprezentaci,
 Equity,Hodnota majetku,
+Error Log,error Log,
 Error evaluating the criteria formula,Chyba pri hodnotení kritéria kritérií,
 Error in formula or condition: {0},Chyba vo vzorci alebo stave: {0},
 Error while processing deferred accounting for {0},Chyba pri spracovaní odloženého účtovania pre {0},
@@ -950,6 +996,7 @@
 Estimated Cost,Odhadované náklady,
 Evaluation,ohodnotenie,
 "Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:",
+Event,udalosť,
 Event Location,Umiestnenie udalosti,
 Event Name,Názov udalosti,
 Exchange Gain/Loss,Exchange zisk / strata,
@@ -984,6 +1031,7 @@
 Export E-Invoices,Export elektronických faktúr,
 Extra Large,Extra veľké,
 Extra Small,Extra Malé,
+Fail,zlyhať,
 Failed,Nepodarilo,
 Failed to create website,Nepodarilo sa vytvoriť webové stránky,
 Failed to install presets,Nepodarilo sa nainštalovať predvoľby,
@@ -991,6 +1039,7 @@
 Failed to setup company,Nepodarilo sa nastaviť spoločnosť,
 Failed to setup defaults,Nepodarilo sa nastaviť predvolené hodnoty,
 Failed to setup post company fixtures,Nepodarilo sa nastaviť doplnky firmy,
+Fax,fax,
 Fee,poplatok,
 Fee Created,Poplatok vytvorený,
 Fee Creation Failed,Vytvorenie poplatku zlyhalo,
@@ -998,10 +1047,14 @@
 Fee Records Created - {0},Fee Records Vytvoril - {0},
 Feedback,Zpětná vazba,
 Fees,poplatky,
+Female,Žena,
 Fetch Data,Načítať údaje,
 Fetch Subscription Updates,Načítať aktualizácie odberov,
 Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin),
 Fetching records......,Prebieha načítavanie záznamov ......,
+Field Name,Názov poľa,
+Fieldname,Názov poľa,
+Fields,Pole,
 Fill the form and save it,Vyplňte formulář a uložte jej,
 Filter Employees By (Optional),Filtrovať zamestnancov podľa (voliteľné),
 "Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Riadok č. Filtra: {0}: Názov poľa <b>{1}</b> musí byť typu „Link“ alebo „Table MultiSelect“,
@@ -1017,6 +1070,7 @@
 Finished Goods,Hotové zboží,
 Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba,
 Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Množstvo hotového produktu <b>{0}</b> a Množstvo <b>{1}</b> sa nemôžu líšiť,
+First Name,Meno,
 "Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiškálny režim je povinný, láskavo nastavte fiškálny režim v spoločnosti {0}",
 Fiscal Year,Fiškálny rok,
 Fiscal Year End Date should be one year after Fiscal Year Start Date,Dátum konca fiškálneho roka by mal byť jeden rok po dátume začiatku fiškálneho roka,
@@ -1054,6 +1108,7 @@
 Forum Activity,Aktivita fóra,
 Free item code is not selected,Zadarmo kód položky nie je vybratý,
 Freight and Forwarding Charges,Nákladní a Spediční Poplatky,
+Frequency,Frekvencia,
 Friday,Pátek,
 From,Od,
 From Address 1,Z adresy 1,
@@ -1085,6 +1140,7 @@
 Fuel Price,palivo Cena,
 Fuel Qty,palivo Množstvo,
 Fulfillment,splnenie,
+Full,plne,
 Full Name,Celé meno/názov,
 Full-time,Na plný úvazek,
 Fully Depreciated,plne odpísaný,
@@ -1118,6 +1174,7 @@
 Get customers from,Získajte zákazníkov z,
 Get from Patient Encounter,Získajte od stretnutia s pacientmi,
 Getting Started,Začíname,
+GitHub Sync ID,Identifikátor GitHub Sync,
 Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.,
 Go to the Desktop and start using ERPNext,Prejdite na plochu a začnite používať ERPNext,
 GoCardless SEPA Mandate,GoCardless SEPA mandát,
@@ -1155,12 +1212,15 @@
 Guardian2 Email ID,ID e-mailu Guardian2,
 Guardian2 Mobile No,Guardian2 Mobile Žiadne,
 Guardian2 Name,Meno Guardian2,
+Guest,Hosť,
 HR Manager,HR Manager,
 HSN,HSN,
 HSN/SAC,HSN / SAC,
+Half Day,Pol deň,
 Half Day Date is mandatory,Polovičný dátum je povinný,
 Half Day Date should be between From Date and To Date,Half Day Date by mala byť v rozmedzí od dátumu a do dnešného dňa,
 Half Day Date should be in between Work From Date and Work End Date,Polovičný dátum by mal byť medzi prácou od dátumu a dátumom ukončenia práce,
+Half Yearly,Polročne,
 Half day date should be in between from date and to date,Dátum pol dňa by mal byť medzi dňom a dňom,
 Half-Yearly,Polročne,
 Hardware,Technické vybavení,
@@ -1186,16 +1246,19 @@
 Holiday List,Dovolená Seznam,
 Hotel Rooms of type {0} are unavailable on {1},Hotel Izby typu {0} sú k dispozícii na {1},
 Hotels,hotely,
+Hourly,hodinový,
 Hours,hodiny,
 House rent paid days overlapping with {0},Nájomné za platené dni sa prekrýva s {0},
 House rented dates required for exemption calculation,Požadované dátumy pre výpočet výnimky,
 House rented dates should be atleast 15 days apart,Prenajaté rodinné domy by mali byť aspoň 15 dní od seba,
 How Pricing Rule is applied?,Jak Ceny pravidlo platí?,
 Hub Category,Kategória Hubu,
+Hub Sync ID,ID synchronizácie Hubu,
 Human Resource,Ľudské Zdroje,
 Human Resources,Lidské zdroje,
 IFSC Code,Kód IFSC,
 IGST Amount,Suma IGST,
+IP Address,IP adresa,
 ITC Available (whether in full op part),ITC k dispozícii (či už v plnej op časti),
 ITC Reversed,ITC obrátené,
 Identifying Decision Makers,Identifikácia rozhodovacích orgánov,
@@ -1206,8 +1269,11 @@
 "If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","V prípade neobmedzeného uplynutia platnosti Vernostných bodov, ponechajte dobu trvania expirácie prázdnu alebo 0.",
 "If you have any questions, please get back to us.","Ak máte akékoľvek otázky, obráťte sa na nás.",
 Ignore Existing Ordered Qty,Ignorovať existujúce objednané množstvo,
+Image,Obrázok,
+Image View,Image View,
 Import Data,Importovať údaje,
 Import Day Book Data,Importovať údaje dennej knihy,
+Import Log,Záznam importu,
 Import Master Data,Import kmeňových dát,
 Import Successfull,Import bol úspešný,
 Import in Bulk,Dovoz hromadnú,
@@ -1222,6 +1288,7 @@
 In Stock: ,Na sklade:,
 In Value,v Hodnota,
 "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 Exploded Items,Zahrňte explodované položky,
@@ -1255,9 +1322,11 @@
 Integrated Tax,Integrovaná daň,
 Inter-State Supplies,Medzištátne dodávky,
 Interest Amount,záujem Suma,
+Interests,záujmy,
 Intern,internovať,
 Internet Publishing,Internet Publishing,
 Intra-State Supplies,Vnútroštátne dodávky,
+Introduction,úvod,
 Invalid Attribute,Neplatný atribút,
 Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdnej objednávky pre vybraného zákazníka a položku,
 Invalid Company for Inter Company Transaction.,Neplatná spoločnosť pre medzipodnikové transakcie.,
@@ -1290,6 +1359,8 @@
 Inward Supplies(liable to reverse charge,Dočasné dodávky (podliehajú spätnému účtovaniu,
 Inward supplies from ISD,Dovozné zásielky z ISD,
 Inward supplies liable to reverse charge (other than 1 & 2 above),Dovozné zásielky podliehajúce preneseniu daňovej povinnosti (iné ako vyššie uvedené položky 1 a 2),
+Is Active,Je aktívny,
+Is Default,Je Výchozí,
 Is Existing Asset,Je existujúcemu aktívu,
 Is Frozen,Je Frozen,
 Is Group,Is Group,
@@ -1375,10 +1446,13 @@
 Lab Tests and Vital Signs,Laboratórne testy a vitálne znaky,
 Lab result datetime cannot be before testing datetime,Výsledok dátumu výsledku laboratória nemôže byť pred dátumom testovania,
 Lab testing datetime cannot be before collection datetime,Laboratórne testovanie dátumu nemôže byť pred dátumom zberu,
+Label,Popis,
 Laboratory,laboratórium,
+Language Name,Názov jazyka,
 Large,Veľký,
 Last Communication,Posledná komunikácia,
 Last Communication Date,Dátum poslednej komunikácie,
+Last Name,Priezvisko,
 Last Order Amount,Suma poslednej objednávky,
 Last Order Date,Posledná Dátum objednávky,
 Last Purchase Price,Posledná nákupná cena,
@@ -1418,10 +1492,13 @@
 Ledger,Účtovná kniha,
 Legal,Právne,
 Legal Expenses,Výdavky na právne služby,
+Letter Head,Záhlavie,
 Letter Heads for print templates.,Dopis hlavy na tiskových šablon.,
+Level,Úroveň,
 Liability,Odpovědnost,
 License,licencie,
 Lifecycle,Životný cyklus,
+Limit,limit,
 Limit Crossed,limit skríženými,
 Link to Material Request,Odkaz na žiadosť o materiál,
 List of all share transactions,Zoznam všetkých transakcií s akciami,
@@ -1454,11 +1531,13 @@
 Main,Hlavné,
 Maintenance,údržba,
 Maintenance Log,Denník údržby,
+Maintenance Manager,Správca údržby,
 Maintenance Schedule,Plán údržby,
 Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule""",
 Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje v porovnaní s {1},
 Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky,
 Maintenance Status has to be Cancelled or Completed to Submit,Stav údržby musí byť zrušený alebo dokončený na odoslanie,
+Maintenance User,Údržba uživatele,
 Maintenance Visit,Maintenance Visit,
 Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky,
 Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0},
@@ -1466,6 +1545,7 @@
 Make Payment,Vykonať platbu,
 Make project from a template.,Vytvorte projekt zo šablóny.,
 Making Stock Entries,Tvorba prírastkov zásob,
+Male,Muž,
 Manage Customer Group Tree.,Správa zákazníků skupiny Tree.,
 Manage Sales Partners.,Správa prodejních partnerů.,
 Manage Sales Person Tree.,Správa obchodník strom.,
@@ -1475,6 +1555,7 @@
 Manager,manažér,
 Managing Projects,Správa projektov,
 Managing Subcontracting,Správa Subdodávky,
+Mandatory,povinné,
 Mandatory field - Academic Year,Povinná oblasť - akademický rok,
 Mandatory field - Get Students From,Povinné pole - Získajte študentov z,
 Mandatory field - Program,Povinné pole - Program,
@@ -1483,6 +1564,8 @@
 Manufacturer Part Number,Typové označení,
 Manufacturing,Výroba,
 Manufacturing Quantity is mandatory,Výrobné množstvo je povinné,
+Mapping,mapovanie,
+Mapping Type,Typ mapovania,
 Mark Absent,Označiť ako neprítomný,
 Mark Attendance,Označenie účasti,
 Mark Half Day,Mark Poldenné,
@@ -1542,8 +1625,12 @@
 Merge Account,Zlúčiť účet,
 Merge with Existing Account,Zlúčiť so existujúcim účtom,
 "Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. Je Group, Root Type, Company",
+Message Examples,Příklady Zpráv,
 Message Sent,Správa bola odoslaná,
+Method,metóda,
 Middle Income,Středními příjmy,
+Middle Name,Stredné meno,
+Middle Name (Optional),Druhé meno (voliteľné),
 Min Amt can not be greater than Max Amt,Minimálny Amt nesmie byť väčší ako Max. Amt,
 Min Qty can not be greater than Max Qty,Min množstvo nemôže byť väčšie ako Max množstvo,
 Minimum Lead Age (Days),Minimálny vek vedenia (dni),
@@ -1577,6 +1664,7 @@
 Multiple default mode of payment is not allowed,Nie je povolený viacnásobný predvolený spôsob platby,
 Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Niekoľko fiškálnych rokov existujú pre dáta {0}. Prosím nastavte spoločnosť vo fiškálnom roku,
 Music,hudba,
+My Account,Môj účet,
 Name error: {0},Názov chyba: {0},
 Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi",
 Name or Email is mandatory,Meno alebo e-mail je povinné,
@@ -1687,6 +1775,7 @@
 Non Profit (beta),Neziskové (beta),
 Non-GST outward supplies,Vonkajšie dodávky mimo GST,
 Non-Group to Group,Non-skupiny k skupine,
+None,nikto,
 None of the items have any change in quantity or value.,Žiadna z týchto položiek nemá zmenu v množstve alebo hodnote.,
 Nos,Balenie,
 Not Available,Není k dispozici,
@@ -1717,6 +1806,7 @@
 Nothing to change,Nič sa nemenia,
 Notice Period,Výpovedná Lehota,
 Notify Customers via Email,Informujte zákazníkov prostredníctvom e-mailu,
+Number,číslo,
 Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervované nemôže byť väčšia ako celkový počet Odpisy,
 Number of Interaction,Počet interakcií,
 Number of Order,Číslo objednávky,
@@ -1775,6 +1865,7 @@
 Optional Holiday List not set for leave period {0},Voliteľný prázdninový zoznam nie je nastavený na obdobie dovolenky {0},
 "Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené.",
 Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.,
+Options,možnosti,
 Order Count,Počet objednávok,
 Order Entry,Zadanie objednávky,
 Order Value,Hodnota objednávky,
@@ -1787,6 +1878,7 @@
 Orders released for production.,Objednávky uvolněna pro výrobu.,
 Organization,organizácie,
 Organization Name,Názov organizácie,
+Other,Ostatní,
 Other Reports,Ostatné správy,
 "Other outward supplies(Nil rated,Exempted)","Ostatné pasívne výrobky (bez hodnotenia, oslobodené)",
 Others,Ostatní,
@@ -1820,6 +1912,7 @@
 Paid Amount cannot be greater than total negative outstanding amount {0},Zaplatená suma nemôže byť vyšší ako celkový negatívny dlžnej čiastky {0},
 Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total,
 Paid and Not Delivered,Platená a nie je doručenie,
+Parameter,Parametr,
 Parent Item {0} must not be a Stock Item,Parent Item {0} nesmie byť skladom,
 Parents Teacher Meeting Attendance,Zúčastňovanie učiteľov rodičov,
 Part-time,Part-time,
@@ -1831,6 +1924,7 @@
 Party Type and Party is mandatory for {0} account,Typ strany a strana je povinný pre účet {0},
 Party Type is mandatory,Typ strana je povinná,
 Party is mandatory,Party je povinná,
+Password,heslo,
 Password policy for Salary Slips is not set,Nie je nastavená politika hesiel pre platové pásky,
 Past Due Date,Dátum splatnosti,
 Patient,trpezlivý,
@@ -1855,7 +1949,9 @@
 Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu.",
 Payment Entry is already created,Vstup Platba je už vytvorili,
 Payment Failed. Please check your GoCardless Account for more details,Platba zlyhala. Skontrolujte svoj účet GoCardless pre viac informácií,
+Payment Gateway,Platobná brána,
 "Payment Gateway Account not created, please create one manually.","Platobná brána účet nevytvorili, prosím, vytvorte ručne.",
+Payment Gateway Name,Názov platobnej brány,
 Payment Mode,Způsob platby,
 "Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platba nie je nakonfigurovaný. Prosím skontrolujte, či je účet bol nastavený na režim platieb alebo na POS Profilu.",
 Payment Receipt Note,Doklad o zaplatení Note,
@@ -1897,8 +1993,10 @@
 Physician,lekár,
 Piecework,Úkolová práce,
 Pin Code,PIN kód,
+Pincode,Pinkód,
 Place Of Supply (State/UT),Miesto dodania (štát / UT),
 Place Order,Objednať,
+Plan Name,Názov plánu,
 Plan for maintenance visits.,Plán pro návštěvy údržby.,
 Planned Qty,Plánované Množství,
 "Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Plánované množstvo: Množstvo, pre ktoré bola zadaná pracovná objednávka, ale čaká sa na výrobu.",
@@ -1998,7 +2096,7 @@
 "Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosím, vyberte položku, kde &quot;Je skladom,&quot; je &quot;Nie&quot; a &quot;je Sales Item&quot; &quot;Áno&quot; a nie je tam žiadny iný produkt Bundle",
 Please select Maintenance Status as Completed or remove Completion Date,Vyberte Stav údržby ako Dokončené alebo Odstráňte Dátum dokončenia,
 Please select Party Type first,"Prosím, vyberte typ Party prvý",
-Please select Patient,Vyberte položku Pacient,
+Please select Patient,Vyberte pacienta,
 Please select Patient to get Lab Tests,"Ak chcete získať laboratórne testy, vyberte položku Pacient",
 Please select Posting Date before selecting Party,"Prosím, vyberte Dátum zverejnenia pred výberom Party",
 Please select Posting Date first,"Prosím, vyberte najprv Dátum zverejnenia",
@@ -2091,6 +2189,7 @@
 Point-of-Sale,Mieste predaja,
 Point-of-Sale Profile,Point-of-Sale Profil,
 Portal,portál,
+Portal Settings,Nastavenie portálu,
 Possible Supplier,možné Dodávateľ,
 Postal Expenses,Poštovní náklady,
 Posting Date,Dátum pridania,
@@ -2109,6 +2208,7 @@
 Prescriptions,predpisy,
 Present,Současnost,
 Prev,Predchádzajúce,
+Preview,Náhľad,
 Preview Salary Slip,Preview výplatnej páske,
 Previous Financial Year is not closed,Predchádzajúci finančný rok nie je uzavretý,
 Price,cena,
@@ -2130,8 +2230,10 @@
 Primary Address Details,Údaje o primárnej adrese,
 Primary Contact Details,Priame kontaktné údaje,
 Principal Amount,istina,
+Print Format,Formát tlače,
 Print IRS 1099 Forms,Tlačte formuláre IRS 1099,
 Print Report Card,Vytlačiť kartu správ,
+Print Settings,Nastavenie tlače,
 Print and Stationery,Tlač a papiernictva,
 Print settings updated in respective print format,Nastavenie tlače aktualizované v príslušnom formáte tlači,
 Print taxes with zero amount,Tlačiť dane s nulovou čiastkou,
@@ -2140,6 +2242,7 @@
 Privilege Leave,Privilege Leave,
 Probation,Skúšobná lehota,
 Probationary Period,Skúšobná doba,
+Procedure,procedúra,
 Process Day Book Data,Spracovať údaje dennej knihy,
 Process Master Data,Spracovať kmeňové dáta,
 Processing Chart of Accounts and Parties,Spracovateľská schéma účtov a strán,
@@ -2177,6 +2280,7 @@
 Projected Qty,Premietané množstvo,
 Projected Quantity Formula,Vzorec predpokladaného množstva,
 Projects,projekty,
+Property,vlastnosť,
 Property already added,Vlastnosti už boli pridané,
 Proposal Writing,Návrh Psaní,
 Proposal/Price Quote,Návrh / cenová ponuka,
@@ -2184,12 +2288,15 @@
 Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit),
 Publications,Publikácie,
 Publish Items on Website,Publikovať položky na webových stránkach,
+Published,Zverejnené,
 Publishing,Zverejnenie,
 Purchase,nákup,
 Purchase Amount,Suma nákupu,
 Purchase Date,Dátum nákupu,
 Purchase Invoice,Prijatá faktúra,
 Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána,
+Purchase Manager,Manažér nákupu,
+Purchase Master Manager,Nadriadený manažér nákupu,
 Purchase Order,Nákupná objednávka,
 Purchase Order Amount,Suma objednávky,
 Purchase Order Amount(Company Currency),Suma objednávky (mena spoločnosti),
@@ -2204,6 +2311,7 @@
 Purchase Receipt,Příjemka,
 Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena,
 Purchase Tax Template,Spotrebná daň šablóny,
+Purchase User,Nákup Uživatel,
 Purchase orders help you plan and follow up on your purchases,Objednávky pomôžu pri plánovaní a sledovaní na vaše nákupy,
 Purchasing,nákup,
 Purpose must be one of {0},Cíl musí být jedním z {0},
@@ -2234,6 +2342,7 @@
 Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 0 ° C.",
 Quantity to Produce,Množstvo na výrobu,
 Quantity to Produce can not be less than Zero,Množstvo na výrobu nesmie byť menšie ako nula,
+Query Options,Možnosti dotazu,
 Queued for replacing the BOM. It may take a few minutes.,Namiesto výmeny kusovníka. Môže to trvať niekoľko minút.,
 Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Naliehavá aktualizácia najnovšej ceny vo všetkých účtovných dokladoch. Môže to trvať niekoľko minút.,
 Quick Journal Entry,Rýchly vstup Journal,
@@ -2251,6 +2360,7 @@
 Range,rozsah,
 Rate,Sadzba,
 Rate:,rýchlosť:,
+Rating,Rating,
 Raw Material,Surovina,
 Raw Materials,Suroviny,
 Raw Materials cannot be blank.,Suroviny nemůže být prázdný.,
@@ -2272,9 +2382,11 @@
 Received Quantity,Prijaté množstvo,
 Received Stock Entries,Prijaté položky zásob,
 Receiver List is empty. Please create Receiver List,Zoznam príjemcov je prázdny. Prosím vytvorte zoznam príjemcov.,
+Recipients,príjemcovia,
 Reconcile,Zosúladiť,
 "Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď",
 Records,záznamy,
+Redirect URL,presmerovanie URL,
 Ref,Ref,
 Ref Date,Ref Dátum,
 Reference,Referencia,
@@ -2282,13 +2394,18 @@
 Reference Date,Referenčný dátum,
 Reference Doctype must be one of {0},Referenčná DOCTYPE musí byť jedným z {0},
 Reference Document,Referenčný dokument,
+Reference Document Type,Referenčná Typ dokumentu,
 Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0},
 Reference No and Reference Date is mandatory for Bank transaction,Referenčné číslo a referenčný dátum je povinný pre bankové transakcie,
 Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni",
 Reference No.,Referenčné číslo,
 Reference Number,Referenční číslo,
+Reference Owner,referenčnej Vlastník,
+Reference Type,Typ reference,
 "Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, Kód položky: {1} a zákazník: {2}",
 References,Referencie,
+Refresh Token,Obnoviť Token,
+Region,kraj,
 Register,Registrovať,
 Reject,Odmietnuť,
 Rejected,Zamítnuto,
@@ -2309,9 +2426,11 @@
 Repeat Customer Revenue,Repeat Customer Příjmy,
 Repeat Customers,Verní zákazníci,
 Replace BOM and update latest price in all BOMs,Nahraďte kusovník a aktualizujte najnovšiu cenu vo všetkých kusovníkoch,
+Replied,Odpovězeno,
 Replies,odpovede,
 Report,Report,
 Report Builder,Konfigurátor Reportu,
+Report Type,Typ výpisu,
 Report Type is mandatory,Report Type je povinné,
 Report an Issue,Nahlásiť problém,
 Reports,správy,
@@ -2347,6 +2466,7 @@
 Reserved for sub contracting,Vyhradené pre subkontraktovanie,
 Resistant,odolný,
 Resolve error and upload again.,Vyriešte chybu a odovzdajte znova.,
+Response,odpoveď,
 Responsibilities,zodpovednosť,
 Rest Of The World,Zbytek světa,
 Restart Subscription,Reštartujte odber,
@@ -2367,6 +2487,7 @@
 Reverse Journal Entry,Zadanie reverzného denníka,
 Review Invitation Sent,Recenzia pozvánky odoslaná,
 Review and Action,Preskúmanie a konanie,
+Role,Role,
 Rooms Booked,Izby boli rezervované,
 Root Company,Root Company,
 Root Type,Root Type,
@@ -2375,6 +2496,7 @@
 Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko,
 Round Off,Zaokrúhliť,
 Rounded Total,Zaoblený Total,
+Route,trasa,
 Row # {0}: ,Řádek # {0}:,
 Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí byť rovnaké, ako {1} {2}",
 Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nemožno vrátiť viac ako {1} pre bodu {2},
@@ -2477,6 +2599,8 @@
 Sales Invoice,Predajná faktúra,
 Sales Invoice {0} has already been submitted,Predajná faktúra {0} už bola odoslaná,
 Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky,
+Sales Manager,Manažér predaja,
+Sales Master Manager,Nadriadený manažér predaja,
 Sales Order,Predajné objednávky,
 Sales Order Item,Položka predajnej objednávky,
 Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0},
@@ -2492,12 +2616,15 @@
 Sales Summary,Súhrn predajov,
 Sales Tax Template,Daň z predaja Template,
 Sales Team,Predajný tím,
+Sales User,Používateľ predaja,
 Sales and Returns,Predaje a vrátenia,
 Sales campaigns.,Predajné kampane,
 Sales orders are not available for production,Príkazy na predaj nie sú k dispozícii na výrobu,
+Salutation,Oslovenie,
 Same Company is entered more than once,Rovnaký Spoločnosť je zapísaná viac ako raz,
 Same item cannot be entered multiple times.,Rovnakú položku nemožno zadávať viackrát.,
 Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát,
+Sample,vzorka,
 Sample Collection,Zbierka vzoriek,
 Sample quantity {0} cannot be more than received quantity {1},Množstvo vzorky {0} nemôže byť väčšie ako prijaté množstvo {1},
 Sanctioned,Sankcionované,
@@ -2507,6 +2634,7 @@
 Saturday,sobota,
 Saved,Uložené,
 Saving {0},Uloženie {0},
+Scan Barcode,Naskenujte čiarový kód,
 Schedule,plán,
 Schedule Admission,Plán prijatia,
 Schedule Course,rozvrh,
@@ -2526,6 +2654,7 @@
 Search Sub Assemblies,Vyhľadávanie Sub Assemblies,
 "Search by item code, serial number, batch no or barcode","Vyhľadajte podľa kódu položky, sériového čísla, šarže alebo čiarového kódu",
 "Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd.",
+Secret Key,Tajný kľúč,
 Secretary,sekretárka,
 Section Code,Kód sekcie,
 Secured Loans,Zajištěné úvěry,
@@ -2550,6 +2679,7 @@
 Select Customer,Vyberte zákazníka,
 Select Days,Vyberte dni,
 Select Default Supplier,Vybrať Predvolené Dodávateľ,
+Select DocType,Zvoľte DocType,
 Select Fiscal Year...,Vyberte fiškálny rok ...,
 Select Item (optional),Vyberte položku (voliteľné),
 Select Items based on Delivery Date,Vyberte položku podľa dátumu doručenia,
@@ -2590,6 +2720,7 @@
 Send Supplier Emails,Poslať Dodávateľ e-maily,
 Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům,
 Sensitivity,citlivosť,
+Sent,odoslané,
 Serial #,Serial #,
 Serial No and Batch,Sériové číslo a Dávka,
 Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0},
@@ -2674,6 +2805,7 @@
 Shopify Supplier,Nakupujte dodávateľa,
 Shopping Cart,Nákupný košík,
 Shopping Cart Settings,Nastavenie Nákupného košíka,
+Short Name,Skrátené meno,
 Shortage Qty,Nedostatek Množství,
 Show Completed,Zobraziť dokončené,
 Show Cumulative Amount,Zobraziť kumulatívnu čiastku,
@@ -2696,6 +2828,7 @@
 Single unit of an Item.,Single jednotka položky.,
 "Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskočiť Ponechať alokáciu pre nasledujúcich zamestnancov, pretože záznamy proti alokácii už existujú proti nim. {0}",
 "Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Vynechanie priradenia štruktúry miezd pre nasledujúcich zamestnancov, pretože záznamy o priradení mzdovej štruktúry už proti nim existujú. {0}",
+Slideshow,Premietanie obrázkov na webstránke,
 Slots for {0} are not added to the schedule,Sloty pre {0} nie sú pridané do plánu,
 Small,malý,
 Soap & Detergent,Soap & Detergent,
@@ -2709,6 +2842,7 @@
 Something went wrong!,Niečo sa pokazilo!,
 "Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit",
 Source,zdroj,
+Source Name,Názov zdroja,
 Source Warehouse,Zdroj Warehouse,
 Source and Target Location cannot be same,Zdroj a cieľové umiestnenie nemôžu byť rovnaké,
 Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0},
@@ -2721,6 +2855,7 @@
 Split Issue,Split Issue,
 Sports,Sportovní,
 Staffing Plan {0} already exist for designation {1},Personálny plán {0} už existuje pre označenie {1},
+Standard,Štandard,
 Standard Buying,Štandardný nákup,
 Standard Selling,Štandardný predaj,
 Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.,
@@ -2813,12 +2948,14 @@
 Subscription Management,Správa predplatného,
 Subscriptions,odbery,
 Subtotal,medzisúčet,
+Successful,Úspešný,
 Successfully Reconciled,Úspešne zinventarizované,
 Successfully Set Supplier,Úspešne nastaviť dodávateľa,
 Successfully created payment entries,Úspešne vytvorené položky platieb,
 Successfully deleted all transactions related to this company!,Úspešne vypúšťa všetky transakcie súvisiace s týmto spoločnosti!,
 Sum of Scores of Assessment Criteria needs to be {0}.,Súčet skóre hodnotiacich kritérií musí byť {0}.,
 Sum of points for all goals should be 100. It is {0},Súčet bodov za všetkých cieľov by malo byť 100. Je {0},
+Summary,zhrnutie,
 Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam,
 Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam,
 Sunday,nedeľa,
@@ -2855,8 +2992,10 @@
 Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizácia bola dočasne zakázaná, pretože boli prekročené maximálne počet opakovaní",
 Syntax error in condition: {0},Chyba syntaxe v stave: {0},
 Syntax error in formula or condition: {0},syntaktická chyba vo vzorci alebo stave: {0},
+System Manager,Správca systému,
 TDS Rate %,TDS%,
 Tap items to add them here,Poklepte na položky a pridajte ich sem,
+Target,Cíl,
 Target ({}),Zacielenie ({}),
 Target On,Target On,
 Target Warehouse,Target Warehouse,
@@ -2866,6 +3005,7 @@
 Tasks have been created for managing the {0} disease (on row {1}),Boli vytvorené úlohy na správu ochorenia {0} (na riadku {1}),
 Tax,daň,
 Tax Assets,Daňové aktíva,
+Tax Category,Daňová kategória,
 Tax Category for overriding tax rates.,Daňová kategória pre hlavné daňové sadzby.,
 "Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategória bola zmenená na &quot;Celkom&quot;, pretože všetky položky sú položky, ktoré nie sú na sklade",
 Tax ID,DIČ,
@@ -2885,6 +3025,7 @@
 Telecommunications,Telekomunikace,
 Telephone Expenses,Telefonní Náklady,
 Television,Televize,
+Template Name,Názov šablóny,
 Template of terms or contract.,Šablona podmínek nebo smlouvy.,
 Templates of supplier scorecard criteria.,Šablóny kritérií kritérií pre dodávateľa.,
 Templates of supplier scorecard variables.,Šablóny premenných ukazovateľa skóre dodávateľa.,
@@ -2987,7 +3128,7 @@
 To Address 2,Na adresu 2,
 To Bill,K fakturácii,
 To Date,To Date,
-To Date cannot be before From Date,Dátum nemôže byť pred dátumom,
+To Date cannot be before From Date,Dátum DO nemôže byť skôr ako dátum OD,
 To Date cannot be less than From Date,Dátumu nemôže byť menšia ako od dátumu,
 To Date must be greater than From Date,Dátum musí byť väčší ako od dátumu,
 To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}",
@@ -3078,6 +3219,7 @@
 Total(Amt),Total (Amt),
 Total(Qty),Total (ks),
 Traceability,sledovateľnosť,
+Traceback,Vystopovať,
 Track Leads by Lead Source.,Track Leads by Lead Zdroj.,
 Training,výcvik,
 Training Event,Training Event,
@@ -3120,6 +3262,7 @@
 UOM,UOM,
 UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0},
 UOM coversion factor required for UOM: {0} in Item: {1},Koeficient prepočtu MJ je potrebný k MJ: {0} v bode: {1},
+URL,URL,
 Unable to find DocType {0},Nepodarilo sa nájsť DocType {0},
 Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nepodarilo sa nájsť kurz {0} až {1} pre kľúčový dátum {2}. Ručne vytvorte záznam o menovej karte,
 Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nepodarilo sa nájsť skóre od {0}. Musíte mať stály počet bodov od 0 do 100,
@@ -3134,6 +3277,7 @@
 Unpaid,Nezaplacený,
 Unsecured Loans,Nezajištěných úvěrů,
 Unsubscribe from this Email Digest,Odhlásiť sa z tohto Email Digest,
+Unsubscribed,Odhlášen z odběru,
 Until,Dokud,
 Unverified Webhook Data,Neoverené údaje Webhook,
 Update Account Name / Number,Aktualizovať názov / číslo účtu,
@@ -3152,9 +3296,11 @@
 Updating Variants...,Aktualizácia variantov ...,
 Upload your letter head and logo. (you can edit them later).,Nahrajte svoju hlavičku a logo pre dokumenty. (Môžete ich upravovať neskôr.),
 Upper Income,Horní příjmů,
+Use Sandbox,použitie Sandbox,
 Used Leaves,Použité listy,
 User,užívateľ,
 User Forum,user Forum,
+User ID,User ID,
 User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0},
 User Remark,Uživatel Poznámka,
 User has not applied rule on the invoice {0},Používateľ na faktúru neuplatnil pravidlo {0},
@@ -3171,6 +3317,7 @@
 Valid from and valid upto fields are mandatory for the cumulative,Pre kumulatívne sú povinné a platné až polia,
 Valid from date must be less than valid upto date,Platné od dátumu musí byť kratšie ako platné do dátumu,
 Valid till date cannot be before transaction date,Platné do dátumu nemôže byť pred dátumom transakcie,
+Validity,platnosť,
 Validity period of this quotation has ended.,Platnosť tejto ponuky sa skončila.,
 Valuation Rate,Ocenění Rate,
 Valuation Rate is mandatory if Opening Stock entered,"Ocenenie Rate je povinné, ak zadaná počiatočným stavom zásob",
@@ -3243,9 +3390,14 @@
 Website Image should be a public file or website URL,Webové stránky Image by mala byť verejná súboru alebo webovej stránky URL,
 Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť,
 Website Listing,Výpis webových stránok,
+Website Manager,Správce webu,
+Website Settings,Nastavení www stránky,
 Wednesday,streda,
+Week,týždeň,
+Weekdays,Dni v týždni,
 Weekly,Týdenní,
 "Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnosť je uvedená, \n uveďte prosím aj ""váhu MJ""",
+Welcome email sent,Uvítací email odeslán,
 Welcome to ERPNext,Vitajte v ERPNext,
 What do you need help with?,S čím potrebujete pomôcť?,
 What does it do?,Čím sa zaoberá?,
@@ -3319,6 +3471,7 @@
 "e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, kreditné karty",
 hidden,skrytý,
 modified,modifikovaný,
+old_parent,old_parent,
 on,Kdy,
 {0} '{1}' is disabled,{0} '{1}' je vypnuté,
 {0} '{1}' not in Fiscal Year {2},{0} '{1}' nie je vo fiškálnom roku {2},
@@ -3342,7 +3495,7 @@
 {0} applicable after {1} working days,{0} uplatniteľné po {1} pracovných dňoch,
 {0} asset cannot be transferred,{0} pohľadávku nemôže byť prevedená,
 {0} can not be negative,{0} nemôže byť záporné,
-{0} created,{0} vytvorené,
+{0} created,{0} vytvoril,
 "{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v súčasnosti má postavenie {1} Scorecardu pre dodávateľov a nákupné objednávky tomuto dodávateľovi by mali byť vydané opatrne.,
 "{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} v súčasnosti má {1} hodnotiacu kartu pre dodávateľa, a RFQ pre tohto dodávateľa by mali byť vydané opatrne.",
 {0} does not belong to Company {1},{0} nepatrí do Spoločnosti {1},
@@ -3421,10 +3574,34 @@
 {0}: {1} does not exists,{0}: {1} neexistuje,
 {0}: {1} not found in Invoice Details table,{0}: {1} nenájdené v tabuľke Podrobnosti Faktúry,
 {} of {},{} z {},
+Chat,Čet,
+Completed By,Dokončené kým,
+Conditions,podmienky,
+County,Okres,
+Day of Week,Deň v týždni,
 "Dear System Manager,","Vážený System Manager,",
+Default Value,Výchozí hodnota,
 Email Group,email Group,
+Fieldtype,Typ pole,
+ID,ID,
 Images,snímky,
 Import,Importovat,
+Office,Kancelář,
+Passive,pasívny,
+Percent,percento,
+Permanent,stály,
+Personal,osobné,
+Plant,Rostlina,
+Post,Príspevok,
+Postal,Poštovní,
+Postal Code,poštové smerovacie číslo,
+Provider,poskytovateľ,
+Read Only,Len na čítanie,
+Recipient,Príjemca,
+Reviews,recenzia,
+Sender,odosielateľ,
+Shop,Obchod,
+Subsidiary,Dceřiný,
 There is some problem with the file url: {0},Tam je nejaký problém s URL súboru: {0},
 Values Changed,hodnoty Zmenil,
 or,alebo,
@@ -3458,13 +3635,19 @@
 "Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Špeciálne znaky s výnimkou „-“, „#“, „.“, „/“, „{“ A „}“ nie sú v názvových sériách povolené.",
 Target Details,Podrobnosti o cieli,
 {0} already has a Parent Procedure {1}.,{0} už má rodičovský postup {1}.,
+API,API,
 Annual,Roční,
 Approved,schválený,
 Change,zmena,
+Contact Email,Kontaktný e-mail,
 From Date,Od data,
 Group By,Zoskupiť podľa,
 Importing {0} of {1},Importuje sa {0} z {1},
+Last Sync On,Posledná synchronizácia zapnutá,
+Naming Series,Číselné rady,
 No data to export,Žiadne údaje na export,
+Print Heading,Hlavička tlače,
+Video,video,
 % Of Grand Total,% Z celkového súčtu,
 'employee_field_value' and 'timestamp' are required.,Vyžadujú sa &#39;customer_field_value&#39; a &#39;timestamp&#39;.,
 <b>Company</b> is a mandatory filter.,<b>Spoločnosť</b> je povinný filter.,
@@ -4045,6 +4228,7 @@
 Transfer Material to Supplier,Preneste materiál Dodávateľovi,
 Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Pre zvolený spôsob dopravy sú povinné číslo a dátum prepravy,
 Tuesday,Úterý,
+Type,typ,
 Unable to find Salary Component {0},Nedá sa nájsť zložka platu {0},
 Unable to find the time slot in the next {0} days for the operation {1}.,V nasledujúcich {0} dňoch nie je možné nájsť časový interval operácie {1}.,
 Unable to update remote activity,Nemožno aktualizovať vzdialenú aktivitu,
@@ -4121,15 +4305,21 @@
 Total Expense This Year,Celkové náklady v tomto roku,
 Total Income,Celkový príjem,
 Total Income This Year,Celkový príjem v tomto roku,
+Barcode,čiarový kód,
+Center,Stred,
 Clear,jasný,
+Comment,komentár,
 Comments,Komentáre,
 Download,Stiahnuť ▼,
+Left,Vľavo,
+Link,odkaz,
 New,Nový,
 Not Found,Nenájdené,
 Print,vytlačiť,
 Reference Name,Referenčný názov,
 Refresh,Obnoviť,
 Success,Úspech,
+Time,čas,
 Value,hodnota,
 Actual,skutočný,
 Add to Cart,Pridať do košíka,
@@ -4147,6 +4337,10 @@
 Write Off,Odpísať,
 {0} Created,{0} vytvoril,
 Email Id,Email ID,
+No,Nie,
+Reference Doctype,Reference DocType,
+User Id,ID používateľa,
+Yes,Áno,
 Actual ,Aktuální,
 Add to cart,Pridať do košíka,
 Budget,rozpočet,
@@ -4157,7 +4351,7 @@
 Download as JSON,Stiahnuť ako JSON,
 End date can not be less than start date,Dátum ukončenia nemôže byť menší ako dátum začiatku,
 For Default Supplier (Optional),Pre predvoleného dodávateľa (nepovinné),
-From date cannot be greater than To date,Od dátumu nemôže byť väčšia ako dátum,
+From date cannot be greater than To date,Dátum OD nemôže byť väčší ako dátum DO,
 Get items from,Získať predmety z,
 Group by,Seskupit podle,
 In stock,Skladom,
@@ -4176,27 +4370,29 @@
 Open To Do ,otvorená robiť,
 Operation Id,Prevádzka ID,
 Partially ordered,čiastočne usporiadané,
-Please select company first,Najskôr vyberte spoločnosť,
+Please select company first,"Prosím, vyberte najprv firmu",
 Please select patient,Vyberte položku Pacient,
 Printed On ,Vytlačené dňa,
 Projected qty,Premietané množstvo,
 Sales person,Predajca,
 Serial No {0} Created,Pořadové číslo {0} vytvořil,
-Set as default,Nastaviť ako predvolenú,
+Set as default,Nastavit jako výchozí,
 Source Location is required for the Asset {0},Umiestnenie zdroja sa vyžaduje pre majetok {0},
 Tax Id,DIČ,
 To Time,Chcete-li čas,
 To date cannot be before from date,Dátum nemôže byť pred dátumom,
 Total Taxable value,Celková zdaniteľná hodnota,
 Upcoming Calendar Events ,Nadchádzajúce Udalosti v kalendári,
-Value or Qty,Hodnota alebo množstvo,
+Value or Qty,Hodnota nebo Množství,
 Variance ,odchýlka,
 Variant of,Varianta,
-Write off,Odpis,
+Write off,Odpísať,
 Write off Amount,Odepsat Částka,
 hours,hodiny,
 received from,prijaté od,
 to,na,
+Cards,karty,
+Percentage,percento,
 Failed to setup defaults for country {0}. Please contact support@erpnext.com,"Nepodarilo sa nastaviť predvolené nastavenia pre krajinu {0}. Prosím, kontaktujte support@erpnext.com",
 Row #{0}: Item {1} is not a Serialized/Batched Item. It cannot have a Serial No/Batch No against it.,Riadok # {0}: Položka {1} nie je sériová / dávková položka. Proti nemu nemôže mať sériové číslo / číslo šarže.,
 Please set {0},Prosím nastavte {0},
@@ -4211,3 +4407,4001 @@
 Supplier > Supplier Type,Dodávateľ&gt; Typ dodávateľa,
 Please setup Employee Naming System in Human Resource > HR Settings,Nastavte systém pomenovávania zamestnancov v časti Ľudské zdroje&gt; Nastavenia ľudských zdrojov,
 Please setup numbering series for Attendance via Setup > Numbering Series,Nastavte číslovacie série pre Účasť cez Nastavenie&gt; Číslovacie série,
+Purchase Order Required,Vydaná objednávka je vyžadována,
+Purchase Receipt Required,Příjmka je vyžadována,
+Requested,Požadované,
+YouTube,YouTube,
+Vimeo,Vimeo,
+Publish Date,Dátum vydania,
+Duration,trvanie,
+Advanced Settings,Pokročilé nastavenia,
+Path,cesta,
+Components,komponenty,
+Verified By,Verified By,
+Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu,
+Must be Whole Number,Musí být celé číslo,
+GL Entry,Vstup GL,
+Fee Validity,Platnosť poplatku,
+Dosage Form,Dávkovací formulár,
+Patient Medical Record,Záznam pacienta,
+Total Completed Qty,Celkom dokončené množstvo,
+Qty to Manufacture,Množství K výrobě,
+Out Patient Consulting Charge Item,Zariadenie pre poplatok za konzultáciu pacienta,
+Inpatient Visit Charge Item,Položka poplatku za hospitalizáciu,
+OP Consulting Charge,OP Poradenstvo Charge,
+Inpatient Visit Charge,Poplatok za návštevu v nemocnici,
+Check Availability,Skontrolovať dostupnosť,
+Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden.",
+Account Name,Názov účtu,
+Inter Company Account,Inter firemný účet,
+Parent Account,Nadřazený účet,
+Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.,
+Chargeable,Spoplatniteľné,
+Rate at which this tax is applied,"Sadzba, pri ktorej sa použije táto daň",
+Frozen,Zmražený,
+"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům.",
+Balance must be,Zostatok musí byť,
+Old Parent,Staré nadřazené,
+Include in gross,Zahrnúť do brutto,
+Auditor,Auditor,
+Accounting Dimension,Účtovná dimenzia,
+Dimension Name,Názov dimenzie,
+Dimension Defaults,Predvolené rozmery,
+Accounting Dimension Detail,Detail účtovnej dimenzie,
+Default Dimension,Predvolená dimenzia,
+Mandatory For Balance Sheet,Povinné pre súvahu,
+Mandatory For Profit and Loss Account,Povinné pre účet ziskov a strát,
+Accounting Period,Účtovného obdobia,
+Period Name,Názov obdobia,
+Closed Documents,Uzavreté dokumenty,
+Accounts Settings,Nastavenie účtu,
+Settings for Accounts,Nastavenie Účtovníctva,
+Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob,
+"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky.",
+Accounts Frozen Upto,Účty Frozen aľ,
+"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže.",
+Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky,
+Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účtů,
+Determine Address Tax Category From,Určite kategóriu dane z adresy,
+Address used to determine Tax Category in transactions.,Adresa použitá na určenie daňovej kategórie pri transakciách.,
+Over Billing Allowance (%),Príplatok za fakturáciu (%),
+Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,"Percentuálny podiel, ktorý vám umožňuje vyúčtovať viac oproti objednanej sume. Napríklad: Ak je hodnota objednávky 100 EUR pre položku a tolerancia je nastavená na 10%, potom máte povolené vyúčtovať 110 USD.",
+Credit Controller,Credit Controller,
+Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity.",
+Check Supplier Invoice Number Uniqueness,"Skontrolujte, či dodávateľské faktúry Počet Jedinečnosť",
+Make Payment via Journal Entry,Vykonať platbu cez Journal Entry,
+Unlink Payment on Cancellation of Invoice,Odpojiť Platba o zrušení faktúry,
+Unlink Advance Payment on Cancelation of Order,Odpojte zálohovú platbu pri zrušení objednávky,
+Book Asset Depreciation Entry Automatically,Automatické odpisovanie majetku v účtovnej závierke,
+Allow Cost Center In Entry of Balance Sheet Account,Povoliť nákladové stredisko pri zápise účtov bilancie,
+Automatically Add Taxes and Charges from Item Tax Template,Automaticky pridávať dane a poplatky zo šablóny dane z položiek,
+Automatically Fetch Payment Terms,Automaticky načítať platobné podmienky,
+Show Inclusive Tax In Print,Zobraziť inkluzívnu daň v tlači,
+Show Payment Schedule in Print,Zobraziť plán platieb v časti Tlač,
+Currency Exchange Settings,Nastavenia výmeny meny,
+Allow Stale Exchange Rates,Povoliť stale kurzy výmeny,
+Stale Days,Stale dni,
+Report Settings,Nastavenia prehľadov,
+Use Custom Cash Flow Format,Použiť formát vlastného toku peňazí,
+Only select if you have setup Cash Flow Mapper documents,"Vyberte len, ak máte nastavené dokumenty Mapper Cash Flow",
+Allowed To Transact With,Povolené na transakciu s,
+Branch Code,Kód pobočky,
+Address and Contact,Adresa a Kontakt,
+Address HTML,Adresa HTML,
+Contact HTML,Kontakt HTML,
+Data Import Configuration,Konfigurácia importu údajov,
+Bank Transaction Mapping,Mapovanie bankových transakcií,
+Plaid Access Token,Plaid Access Token,
+Company Account,Firemný účet,
+Account Subtype,Podtyp účtu,
+Is Default Account,Je predvolený účet,
+Is Company Account,Je firemný účet,
+Party Details,Party Podrobnosti,
+Account Details,Údaje o účtu,
+IBAN,IBAN,
+Bank Account No,Číslo bankového účtu,
+Integration Details,Podrobnosti o integrácii,
+Integration ID,Integračné ID,
+Last Integration Date,Dátum poslednej integrácie,
+Change this date manually to setup the next synchronization start date,Tento dátum zmeňte manuálne a nastavte nasledujúci dátum začatia synchronizácie,
+Mask,maskovať,
+Bank Guarantee,Banková záruka,
+Bank Guarantee Type,Typ bankovej záruky,
+Receiving,Príjem,
+Providing,ak,
+Reference Document Name,Názov referenčného dokumentu,
+Validity in Days,Platnosť v dňoch,
+Bank Account Info,Informácie o bankovom účte,
+Clauses and Conditions,Doložky a podmienky,
+Bank Guarantee Number,Číslo bankovej záruky,
+Name of Beneficiary,Názov príjemcu,
+Margin Money,Margin Money,
+Charges Incurred,Poplatky vzniknuté,
+Fixed Deposit Number,Číslo s pevným vkladom,
+Account Currency,Mena účtu,
+Select the Bank Account to reconcile.,"Vyberte bankový účet, ktorý chcete zladiť.",
+Include Reconciled Entries,Zahrnout odsouhlasené zápisy,
+Get Payment Entries,Získať Platobné položky,
+Payment Entries,platobné Príspevky,
+Update Clearance Date,Aktualizace Výprodej Datum,
+Bank Reconciliation Detail,Detail bankového odsúhlasenia,
+Cheque Number,Šek číslo,
+Cheque Date,Šek Datum,
+Statement Header Mapping,Hlásenie hlavičky výkazu,
+Statement Headers,Hlavičky vyhlásení,
+Transaction Data Mapping,Mapovanie dát transakcií,
+Mapped Items,Mapované položky,
+Bank Statement Settings Item,Položka Nastavenia bankového výpisu,
+Mapped Header,Zmapovaná hlavička,
+Bank Header,Záhlavie banky,
+Bank Statement Transaction Entry,Výpis transakcie z bankového výpisu,
+Bank Transaction Entries,Položky bankových transakcií,
+New Transactions,Nové transakcie,
+Match Transaction to Invoices,Prebieha transakcia so faktúrami,
+Create New Payment/Journal Entry,Vytvorte novú položku Platba / denník,
+Submit/Reconcile Payments,Odoslať / Zosúladiť platby,
+Matching Invoices,Zodpovedajúce faktúry,
+Payment Invoice Items,Položky faktúry platby,
+Reconciled Transactions,Zosúladené transakcie,
+Bank Statement Transaction Invoice Item,Položka faktúry transakcie na bankový účet,
+Payment Description,Popis platby,
+Invoice Date,Dátum fakturácie,
+Bank Statement Transaction Payment Item,Platobná položka transakcie v banke,
+outstanding_amount,nesplatená suma,
+Payment Reference,Označenie platby,
+Bank Statement Transaction Settings Item,Položka nastavenia transakcie bankového výpisu,
+Bank Data,Bankové údaje,
+Mapped Data Type,Mapovaný typ údajov,
+Mapped Data,Mapované údaje,
+Bank Transaction,Bankové transakcie,
+ACC-BTN-.YYYY.-,ACC-BTN-.YYYY.-,
+Transaction ID,ID transakcie,
+Unallocated Amount,nepridelené Suma,
+Field in Bank Transaction,Pole v bankovej transakcii,
+Column in Bank File,Stĺpec v bankovom súbore,
+Bank Transaction Payments,Platby bankových transakcií,
+Control Action,Kontrolná akcia,
+Applicable on Material Request,Platí pre materiálové požiadavky,
+Action if Annual Budget Exceeded on MR,Opatrenie v prípade prekročenia ročného rozpočtu na MR,
+Warn,Varovat,
+Ignore,Ignorovat,
+Action if Accumulated Monthly Budget Exceeded on MR,Ak je akumulovaný mesačný rozpočet prekročen na MR,
+Applicable on Purchase Order,Platí pre nákupnú objednávku,
+Action if Annual Budget Exceeded on PO,"Opatrenie, ak bol prekročený ročný rozpočet na PO",
+Action if Accumulated Monthly Budget Exceeded on PO,Ak akumulovaný mesačný rozpočet prekročil PO,
+Applicable on booking actual expenses,Platí pri rezervácii skutočných výdavkov,
+Action if Annual Budget Exceeded on Actual,"Opatrenie, ak bol ročný rozpočet prekročený na skutočný",
+Action if Accumulated Monthly Budget Exceeded on Actual,Ak akumulovaný mesačný rozpočet prekročil skutočný,
+Budget Accounts,rozpočtové účty,
+Budget Account,rozpočet účtu,
+Budget Amount,rozpočet Suma,
+C-Form,C-Form,
+ACC-CF-.YYYY.-,ACC-CF-.YYYY.-,
+C-Form No,C-Form No,
+Received Date,Dátum prijatia,
+Quarter,Čtvrtletí,
+I,ja,
+II,II,
+III,III,
+IV,IV,
+C-Form Invoice Detail,C-Form Faktura Detail,
+Invoice No,Faktúra č.,
+Cash Flow Mapper,Mapovač hotovostných tokov,
+Section Name,Názov sekcie,
+Section Header,Záhlavie sekcie,
+Section Leader,Vedúci sekcie,
+e.g Adjustments for:,napr. Úpravy pre:,
+Section Subtotal,Oddiel Medzisúčet,
+Section Footer,Päta sekcie,
+Position,pozície,
+Cash Flow Mapping,Mapovanie peňažných tokov,
+Select Maximum Of 1,Vyberte možnosť Maximálne 1,
+Is Finance Cost,Sú finančné náklady,
+Is Working Capital,Je pracovný kapitál,
+Is Finance Cost Adjustment,Je úprava finančných nákladov,
+Is Income Tax Liability,Zodpovednosť za dane z príjmov,
+Is Income Tax Expense,Daň z príjmov,
+Cash Flow Mapping Accounts,Zúčtovanie peňažných tokov,
+account,Účet,
+Cash Flow Mapping Template,Šablóna mapovania peňažných tokov,
+Cash Flow Mapping Template Details,Podrobné informácie o šablóne mapovania peňažných tokov,
+POS-CLO-,POS-CLO-,
+Custody,starostlivosť,
+Net Amount,Čistá suma,
+Cashier Closing Payments,Pokladničné platby,
+Import Chart of Accounts from a csv file,Importujte účtovnú schému zo súboru CSV,
+Attach custom Chart of Accounts file,Pripojte vlastný súbor účtovných osnov,
+Chart Preview,Ukážka grafu,
+Chart Tree,Strom stromu,
+Cheque Print Template,Šek šablóny tlače,
+Has Print Format,Má formát tlače,
+Primary Settings,primárnej Nastavenie,
+Cheque Size,šek Veľkosť,
+Regular,pravidelný,
+Starting position from top edge,Východisková poloha od horného okraja,
+Cheque Width,šek Šírka,
+Cheque Height,šek Výška,
+Scanned Cheque,skenovaných Šek,
+Is Account Payable,Je účtu splatný,
+Distance from top edge,Vzdialenosť od horného okraja,
+Distance from left edge,Vzdialenosť od ľavého okraja,
+Message to show,správa ukázať,
+Date Settings,Nastavenia dátumu,
+Starting location from left edge,Počnúc umiestnenie od ľavého okraja,
+Payer Settings,nastavenie platcu,
+Width of amount in word,Šírka sumy v slove,
+Line spacing for amount in words,riadkovanie za čiastku v slovách,
+Amount In Figure,Na obrázku vyššie,
+Signatory Position,signatár Position,
+Closed Document,Uzavretý dokument,
+Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.,
+Cost Center Name,Meno nákladového strediska,
+Parent Cost Center,Nadřazené Nákladové středisko,
+lft,LFT,
+rgt,Rgt,
+Coupon Code,kód kupónu,
+Coupon Name,Názov kupónu,
+"e.g. ""Summer Holiday 2019 Offer 20""","napr. „Letná dovolenka 2019, ponuka 20“",
+Coupon Type,Typ kupónu,
+Promotional,propagačné,
+Gift Card,Darčeková karta,
+unique e.g. SAVE20  To be used to get discount,"jedinečný, napr. SAVE20 Používa sa na získanie zľavy",
+Validity and Usage,Platnosť a použitie,
+Maximum Use,Maximálne použitie,
+Used,použité,
+Coupon Description,Popis kupónu,
+Discounted Invoice,Zľavnená faktúra,
+Exchange Rate Revaluation,Prehodnotenie výmenného kurzu,
+Get Entries,Získajte záznamy,
+Exchange Rate Revaluation Account,Účet z precenenia výmenného kurzu,
+Total Gain/Loss,Celkový zisk / strata,
+Balance In Account Currency,Zostatok v mene účtu,
+Current Exchange Rate,Aktuálny kurz,
+Balance In Base Currency,Zostatok v základnej mene,
+New Exchange Rate,Nový kurz,
+New Balance In Base Currency,Nový zostatok v základnej mene,
+Gain/Loss,Zisk / strata,
+**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiškálny rok ** predstavuje finančný rok. Všetky účtovné záznamy a ďalšie významné transakcie sú sledované pod ** Fiškálny rok **.,
+Year Name,Meno roku,
+"For e.g. 2012, 2012-13","Pro např 2012, 2012-13",
+Year Start Date,Dátom začiatku roka,
+Year End Date,Dátum konca roka,
+Companies,Spoločnosti,
+Auto Created,Automatické vytvorenie,
+Stock User,Používateľ skladu,
+Fiscal Year Company,Spoločnosť pre fiškálny rok,
+Debit Amount,Debetné Suma,
+Credit Amount,Výška úveru,
+Debit Amount in Account Currency,Debetné Čiastka v mene účtu,
+Credit Amount in Account Currency,Kreditné Čiastka v mene účtu,
+Voucher Detail No,Voucher Detail No,
+Is Opening,Se otevírá,
+Is Advance,Je Zálohová,
+To Rename,Premenovať,
+GST Account,Účet GST,
+CGST Account,CGST účet,
+SGST Account,Účet SGST,
+IGST Account,Účet IGST,
+CESS Account,Účet CESS,
+Loan Start Date,Dátum začiatku pôžičky,
+Loan Period (Days),Úverové obdobie (dni),
+Loan End Date,Dátum ukončenia pôžičky,
+Bank Charges,Bankové poplatky,
+Short Term Loan Account,Krátkodobý úverový účet,
+Bank Charges Account,Účet bankových poplatkov,
+Accounts Receivable Credit Account,Úverový účet pohľadávok,
+Accounts Receivable Discounted Account,Zľavový účet pohľadávok,
+Accounts Receivable Unpaid Account,Nesplatené účty pohľadávok,
+Item Tax Template,Šablóna dane z položky,
+Tax Rates,Daňové sadzby,
+Item Tax Template Detail,Detail šablóny dane z položky,
+Entry Type,Entry Type,
+Inter Company Journal Entry,Inter company Journal Entry,
+Bank Entry,Bank Entry,
+Cash Entry,Cash Entry,
+Credit Card Entry,Vstup Kreditní karta,
+Contra Entry,Contra Entry,
+Excise Entry,Spotřební Entry,
+Write Off Entry,Odepsat Vstup,
+Opening Entry,Otvárací údaj,
+ACC-JV-.YYYY.-,ACC-JV-.YYYY.-,
+Accounting Entries,Účetní záznamy,
+Total Debit,Celkem Debit,
+Total Credit,Celkový Credit,
+Difference (Dr - Cr),Rozdíl (Dr - Cr),
+Make Difference Entry,Učinit vstup Rozdíl,
+Total Amount Currency,Celková suma Mena,
+Total Amount in Words,Celková částka slovy,
+Remark,Poznámka,
+Paid Loan,Platené pôžičky,
+Inter Company Journal Entry Reference,Inter Company Entry Reference,
+Write Off Based On,Odepsat založené na,
+Get Outstanding Invoices,Získat neuhrazených faktur,
+Printing Settings,Nastavenie tlače,
+Pay To / Recd From,Platit K / Recd Z,
+Payment Order,Platobný príkaz,
+Subscription Section,Sekcia odberu,
+Journal Entry Account,Zápis do deníku Účet,
+Account Balance,Zůstatek na účtu,
+Party Balance,Balance Party,
+If Income or Expense,Pokud je výnos nebo náklad,
+Exchange Rate,Výmenný kurz,
+Debit in Company Currency,Debetnej v spoločnosti Mena,
+Credit in Company Currency,Úverové spoločnosti v mene,
+Payroll Entry,Mzdový účet,
+Employee Advance,Zamestnanec Advance,
+Reference Due Date,Referenčný dátum splatnosti,
+Loyalty Program Tier,Vernostný programový stupeň,
+Redeem Against,Späť na začiatok,
+Expiry Date,Datum vypršení platnosti,
+Loyalty Point Entry Redemption,Vrátenie bodu vkladu,
+Redemption Date,Dátum vykúpenia,
+Redeemed Points,Vymožené body,
+Loyalty Program Name,Názov vernostného programu,
+Loyalty Program Type,Typ vernostného programu,
+Single Tier Program,Jednoduchý program,
+Multiple Tier Program,Viacvrstvový program,
+Customer Territory,Oblasť zákazníka,
+Auto Opt In (For all customers),Automatická registrácia (pre všetkých zákazníkov),
+Collection Tier,Zbierka Tier,
+Collection Rules,Pravidlá zberu,
+Redemption,vykúpenie,
+Conversion Factor,Konverzný koeficient,
+1 Loyalty Points = How much base currency?,1 Vernostné body = Koľko základnej meny?,
+Expiry Duration (in days),Trvanie platnosti (v dňoch),
+Help Section,Sekcia pomocníka,
+Loyalty Program Help,Nápoveda vernostného programu,
+Loyalty Program Collection,Zber vernostného programu,
+Tier Name,Názov úrovne,
+Minimum Total Spent,Minimálny celkový počet vynaložených prostriedkov,
+Collection Factor (=1 LP),Faktor zberu (= 1 LP),
+For how much spent = 1 Loyalty Point,Pre koľko strávil = 1 vernostný bod,
+Mode of Payment Account,Způsob platby účtu,
+Default Account,Východzí účet,
+Default account will be automatically updated in POS Invoice when this mode is selected.,"Predvolený účet sa automaticky aktualizuje v POS faktúre, keď je vybratý tento režim.",
+**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mesačný Distribúcia ** umožňuje distribuovať Rozpočet / Target celé mesiace, ak máte sezónnosti vo vašej firme.",
+Distribution Name,Názov distribúcie,
+Name of the Monthly Distribution,Názov mesačného rozdelenia,
+Monthly Distribution Percentages,Měsíční Distribuční Procenta,
+Monthly Distribution Percentage,Měsíční Distribution Procento,
+Percentage Allocation,Procento přidělení,
+Create Missing Party,Vytvoriť chýbajúcu stranu,
+Create missing customer or supplier.,Vytvorte chýbajúceho zákazníka alebo dodávateľa.,
+Opening Invoice Creation Tool Item,Otvorenie položky nástroja na vytvorenie faktúry,
+Temporary Opening Account,Dočasný úvodný účet,
+Party Account,Party účtu,
+Type of Payment,typ platby,
+ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-,
+Receive,Prijať,
+Internal Transfer,vnútorné Prevod,
+Payment Order Status,Stav platobného príkazu,
+Payment Ordered,Platba objednaná,
+Payment From / To,Platba od / do,
+Company Bank Account,Firemný bankový účet,
+Party Bank Account,Bankový účet strany,
+Account Paid From,Účet sú platení z prostriedkov,
+Account Paid To,účet Venovaná,
+Paid Amount (Company Currency),Zaplatená suma (Company meny),
+Received Amount,Prijatá suma,
+Received Amount (Company Currency),Prijatá suma (v peňažnej mene firmy),
+Get Outstanding Invoice,Získajte vynikajúcu faktúru,
+Payment References,platobné Referencie,
+Writeoff,odpísanie,
+Total Allocated Amount,Celková alokovaná suma,
+Total Allocated Amount (Company Currency),Celková alokovaná suma (Company mena),
+Set Exchange Gain / Loss,Set Exchange zisk / strata,
+Difference Amount (Company Currency),Rozdiel Suma (Company mena),
+Write Off Difference Amount,Odpísať Difference Suma,
+Deductions or Loss,Odpočty alebo strata,
+Payment Deductions or Loss,Platobné zrážky alebo strata,
+Cheque/Reference Date,Šek / Referenčný dátum,
+Payment Entry Deduction,Platba Vstup dedukcie,
+Payment Entry Reference,Platba Vstup referencie,
+Allocated,Přidělené,
+Payment Gateway Account,Platobná brána účet,
+Payment Account,Platební účet,
+Default Payment Request Message,Východzí Platba Request Message,
+PMO-,PMO-,
+Payment Order Type,Typ platobného príkazu,
+Payment Order Reference,Odkaz na platobný príkaz,
+Bank Account Details,Podrobnosti o bankovom účte,
+Payment Reconciliation,Platba Odsouhlasení,
+Receivable / Payable Account,Účet pohľadávok/záväzkov,
+Bank / Cash Account,Bankový / Peňažný účet,
+From Invoice Date,Z faktúry Dátum,
+To Invoice Date,Ak chcete dátumu vystavenia faktúry,
+Minimum Invoice Amount,Minimálna suma faktúry,
+Maximum Invoice Amount,Maximálna suma faktúry,
+System will fetch all the entries if limit value is zero.,"Ak je limitná hodnota nula, systém načíta všetky záznamy.",
+Get Unreconciled Entries,Získat smířit záznamů,
+Unreconciled Payment Details,Smířit platbě,
+Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti,
+Payment Reconciliation Invoice,Platba Odsouhlasení faktury,
+Invoice Number,Číslo faktúry,
+Payment Reconciliation Payment,Platba Odsouhlasení Platba,
+Reference Row,referenčnej Row,
+Allocated amount,Přidělené sumy,
+Payment Request Type,Typ žiadosti o platbu,
+Outward,von,
+Inward,dovnútra,
+ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-,
+Transaction Details,detaily transakcie,
+Amount in customer's currency,Čiastka v mene zákazníka,
+Is a Subscription,Je predplatné,
+Transaction Currency,transakčné mena,
+Subscription Plans,Predplatné,
+SWIFT Number,SWIFT číslo,
+Recipient Message And Payment Details,Príjemca správy a platobných informácií,
+Make Sales Invoice,Vytvoriť faktúru,
+Mute Email,Stíšiť email,
+payment_url,payment_url,
+Payment Gateway Details,Platobná brána Podrobnosti,
+Payment Schedule,Rozvrh platieb,
+Invoice Portion,Časť faktúry,
+Payment Amount,Částka platby,
+Payment Term Name,Názov platby,
+Due Date Based On,Dátum splatnosti založený na,
+Day(s) after invoice date,Deň (dni) po dátume fakturácie,
+Day(s) after the end of the invoice month,Deň (dni) po skončení fakturačného mesiaca,
+Month(s) after the end of the invoice month,Mesiac (mesiace) po skončení mesiaca faktúry,
+Credit Days,Úverové dni,
+Credit Months,Kreditné mesiace,
+Payment Terms Template Detail,Podrobné informácie o podmienkach platieb,
+Closing Fiscal Year,Uzavření fiskálního roku,
+Closing Account Head,Závěrečný účet hlava,
+"The account head under Liability or Equity, in which Profit/Loss will be booked","Účet hlavu pod záväzkom alebo vlastným imaním, v ktorom budú Zisk / strata rezervovať",
+POS Customer Group,POS Customer Group,
+POS Field,Pole POS,
+POS Item Group,POS položky Group,
+[Select],[Vybrať],
+Company Address,Adresa spoločnosti,
+Update Stock,Aktualizace skladem,
+Ignore Pricing Rule,Ignorovat Ceny pravidlo,
+Allow user to edit Rate,Umožňujú užívateľovi upravovať Cena,
+Allow user to edit Discount,Povoliť používateľovi upraviť zľavu,
+Allow Print Before Pay,Povoliť tlač pred zaplatením,
+Display Items In Stock,Zobraziť položky na sklade,
+Applicable for Users,Platí pre používateľov,
+Sales Invoice Payment,Platba na odoslanú faktúru,
+Item Groups,Skupiny položiek,
+Only show Items from these Item Groups,Zobrazovať iba položky z týchto skupín položiek,
+Customer Groups,skupiny zákazníkov,
+Only show Customer of these Customer Groups,Zobraziť iba zákazníka z týchto skupín zákazníkov,
+Print Format for Online,Formát tlače pre online,
+Offline POS Settings,Nastavenia POS offline,
+Write Off Account,Odepsat účet,
+Write Off Cost Center,Odepsat nákladové středisko,
+Account for Change Amount,Účet pre zmenu Suma,
+Taxes and Charges,Daně a poplatky,
+Apply Discount On,Použiť Zľava na,
+POS Profile User,Používateľ profilu POS,
+Use POS in Offline Mode,Používajte POS v režime offline,
+Apply On,Aplikujte na,
+Price or Product Discount,Cena alebo zľava produktu,
+Apply Rule On Item Code,Použiť pravidlo pre kód položky,
+Apply Rule On Item Group,Použiť pravidlo pre skupinu položiek,
+Apply Rule On Brand,Použiť pravidlo na značku,
+Mixed Conditions,Zmiešané podmienky,
+Conditions will be applied on all the selected items combined. ,Na všetky vybrané položky sa použijú podmienky spolu.,
+Is Cumulative,Je kumulatívne,
+Coupon Code Based,Na základe kódu kupónu,
+Discount on Other Item,Zľava na inú položku,
+Apply Rule On Other,Použiť pravidlo na iné,
+Party Information,Informácie o večierku,
+Quantity and Amount,Množstvo a množstvo,
+Min Qty,Min Množství,
+Max Qty,Max Množství,
+Min Amt,Min. Amt,
+Max Amt,Max Amt,
+Period Settings,Nastavenie obdobia,
+Margin,Marža,
+Margin Type,margin Type,
+Margin Rate or Amount,Marža sadzbou alebo pevnou sumou,
+Price Discount Scheme,Schéma zníženia ceny,
+Rate or Discount,Sadzba alebo zľava,
+Discount Percentage,Zľava v percentách,
+Discount Amount,Čiastka zľavy,
+For Price List,Pre Cenník,
+Product Discount Scheme,Schéma zľavy na výrobok,
+Same Item,Rovnaká položka,
+Free Item,Zadarmo položka,
+Threshold for Suggestion,Prahová hodnota návrhu,
+System will notify to increase or decrease quantity or amount ,Systém vás upozorní na zvýšenie alebo zníženie množstva alebo množstva,
+"Higher the number, higher the priority","Vyšší číslo, vyšší priorita",
+Apply Multiple Pricing Rules,Použite pravidlá viacerých cien,
+Apply Discount on Rate,Použite zľavu na sadzbu,
+Validate Applied Rule,Potvrdiť použité pravidlo,
+Rule Description,Popis pravidla,
+Pricing Rule Help,Ceny Pravidlo Help,
+Promotional Scheme Id,ID propagačnej schémy,
+Promotional Scheme,Propagačná schéma,
+Pricing Rule Brand,Značka pravidla stanovovania cien,
+Pricing Rule Detail,Podrobnosti pravidla o cenách,
+Child Docname,Názov dieťaťa,
+Rule Applied,Platí pravidlo,
+Pricing Rule Item Code,Kód položky pravidla pravidla,
+Pricing Rule Item Group,Skupina položiek cenových pravidiel,
+Price Discount Slabs,Cenové zľavy,
+Promotional Scheme Price Discount,Zľava na propagačnú schému,
+Product Discount Slabs,Dosky na zľavu produktov,
+Promotional Scheme Product Discount,Zľava na propagačnú schému,
+Min Amount,Min. Suma,
+Max Amount,Maximálna suma,
+Discount Type,Typ zľavy,
+ACC-PINV-.YYYY.-,ACC-pInv-.YYYY.-,
+Tax Withholding Category,Daňová kategória,
+Edit Posting Date and Time,Úpraviť dátum a čas vzniku,
+Is Paid,sa vypláca,
+Is Return (Debit Note),Je Return (Debit Note),
+Apply Tax Withholding Amount,Použiť čiastku zrážkovej dane,
+Accounting Dimensions ,Účtovné dimenzie,
+Supplier Invoice Details,Detaily dodávateľskej faktúry,
+Supplier Invoice Date,Dátum dodávateľskej faktúry,
+Return Against Purchase Invoice,Návrat proti nákupnej faktúry,
+Select Supplier Address,Vybrať Dodávateľ Address,
+Contact Person,Kontaktná osoba,
+Select Shipping Address,Zvoľte adresu pre dodanie,
+Currency and Price List,Cenník a mena,
+Price List Currency,Mena cenníka,
+Price List Exchange Rate,Katalogová cena Exchange Rate,
+Set Accepted Warehouse,Nastaviť prijatý sklad,
+Rejected Warehouse,Zamítnuto Warehouse,
+Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek",
+Raw Materials Supplied,Suroviny dodané,
+Supplier Warehouse,Dodavatel Warehouse,
+Pricing Rules,Pravidlá stanovovania cien,
+Supplied Items,Dodávané položky,
+Total (Company Currency),Total (Company meny),
+Net Total (Company Currency),Net Total (Company Měna),
+Total Net Weight,Celková čistá hmotnosť,
+Shipping Rule,Prepravné pravidlo,
+Purchase Taxes and Charges Template,Kúpte Dane a poplatky šablóny,
+Purchase Taxes and Charges,Nákup Daně a poplatky,
+Tax Breakup,Daňové rozdelenie,
+Taxes and Charges Calculation,Daně a poplatky výpočet,
+Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna),
+Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna),
+Total Taxes and Charges (Company Currency),Spolu dane a poplatky (v peňažnej mene firmy),
+Taxes and Charges Added,Daně a poplatky přidané,
+Taxes and Charges Deducted,Daně a odečtené,
+Total Taxes and Charges,Celkem Daně a poplatky,
+Additional Discount,Ďalšie zľavy,
+Apply Additional Discount On,Použiť dodatočné Zľava na,
+Additional Discount Amount (Company Currency),Dodatočná zľava Suma (Mena Company),
+Grand Total (Company Currency),Celkový součet (Měna společnosti),
+Rounding Adjustment (Company Currency),Úprava zaokrúhľovania (mena spoločnosti),
+Rounded Total (Company Currency),Zaoblený Total (Company Měna),
+In Words (Company Currency),Slovy (měna společnosti),
+Rounding Adjustment,Nastavenie zaokrúhľovania,
+In Words,Slovy,
+Total Advance,Total Advance,
+Disable Rounded Total,Vypnúť zaokrúhlovanie sumy spolu,
+Cash/Bank Account,Hotovostný / Bankový účet,
+Write Off Amount (Company Currency),Odpísať Suma (Company meny),
+Set Advances and Allocate (FIFO),Nastaviť preddavky a alokovať (FIFO),
+Get Advances Paid,Získejte zaplacené zálohy,
+Advances,Zálohy,
+Terms,Podmínky,
+Terms and Conditions1,Podmínky a podmínek1,
+Group same items,Skupina rovnaké položky,
+Print Language,Jazyk tlače,
+"Once set, this invoice will be on hold till the set date",Po nastavení bude táto faktúra pozastavená až do stanoveného dátumu,
+Credit To,Kredit:,
+Party Account Currency,Party Mena účtu,
+Against Expense Account,Proti výdajového účtu,
+Inter Company Invoice Reference,Interná referencia faktúry spoločnosti,
+Is Internal Supplier,Je interný dodávateľ,
+Start date of current invoice's period,Datum období současného faktury je Začátek,
+End date of current invoice's period,Datum ukončení doby aktuální faktury je,
+Update Auto Repeat Reference,Aktualizovať referenciu automatického opakovania,
+Purchase Invoice Advance,Záloha přijaté faktury,
+Purchase Invoice Item,Položka přijaté faktury,
+Quantity and Rate,Množstvo a Sadzba,
+Received Qty,Prijaté množstvo,
+Accepted Qty,Prijaté množstvo,
+Rejected Qty,zamietnutá Množstvo,
+UOM Conversion Factor,Faktor konverzie MJ,
+Discount on Price List Rate (%),Zľava z cenníkovej ceny (%),
+Price List Rate (Company Currency),Cenníková cena (mena firmy),
+Rate ,Sadzba,
+Rate (Company Currency),Sadzba (V mene spoločnosti),
+Amount (Company Currency),Částka (Měna Společnosti),
+Is Free Item,Je bezplatná položka,
+Net Rate,Čistá miera,
+Net Rate (Company Currency),Čistý Rate (Company meny),
+Net Amount (Company Currency),Čistá suma (Company Mena),
+Item Tax Amount Included in Value,Čiastka dane z položky zahrnutá v hodnote,
+Landed Cost Voucher Amount,Přistál Náklady Voucher Částka,
+Raw Materials Supplied Cost,Dodává se nákladů na suroviny,
+Accepted Warehouse,Schválené Sklad,
+Serial No,Výrobní číslo,
+Rejected Serial No,Zamítnuto Serial No,
+Expense Head,Náklady Head,
+Is Fixed Asset,Je dlhodobého majetku,
+Asset Location,Umiestnenie majetku,
+Deferred Expense,Odložené náklady,
+Deferred Expense Account,Odložený nákladový účet,
+Service Stop Date,Dátum ukončenia servisu,
+Enable Deferred Expense,Povolenie odloženého výdavku,
+Service Start Date,Dátum začiatku služby,
+Service End Date,Dátum ukončenia služby,
+Allow Zero Valuation Rate,Povoliť sadzbu nulového oceňovania,
+Item Tax Rate,Sazba daně položky,
+Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges,Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.\n Používá se daní a poplatků,
+Purchase Order Item,Položka nákupnej objednávky,
+Purchase Receipt Detail,Detail dokladu o kúpe,
+Item Weight Details,Podrobnosti o položke hmotnosti,
+Weight Per Unit,Hmotnosť na jednotku,
+Total Weight,Celková váha,
+Weight UOM,Hmotnostná MJ,
+Page Break,Zalomenie stránky,
+Consider Tax or Charge for,Zvažte daň či poplatek za,
+Valuation and Total,Oceňování a Total,
+Valuation,Ocenění,
+Add or Deduct,Přidat nebo Odečíst,
+Deduct,Odpočítať,
+On Previous Row Amount,Na předchozí řady Částka,
+On Previous Row Total,Na předchozí řady Celkem,
+On Item Quantity,Na množstvo položky,
+Reference Row #,Referenční Row #,
+Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?,
+"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka",
+Account Head,Účet Head,
+Tax Amount After Discount Amount,Částka daně po slevě Částka,
+"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.","Standardní daň šablona, která může být použita pro všechny nákupních transakcí. Tato šablona může obsahovat seznam daňových hlav a také ostatní náklady hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. \n\n #### Poznámka: \n\n daňovou sazbu, můžete definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.\n\n #### Popis sloupců \n\n 1. Výpočet Type: \n - To může být na ** Čistý Total ** (což je součet základní částky).\n - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.\n - ** Aktuální ** (jak je uvedeno).\n 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat \n 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.\n 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).\n 5. Rate: Sazba daně.\n 6. Částka: Částka daně.\n 7. Celkem: Kumulativní celková k tomuto bodu.\n 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).\n 9. Zvažte daň či poplatek za: V této části můžete nastavit, zda daň / poplatek je pouze pro ocenění (není součástí celkem), nebo pouze pro celkem (není přidanou hodnotu do položky), nebo pro obojí.\n 10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň.",
+Salary Component Account,Účet plat Component,
+Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Východisková banka / Peňažný účet budú automaticky aktualizované v plat položka denníku ak je zvolený tento režim.,
+ACC-SINV-.YYYY.-,ACC-Sinv-.YYYY.-,
+Include Payment (POS),Zahŕňajú platby (POS),
+Offline POS Name,Offline POS Name,
+Is Return (Credit Note),Je návrat (kreditná poznámka),
+Return Against Sales Invoice,Návrat proti predajnej faktúre,
+Update Billed Amount in Sales Order,Aktualizovať faktúrovanú čiastku v objednávke predaja,
+Customer PO Details,Podrobnosti PO zákazníka,
+Customer's Purchase Order,Zákazníka Objednávka,
+Customer's Purchase Order Date,Zákazníka Objednávka Datum,
+Customer Address,Adresa zákazníka,
+Shipping Address Name,Názov dodacej adresy,
+Company Address Name,Názov adresy spoločnosti,
+Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny",
+Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny",
+Set Source Warehouse,Nastaviť zdrojový sklad,
+Packing List,Zoznam balenia,
+Packed Items,Zabalené položky,
+Product Bundle Help,Product Bundle Help,
+Time Sheet List,Zoznam časových rozvrhov,
+Time Sheets,Časové rozvrhy,
+Total Billing Amount,Celková suma fakturácie,
+Sales Taxes and Charges Template,Predaj Dane a poplatky šablóny,
+Sales Taxes and Charges,Dane z predaja a poplatky,
+Loyalty Points Redemption,Vernostné body Vykúpenie,
+Redeem Loyalty Points,Uplatnite vernostné body,
+Redemption Account,Účet spätného odkúpenia,
+Redemption Cost Center,Centrum výdavkových nákladov,
+In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury.",
+Allocate Advances Automatically (FIFO),Automaticky prideľovať preddavky (FIFO),
+Get Advances Received,Získat přijaté zálohy,
+Base Change Amount (Company Currency),Základňa Zmena Suma (Company mena),
+Write Off Outstanding Amount,Odepsat dlužné částky,
+Terms and Conditions Details,Podmínky podrobnosti,
+Is Internal Customer,Je interný zákazník,
+Is Discounted,Je zľava,
+Unpaid and Discounted,Nezaplatené a diskontované,
+Overdue and Discounted,Omeškanie a zľava,
+Accounting Details,Účtovné Podrobnosti,
+Debit To,Debetní K,
+Is Opening Entry,Je vstupní otvor,
+C-Form Applicable,C-Form Použitelné,
+Commission Rate (%),Výška provízie (%),
+Sales Team1,Sales Team1,
+Against Income Account,Proti účet příjmů,
+Sales Invoice Advance,Záloha na odoslanej faktúre,
+Advance amount,Záloha ve výši,
+Sales Invoice Item,Položka odoslanej faktúry,
+Customer's Item Code,Zákazníka Kód položky,
+Brand Name,Jméno značky,
+Qty as per Stock UOM,Množstvo podľa skladovej MJ,
+Discount and Margin,Zľava a Margin,
+Rate With Margin,Sadzba s maržou,
+Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou,
+Rate With Margin (Company Currency),Sadzba s maržou (mena spoločnosti),
+Delivered By Supplier,Dodáva sa podľa dodávateľa,
+Deferred Revenue,Výnosy budúcich období,
+Deferred Revenue Account,Účet odloženého výnosu,
+Enable Deferred Revenue,Povoliť odložené výnosy,
+Stock Details,Detaily zásob,
+Customer Warehouse (Optional),Zákazník Warehouse (voliteľne),
+Available Batch Qty at Warehouse,K dispozícii dávky Množstvo v sklade,
+Available Qty at Warehouse,Množství k dispozici na skladu,
+Delivery Note Item,Delivery Note Item,
+Base Amount (Company Currency),Základná suma (Company Currency),
+Sales Invoice Timesheet,Predajná faktúry časový rozvrh,
+Time Sheet,Časový rozvrh,
+Billing Hours,billing Hodiny,
+Timesheet Detail,Detail pracovného výkazu,
+Tax Amount After Discount Amount (Company Currency),Suma dane po zľave Suma (Company meny),
+Item Wise Tax Detail,Položka Wise Tax Detail,
+Parenttype,Parenttype,
+"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardní daň šablona, která může být použita pro všechny prodejních transakcí. Tato šablona může obsahovat seznam daňových hlav a také další náklady / příjmy hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. \n\n #### Poznámka: \n\n daňovou sazbu, vy definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.\n\n #### Popis sloupců \n\n 1. Výpočet Type: \n - To může být na ** Čistý Total ** (což je součet základní částky).\n - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.\n - ** Aktuální ** (jak je uvedeno).\n 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat \n 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.\n 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).\n 5. Rate: Sazba daně.\n 6. Částka: Částka daně.\n 7. Celkem: Kumulativní celková k tomuto bodu.\n 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).\n 9. Je to poplatek v ceně do základní sazby ?: Pokud se to ověřit, znamená to, že tato daň nebude zobrazen pod tabulkou položky, ale budou zahrnuty do základní sazby v hlavním položce tabulky. To je užitečné, pokud chcete dát paušální cenu (včetně všech poplatků), ceny pro zákazníky.",
+* Will be calculated in the transaction.,* Bude vypočítané v transakcii.,
+From No,Od č,
+To No,Nie,
+Is Company,Je spoločnosť,
+Current State,Aktuálny stav,
+Purchased,zakúpené,
+From Shareholder,Od akcionára,
+From Folio No,Z Folio č,
+To Shareholder,Akcionárovi,
+To Folio No,Do priečinka č,
+Equity/Liability Account,Účet vlastného imania / zodpovednosti,
+Asset Account,Asset Account,
+(including),(počítajúc do toho),
+ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
+Folio no.,Folio č.,
+Contact List,Zoznam kontaktov,
+Hidden list maintaining the list of contacts linked to Shareholder,Skrytý zoznam vedúci zoznam kontaktov prepojených s akcionárom,
+Specify conditions to calculate shipping amount,Stanovte podmienky na výpočet výšky prepravných nákladov,
+Shipping Rule Label,Přepravní Pravidlo Label,
+example: Next Day Shipping,Příklad: Next Day Shipping,
+Shipping Rule Type,Typ pravidla odoslania,
+Shipping Account,Dodací účet,
+Calculate Based On,Vypočítať na základe,
+Fixed,fixné,
+Net Weight,Hmotnost,
+Shipping Amount,Prepravovaná čiastka,
+Shipping Rule Conditions,Přepravní Článek Podmínky,
+Restrict to Countries,Obmedziť na krajiny,
+Valid for Countries,"Platí pre krajiny,",
+Shipping Rule Condition,Přepravní Pravidlo Podmínka,
+A condition for a Shipping Rule,Podmínka pro pravidla dopravy,
+From Value,Od hodnoty,
+To Value,Chcete-li hodnota,
+Shipping Rule Country,Prepravné Pravidlo Krajina,
+Subscription Period,Obdobie upisovania,
+Subscription Start Date,Dátum začiatku odberu,
+Cancelation Date,Dátum zrušenia,
+Trial Period Start Date,Dátum začiatku skúšobného obdobia,
+Trial Period End Date,Dátum ukončenia skúšobného obdobia,
+Current Invoice Start Date,Aktuálny dátum začiatku faktúry,
+Current Invoice End Date,Aktuálny dátum ukončenia faktúry,
+Days Until Due,Dni až do splatnosti,
+Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, ktoré musí účastník zaplatiť faktúry generované týmto odberom",
+Cancel At End Of Period,Zrušiť na konci obdobia,
+Generate Invoice At Beginning Of Period,Generovanie faktúry na začiatku obdobia,
+Plans,plány,
+Discounts,Zľavy,
+Additional DIscount Percentage,Ďalšie zľavy Percento,
+Additional DIscount Amount,Dodatočná zľava Suma,
+Subscription Invoice,Faktúra odberu,
+Subscription Plan,Plán predplatného,
+Price Determination,Stanovenie ceny,
+Fixed rate,Fixna sadzba,
+Based on price list,Na základe cenníka,
+Cost,Náklady,
+Billing Interval,Fakturačný interval,
+Billing Interval Count,Počet fakturačných intervalov,
+"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Počet intervalov pre intervalové pole, napr. Ak je Interval &quot;Dni&quot; a Interval fakturácie je 3, faktúry sa vygenerujú každých 3 dni",
+Payment Plan,Platobný plán,
+Subscription Plan Detail,Podrobný popis predplatného,
+Plan,plán,
+Subscription Settings,Nastavenia odberu,
+Grace Period,Doba odkladu,
+Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Počet dní po uplynutí dátumu faktúry pred zrušením predplatného alebo označením predplatného ako nezaplateného,
+Cancel Invoice After Grace Period,Zrušiť faktúru po období odkladu,
+Prorate,kľúčovanie,
+Tax Rule,Daňové Pravidlo,
+Tax Type,Typ dane,
+Use for Shopping Cart,Použitie pre Košík,
+Billing City,Fakturačné mesto,
+Billing County,Fakturačný okres,
+Billing State,Fakturačný štát,
+Billing Zipcode,Fakturačný PSČ,
+Billing Country,Fakturačná krajina,
+Shipping City,Mesto dodania,
+Shipping County,Okres dodania,
+Shipping State,Prepravné State,
+Shipping Zipcode,Prepravný PSČ,
+Shipping Country,Krajina dodania,
+Tax Withholding Account,Zrážkový účet,
+Tax Withholding Rates,Sadzby zrážkovej dane,
+Rates,Sadzby,
+Tax Withholding Rate,Sadzba zrážkovej dane,
+Single Transaction Threshold,Jednoduchá transakčná prahová hodnota,
+Cumulative Transaction Threshold,Kumulatívna hranica transakcií,
+Agriculture Analysis Criteria,Kritériá analýzy poľnohospodárstva,
+Linked Doctype,Linked Doctype,
+Water Analysis,Analýza vody,
+Soil Analysis,Analýza pôdy,
+Plant Analysis,Analýza rastlín,
+Fertilizer,umelé hnojivo,
+Soil Texture,Textúra pôdy,
+Weather,počasie,
+Agriculture Manager,Poľnohospodársky manažér,
+Agriculture User,Poľnohospodársky užívateľ,
+Agriculture Task,Úloha poľnohospodárstva,
+Start Day,Deň začiatku,
+End Day,Koniec dňa,
+Holiday Management,Správa prázdnin,
+Ignore holidays,Ignorovať dovolenku,
+Previous Business Day,Predchádzajúci pracovný deň,
+Next Business Day,Nasledujúci pracovný deň,
+Urgent,Naléhavý,
+Crop,Plodina,
+Crop Name,Názov plodiny,
+Scientific Name,Vedecké meno,
+"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Môžete definovať všetky úlohy, ktoré je potrebné vykonať pre túto plodinu tu. Denné pole sa používa na uvedenie dňa, kedy je potrebné vykonať úlohu, 1 je prvý deň atď.",
+Crop Spacing,Rozdelenie plodín,
+Crop Spacing UOM,Rozmiestnenie medzných plôch,
+Row Spacing,Rozstup riadkov,
+Row Spacing UOM,Rozloženie riadkov UOM,
+Perennial,trvalka,
+Biennial,dvojročný,
+Planting UOM,Výsadba UOM,
+Planting Area,Oblasť výsadby,
+Yield UOM,Výnos UOM,
+Materials Required,Potrebné materiály,
+Produced Items,Vyrobené položky,
+Produce,vyrobiť,
+Byproducts,vedľajšie produkty,
+Linked Location,Prepojená poloha,
+A link to all the Locations in which the Crop is growing,"Odkaz na všetky lokality, v ktorých rastie plodina",
+This will be day 1 of the crop cycle,Toto bude prvý deň cyklu plodín,
+ISO 8601 standard,ISO 8601,
+Cycle Type,Typ cyklu,
+Less than a year,Menej ako rok,
+The minimum length between each plant in the field for optimum growth,Minimálna dĺžka medzi jednotlivými rastlinami v teréne pre optimálny rast,
+The minimum distance between rows of plants for optimum growth,Minimálna vzdialenosť medzi radmi rastlín pre optimálny rast,
+Detected Diseases,Zistené choroby,
+List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Zoznam chorôb zistených v teréne. Po výbere bude automaticky pridaný zoznam úloh, ktoré sa budú týkať tejto choroby",
+Detected Disease,Zistená choroba,
+LInked Analysis,Llnked Analysis,
+Disease,choroba,
+Tasks Created,Vytvorené úlohy,
+Common Name,Spoločný názov,
+Treatment Task,Liečebná úloha,
+Treatment Period,Liečebné obdobie,
+Fertilizer Name,Názov hnojiva,
+Density (if liquid),Hustota (ak je kvapalná),
+Fertilizer Contents,Obsah hnojiva,
+Fertilizer Content,Obsah hnojiva,
+Linked Plant Analysis,Analýza prepojených rastlín,
+Linked Soil Analysis,Analýza prepojenej pôdy,
+Linked Soil Texture,Prepojená pôdna štruktúra,
+Collection Datetime,Dátum zberu,
+Laboratory Testing Datetime,Laboratórne testovanie,
+Result Datetime,Výsledok Datetime,
+Plant Analysis Criterias,Kritériá analýzy rastlín,
+Plant Analysis Criteria,Kritériá analýzy rastlín,
+Minimum Permissible Value,Minimálna prípustná hodnota,
+Maximum Permissible Value,Maximálna prípustná hodnota,
+Ca/K,Ca / K,
+Ca/Mg,Ca / Mg,
+Mg/K,Mg / K,
+(Ca+Mg)/K,(Ca + Mg) / K,
+Ca/(K+Ca+Mg),Ca / (K + Ca + Mg),
+Soil Analysis Criterias,Kritériá analýzy pôdy,
+Soil Analysis Criteria,Kritériá analýzy pôdy,
+Soil Type,Typ pôdy,
+Loamy Sand,Loamy Sand,
+Sandy Loam,Sandy Loam,
+Loam,hlina,
+Silt Loam,Silt Loam,
+Sandy Clay Loam,Sandy Clay Loam,
+Clay Loam,Clay Loam,
+Silty Clay Loam,Silty Clay Loam,
+Sandy Clay,Sandy Clay,
+Silty Clay,Silty Clay,
+Clay Composition (%),Zloženie hliny (%),
+Sand Composition (%),Zloženie piesku (%),
+Silt Composition (%),Zloženie sklonu (%),
+Ternary Plot,Ternary Plot,
+Soil Texture Criteria,Kritériá textúry pôdy,
+Type of Sample,Typ vzorky,
+Container,kontajner,
+Origin,pôvod,
+Collection Temperature ,Teplota zberu,
+Storage Temperature,Teplota skladovania,
+Appearance,vzhľad,
+Person Responsible,Zodpovedná osoba,
+Water Analysis Criteria,Kritériá analýzy vody,
+Weather Parameter,Parametre počasia,
+ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-,
+Asset Owner,Majiteľ majetku,
+Asset Owner Company,Spoločnosť vlastníka aktív,
+Custodian,strážca,
+Disposal Date,Likvidácia Dátum,
+Journal Entry for Scrap,Zápis do denníka do šrotu,
+Available-for-use Date,Dátum k dispozícii na použitie,
+Calculate Depreciation,Vypočítať odpisy,
+Allow Monthly Depreciation,Povoliť mesačné odpisy,
+Number of Depreciations Booked,Počet Odpisy rezervované,
+Finance Books,Finančné knihy,
+Straight Line,Priamka,
+Double Declining Balance,double degresívne,
+Manual,Manuálny,
+Value After Depreciation,Hodnota po odpisoch,
+Total Number of Depreciations,Celkový počet Odpisy,
+Frequency of Depreciation (Months),Frekvencia odpisy (mesiace),
+Next Depreciation Date,Vedľa Odpisy Dátum,
+Depreciation Schedule,plán odpisy,
+Depreciation Schedules,odpisy Plány,
+Policy number,Číslo politiky,
+Insurer,poisťovateľ,
+Insured value,Poistná hodnota,
+Insurance Start Date,Dátum začatia poistenia,
+Insurance End Date,Dátum ukončenia poistenia,
+Comprehensive Insurance,Komplexné poistenie,
+Maintenance Required,Požadovaná údržba,
+Check if Asset requires Preventive Maintenance or Calibration,"Skontrolujte, či si aktívum vyžaduje preventívnu údržbu alebo kalibráciu",
+Booked Fixed Asset,Rezervovaný dlhodobý majetok,
+Purchase Receipt Amount,Čiastka kúpnej sumy,
+Default Finance Book,Predvolená kniha financií,
+Quality Manager,Manažér kvality,
+Asset Category Name,Asset názov kategórie,
+Depreciation Options,Možnosti odpisovania,
+Enable Capital Work in Progress Accounting,Povoliť kapitálové účtovníctvo v priebehu,
+Finance Book Detail,Detail knihy financií,
+Asset Category Account,Asset Kategórie Account,
+Fixed Asset Account,Fixed Asset Account,
+Accumulated Depreciation Account,účet oprávok,
+Depreciation Expense Account,Odpisy Náklady účtu,
+Capital Work In Progress Account,Účet Kapitálu Rozrobenosti,
+Asset Finance Book,Asset Finance Book,
+Written Down Value,Písomná hodnota,
+Depreciation Start Date,Dátum začiatku odpisovania,
+Expected Value After Useful Life,Očakávaná hodnota po celú dobu životnosti,
+Rate of Depreciation,Miera odpisovania,
+In Percentage,V percentách,
+Select Serial No,Vyberte položku Sériové číslo,
+Maintenance Team,Tím údržby,
+Maintenance Manager Name,Meno správcu údržby,
+Maintenance Tasks,Úlohy údržby,
+Manufacturing User,Používateľ výroby,
+Asset Maintenance Log,Denník údržby majetku,
+ACC-AML-.YYYY.-,ACC-AML-.YYYY.-,
+Maintenance Type,Typ Maintenance,
+Maintenance Status,Status Maintenance,
+Planned,plánovaná,
+Actions performed,Vykonané akcie,
+Asset Maintenance Task,Úloha údržby majetku,
+Maintenance Task,Úloha údržby,
+Preventive Maintenance,Preventívna údržba,
+Calibration,Kalibrácia,
+2 Yearly,2 ročne,
+Certificate Required,Potrebný certifikát,
+Next Due Date,Ďalší dátum splatnosti,
+Last Completion Date,Posledný dátum dokončenia,
+Asset Maintenance Team,Tím na údržbu aktív,
+Maintenance Team Name,Názov tímu údržby,
+Maintenance Team Members,Členovia tímu údržby,
+Purpose,Účel,
+Stock Manager,Manažér zásob,
+Asset Movement Item,Položka na presun majetku,
+Source Location,Umiestnenie zdroja,
+From Employee,Od Zaměstnance,
+Target Location,Miesto zacielenia,
+To Employee,Zamestnanec,
+Asset Repair,Oprava majetku,
+ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-,
+Failure Date,Dátum zlyhania,
+Assign To Name,Priradiť k názvu,
+Repair Status,Stav opravy,
+Error Description,Popis chyby,
+Downtime,prestoje,
+Repair Cost,Náklady na opravu,
+Manufacturing Manager,Výrobný riaditeľ,
+Current Asset Value,Aktuálna hodnota aktív,
+New Asset Value,Nová hodnota majetku,
+Make Depreciation Entry,Urobiť Odpisy Entry,
+Finance Book Id,ID finančnej knihy,
+Location Name,Názov miesta,
+Parent Location,Umiestnenie rodičov,
+Is Container,Je kontajner,
+Check if it is a hydroponic unit,"Skontrolujte, či ide o hydroponickú jednotku",
+Location Details,Podrobné informácie o polohe,
+Latitude,zemepisná šírka,
+Longitude,zemepisná dĺžka,
+Area,rozloha,
+Area UOM,Oblasť UOM,
+Tree Details,Tree Podrobnosti,
+Maintenance Team Member,Člen tímu údržby,
+Team Member,Člen tímu,
+Maintenance Role,Úloha údržby,
+Buying Settings,Nastavenie nákupu,
+Settings for Buying Module,Nastavenie pre modul Nákupy,
+Supplier Naming By,Pomenovanie dodávateľa podľa,
+Default Supplier Group,Predvolená skupina dodávateľov,
+Default Buying Price List,Predvolený nákupný cenník,
+Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu,
+Allow Item to be added multiple times in a transaction,"Povoliť položky, ktoré sa pridávajú viackrát v transakcii",
+Backflush Raw Materials of Subcontract Based On,Backflush Suroviny subdodávateľských služieb založené na,
+Material Transferred for Subcontract,Materiál prenesený na subdodávateľskú zmluvu,
+Over Transfer Allowance (%),Preplatok za prevod (%),
+Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,"Percentuálny podiel, ktorý môžete previesť viac oproti objednanému množstvu. Napríklad: Ak ste si objednali 100 kusov. a váš príspevok je 10%, potom môžete previesť 110 jednotiek.",
+PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
+Get Items from Open Material Requests,Získať predmety z žiadostí Otvoriť Materiál,
+Required By,Vyžadováno,
+Order Confirmation No,Potvrdenie objednávky č,
+Order Confirmation Date,Dátum potvrdenia objednávky,
+Customer Mobile No,Zákazník Mobile Žiadne,
+Customer Contact Email,Kontaktný e-mail zákazníka,
+Set Target Warehouse,Nastaviť cieľový sklad,
+Supply Raw Materials,Dodávok surovín,
+Purchase Order Pricing Rule,Pravidlo stanovenia ceny objednávky,
+Set Reserve Warehouse,Nastaviť rezervný sklad,
+In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce.",
+Advance Paid,Vyplacené zálohy,
+% Billed,% Fakturovaných,
+% Received,% Prijaté,
+Ref SQ,Ref SQ,
+Inter Company Order Reference,Referencia objednávky medzi spoločnosťami,
+Supplier Part Number,Dodavatel Číslo dílu,
+Billed Amt,Fakturovaná čiastka,
+Warehouse and Reference,Sklad a reference,
+To be delivered to customer,Ak chcete byť doručený zákazníkovi,
+Material Request Item,Materiál Žádost o bod,
+Supplier Quotation Item,Položka dodávateľskej ponuky,
+Against Blanket Order,Proti paušálnej objednávke,
+Blanket Order,Objednávka prikrývky,
+Blanket Order Rate,Dekoračná objednávka,
+Returned Qty,Vrátené Množstvo,
+Purchase Order Item Supplied,Dodané položky vydané objednávky,
+BOM Detail No,BOM Detail No,
+Stock Uom,Skladová MJ,
+Raw Material Item Code,Surovina Kód položky,
+Supplied Qty,Dodávané Množstvo,
+Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané,
+Current Stock,Current skladem,
+PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
+For individual supplier,Pre jednotlivé dodávateľa,
+Supplier Detail,Detail dodávateľa,
+Message for Supplier,Správa pre dodávateľov,
+Request for Quotation Item,Žiadosť o cenovú ponuku výtlačku,
+Required Date,Požadovaná data,
+Request for Quotation Supplier,Žiadosť o cenovú ponuku dodávateľa,
+Send Email,Odoslať email,
+Quote Status,Citácia Stav,
+Download PDF,Stiahnuť PDF,
+Supplier of Goods or Services.,Dodavatel zboží nebo služeb.,
+Name and Type,Názov a typ,
+SUP-.YYYY.-,SUP-.YYYY.-,
+Default Bank Account,Prednastavený Bankový účet,
+Is Transporter,Je Transporter,
+Represents Company,Reprezentuje spoločnosť,
+Supplier Type,Dodavatel Type,
+Warn RFQs,Upozornenie na RFQ,
+Warn POs,Upozorňujte organizácie výrobcov,
+Prevent RFQs,Zabráňte RFQ,
+Prevent POs,Zabráňte organizáciám výrobcov,
+Billing Currency,Mena fakturácie,
+Default Payment Terms Template,Šablóna predvolených platobných podmienok,
+Block Supplier,Zablokovať dodávateľa,
+Hold Type,Typ zadržania,
+Leave blank if the Supplier is blocked indefinitely,"Nechajte prázdne, ak je Dodávateľ blokovaný neurčito",
+Default Payable Accounts,Výchozí úplatu účty,
+Mention if non-standard payable account,"Uveďte, či je neštandardný splatný účet",
+Default Tax Withholding Config,Predvolená kont,
+Supplier Details,Detaily dodávateľa,
+Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel,
+PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-,
+Supplier Address,Dodavatel Address,
+Link to material requests,Odkaz na materiálnych požiadaviek,
+Rounding Adjustment (Company Currency,Zaokrúhľovanie úprav (mena spoločnosti,
+Auto Repeat Section,Sekcia Auto Repeat,
+Is Subcontracted,Subdodavatelům,
+Lead Time in days,Vek Obchodnej iniciatívy v dňoch,
+Supplier Score,Skóre dodávateľa,
+Indicator Color,Farba indikátora,
+Evaluation Period,Hodnotiace obdobie,
+Per Week,Za týždeň,
+Per Month,Za mesiac,
+Per Year,Za rok,
+Scoring Setup,Nastavenie bodovania,
+Weighting Function,Funkcia váženia,
+"Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n","Možno použiť premenné tabuľky výsledkov, rovnako ako: {total_score} (celkové skóre z tohto obdobia), {period_number} (počet období do súčasnosti)",
+Scoring Standings,Skóre bodov,
+Criteria Setup,Nastavenie kritérií,
+Load All Criteria,Načítať všetky kritériá,
+Scoring Criteria,Kritériá hodnotenia,
+Scorecard Actions,Akcie Scorecard,
+Warn for new Request for Quotations,Upozornenie na novú žiadosť o ponuku,
+Warn for new Purchase Orders,Upozornenie na nové nákupné objednávky,
+Notify Supplier,Informujte dodávateľa,
+Notify Employee,Upozorniť zamestnanca,
+Supplier Scorecard Criteria,Kritériá hodnotiacej tabuľky dodávateľa,
+Criteria Name,Názov kritéria,
+Max Score,Maximálny výsledok,
+Criteria Formula,Kritérium vzorca,
+Criteria Weight,Hmotnosť kritérií,
+Supplier Scorecard Period,Termín dodacieho obdobia dodávateľa,
+PU-SSP-.YYYY.-,PU-SSP-.YYYY.-,
+Period Score,Skóre obdobia,
+Calculations,Výpočty,
+Criteria,kritériá,
+Variables,Premenné,
+Supplier Scorecard Setup,Nastavenie tabuľky dodávateľov,
+Supplier Scorecard Scoring Criteria,Hodnotiace kritériá pre dodávateľa Scorecard,
+Score,skóre,
+Supplier Scorecard Scoring Standing,Hodnotenie skóre dodávateľa,
+Standing Name,Stály názov,
+Min Grade,Min Grade,
+Max Grade,Max stupeň,
+Warn Purchase Orders,Upozornenie na nákupné objednávky,
+Prevent Purchase Orders,Zabráňte nákupným objednávkam,
+Employee ,Zamestnanec,
+Supplier Scorecard Scoring Variable,Hodnota ukazovateľa skóre skóre dodávateľa,
+Variable Name,Názov premennej,
+Parameter Name,Názov parametra,
+Supplier Scorecard Standing,Hodnota karty dodávateľa je stála,
+Notify Other,Oznámiť iné,
+Supplier Scorecard Variable,Premenná ukazovateľa tabuľky dodávateľov,
+Call Log,Výpis hovorov,
+Received By,Prijaté od,
+Caller Information,Informácie o volajúcom,
+Contact Name,Meno kontaktu,
+Lead Name,Meno Obchodnej iniciatívy,
+Ringing,zvoniaci,
+Missed,vynechal,
+Call Duration in seconds,Trvanie hovoru v sekundách,
+Recording URL,Nahrávacia adresa URL,
+Communication Medium,Komunikační médium,
+Communication Medium Type,Typ komunikačného média,
+Voice,hlas,
+Catch All,Chytiť všetko,
+"If there is no assigned timeslot, then communication will be handled by this group","Ak nie je priradený žiadny časový rozvrh, komunikácia bude uskutočnená touto skupinou",
+Timeslots,Časové úseky,
+Communication Medium Timeslot,Komunikačné stredné časové pásmo,
+Employee Group,Skupina zamestnancov,
+Appointment,vymenovanie,
+Scheduled Time,Naplánovaný čas,
+Unverified,neoverený,
+Customer Details,Podrobnosti zákazníkov,
+Phone Number,Telefónne číslo,
+Skype ID,Skype identifikácia,
+Linked Documents,Prepojené dokumenty,
+Appointment With,Schôdzka s,
+Calendar Event,Udalosť kalendára,
+Appointment Booking Settings,Nastavenia rezervácie schôdzky,
+Enable Appointment Scheduling,Povoliť plánovanie schôdzky,
+Agent Details,Podrobnosti o agentovi,
+Availability Of Slots,Dostupnosť automatov,
+Number of Concurrent Appointments,Počet súbežných stretnutí,
+Agents,agents,
+Appointment Details,Podrobnosti o schôdzke,
+Appointment Duration (In Minutes),Trvanie stretnutia (v minútach),
+Notify Via Email,Upozorniť e-mailom,
+Notify customer and agent via email on the day of the appointment.,V deň stretnutia informujte zákazníka a agenta e-mailom.,
+Number of days appointments can be booked in advance,Počet dní schôdzky si môžete rezervovať vopred,
+Success Settings,Nastavenia úspechu,
+Success Redirect URL,Adresa URL presmerovania úspechu,
+"Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Nechajte doma prázdne. Ide o relatívnu adresu URL stránky, napríklad „about“ presmeruje na „https://yoursitename.com/about“",
+Appointment Booking Slots,Výherné automaty na schôdzky,
+From Time ,Času od,
+Campaign Email Schedule,Časový plán e-mailu kampane,
+Send After (days),Odoslať po (dni),
+Signed,podpísaný,
+Party User,Používateľ strany,
+Unsigned,nepodpísaný,
+Fulfilment Status,Stav plnenia,
+N/A,N / A,
+Unfulfilled,nesplnený,
+Partially Fulfilled,Čiastočne splnené,
+Fulfilled,splnené,
+Lapsed,odpadlý,
+Contract Period,Zmluvné obdobie,
+Signee Details,Signee Details,
+Signee,Signee,
+Signed On,Zapnuté,
+Contract Details,Detaily zmluvy,
+Contract Template,Šablóna zmluvy,
+Contract Terms,Zmluvné podmienky,
+Fulfilment Details,Podrobnosti o plnení,
+Requires Fulfilment,Vyžaduje splnenie,
+Fulfilment Deadline,Termín splnenia,
+Fulfilment Terms,Podmienky plnenia,
+Contract Fulfilment Checklist,Kontrolný zoznam plnenia zmluvy,
+Requirement,požiadavka,
+Contract Terms and Conditions,Zmluvné podmienky,
+Fulfilment Terms and Conditions,Zmluvné podmienky plnenia,
+Contract Template Fulfilment Terms,Zmluvné podmienky pre splnenie podmienok zmluvy,
+Email Campaign,E-mailová kampaň,
+Email Campaign For ,E-mailová kampaň pre,
+Lead is an Organization,Vedenie je organizácia,
+CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-,
+Person Name,Osoba Meno,
+Lost Quotation,stratil Citácia,
+Interested,Zájemci,
+Converted,Prevedené,
+Do Not Contact,Nekontaktujte,
+From Customer,Od Zákazníka,
+Campaign Name,Názov kampane,
+Follow Up,Nasleduj,
+Next Contact By,Další Kontakt By,
+Next Contact Date,Další Kontakt Datum,
+Address & Contact,Adresa a kontakt,
+Mobile No.,Mobile No.,
+Lead Type,Typ Iniciatívy,
+Channel Partner,Channel Partner,
+Consultant,Konzultant,
+Market Segment,Segment trhu,
+Industry,Průmysl,
+Request Type,Typ požadavku,
+Product Enquiry,Dotaz Product,
+Request for Information,Žádost o informace,
+Suggestions,Návrhy,
+Blog Subscriber,Blog Subscriber,
+Lost Reason Detail,Podrobnosti strateného dôvodu,
+Opportunity Lost Reason,Príležitosť stratila dôvod,
+Potential Sales Deal,Potenciální prodej,
+CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-,
+Opportunity From,Příležitost Z,
+Customer / Lead Name,Zákazník / Iniciatíva Meno,
+Opportunity Type,Typ Příležitosti,
+Converted By,Prevedené,
+Sales Stage,Predajná fáza,
+Lost Reason,Ztracené Důvod,
+To Discuss,K projednání,
+With Items,S položkami,
+Probability (%),Pravdepodobnosť (%),
+Contact Info,Kontaktné informácie,
+Customer / Lead Address,Adresa zákazníka/obchodnej iniciatívy,
+Contact Mobile No,Kontakt Mobil,
+Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň",
+Opportunity Date,Příležitost Datum,
+Opportunity Item,Položka Příležitosti,
+Basic Rate,Základná sadzba,
+Stage Name,Pseudonym,
+Term Name,termín Name,
+Term Start Date,Termín Dátum začatia,
+Term End Date,Termín Dátum ukončenia,
+Academics User,akademici Užívateľ,
+Academic Year Name,Akademický rok Meno,
+Article,článok,
+LMS User,Užívateľ LMS,
+Assessment Criteria Group,Hodnotiace kritériá Group,
+Assessment Group Name,Názov skupiny Assessment,
+Parent Assessment Group,Materská skupina Assessment,
+Assessment Name,Názov Assessment,
+Grading Scale,stupnica,
+Examiner,skúšajúci,
+Examiner Name,Meno Examiner,
+Supervisor,Nadriadený,
+Supervisor Name,Meno Supervisor,
+Evaluate,Ohodnotiť,
+Maximum Assessment Score,Maximálne skóre Assessment,
+Assessment Plan Criteria,Plan Assessment Criteria,
+Maximum Score,maximálny počet bodov,
+Total Score,Konečné skóre,
+Grade,stupeň,
+Assessment Result Detail,Posúdenie Detail Výsledok,
+Assessment Result Tool,Assessment Tool Výsledok,
+Result HTML,výsledok HTML,
+Content Activity,Obsahová aktivita,
+Last Activity ,Posledná aktivita,
+Content Question,Otázka obsahu,
+Question Link,Odkaz na otázku,
+Course Name,Názov kurzu,
+Topics,témy,
+Hero Image,Obrázok hrdiny,
+Default Grading Scale,Predvolené Stupnica,
+Education Manager,Správca vzdelávania,
+Course Activity,Aktivita kurzu,
+Course Enrollment,Zápis do kurzu,
+Activity Date,Dátum aktivity,
+Course Assessment Criteria,Hodnotiace kritériá kurz,
+Weightage,Weightage,
+Course Content,Obsah kurzu,
+Quiz,kvíz,
+Program Enrollment,Registrácia do programu,
+Enrollment Date,zápis Dátum,
+Instructor Name,inštruktor Name,
+EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-,
+Course Scheduling Tool,Samozrejme Plánovanie Tool,
+Course Start Date,Začiatok Samozrejme Dátum,
+To TIme,Chcete-li čas,
+Course End Date,Koniec Samozrejme Dátum,
+Course Topic,Téma kurzu,
+Topic,téma,
+Topic Name,Názov témy,
+Education Settings,Nastavenia vzdelávania,
+Current Academic Year,Súčasný akademický rok,
+Current Academic Term,Aktuálny akademický výraz,
+Attendance Freeze Date,Účasť,
+Validate Batch for Students in Student Group,Overenie dávky pre študentov v študentskej skupine,
+"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",V prípade dávkovej študentskej skupiny bude študentská dávka schválená pre každého študenta zo zápisu do programu.,
+Validate Enrolled Course for Students in Student Group,Overiť zapísaný kurz pre študentov v študentskej skupine,
+"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",V prípade kurzov študentskej skupiny bude kurz potvrdený pre každého študenta z prihlásených kurzov pri zaradení do programu.,
+Make Academic Term Mandatory,Akademický termín je povinný,
+"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ak je povolené, pole Akademický termín bude povinné v programe Program registrácie.",
+Instructor Records to be created by,"Záznamy inštruktorov, ktoré vytvorí",
+Employee Number,Počet zaměstnanců,
+LMS Settings,Nastavenia LMS,
+Enable LMS,Povoliť LMS,
+LMS Title,Názov LMS,
+Fee Category,poplatok Kategórie,
+Fee Component,poplatok Component,
+Fees Category,kategórie poplatky,
+Fee Schedule,poplatok Plán,
+Fee Structure,štruktúra poplatkov,
+EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-,
+Fee Creation Status,Stav tvorby poplatkov,
+In Process,V procesu,
+Send Payment Request Email,Poslať e-mail s požiadavkou na platbu,
+Student Category,študent Kategórie,
+Fee Breakup for each student,Poplatok za každý študent,
+Total Amount per Student,Celková suma na študenta,
+Institution,inštitúcie,
+Fee Schedule Program,Program rozpisu poplatkov,
+Student Batch,študent Batch,
+Total Students,Celkový počet študentov,
+Fee Schedule Student Group,Poplatkový študijný program,
+EDU-FST-.YYYY.-,EDU-FST-.YYYY.-,
+EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-,
+Include Payment,Zahrňte platbu,
+Send Payment Request,Odoslať žiadosť o platbu,
+Student Details,Podrobnosti študenta,
+Student Email,Študentský e-mail,
+Grading Scale Name,Stupnica Name,
+Grading Scale Intervals,Triedenie dielikov,
+Intervals,intervaly,
+Grading Scale Interval,Stupnica Interval,
+Grade Code,grade Code,
+Threshold,Prah,
+Grade Description,grade Popis,
+Guardian,poručník,
+Guardian Name,Meno Guardian,
+Alternate Number,Alternatívne Number,
+Occupation,povolania,
+Work Address,pracovná adresa,
+Guardian Of ,Guardian Of,
+Students,študenti,
+Guardian Interests,Guardian záujmy,
+Guardian Interest,Guardian Záujem,
+Interest,záujem,
+Guardian Student,Guardian Student,
+EDU-INS-.YYYY.-,EDU-INS-.YYYY.-,
+Instructor Log,Denník inštruktorov,
+Other details,Ďalšie podrobnosti,
+Option,voľba,
+Is Correct,Je správne,
+Program Name,Názov programu,
+Program Abbreviation,program Skratka,
+Courses,predmety,
+Is Published,Publikované,
+Allow Self Enroll,Povoliť vlastné prihlásenie,
+Is Featured,Je odporúčané,
+Intro Video,Úvodné video,
+Program Course,program kurzu,
+School House,School House,
+Boarding Student,Stravovanie Študent,
+Check this if the Student is residing at the Institute's Hostel.,"Skontrolujte, či študent býva v hosteli inštitútu.",
+Walking,chôdza,
+Institute's Bus,Autobus ústavu,
+Public Transport,Verejná doprava,
+Self-Driving Vehicle,Samohybné vozidlo,
+Pick/Drop by Guardian,Pick / Drop od Guardian,
+Enrolled courses,Zapísané kurzy,
+Program Enrollment Course,Program na zápis do programu,
+Program Enrollment Fee,program zápisné,
+Program Enrollment Tool,Program Tool zápis,
+Get Students From,Získať študentov z,
+Student Applicant,študent Žiadateľ,
+Get Students,získať študentov,
+Enrollment Details,Podrobnosti o registrácii,
+New Program,nový program,
+New Student Batch,Nová študentská dávka,
+Enroll Students,zapísať študenti,
+New Academic Year,Nový akademický rok,
+New Academic Term,Nový akademický termín,
+Program Enrollment Tool Student,Registrácia do programu Student Tool,
+Student Batch Name,Študent Batch Name,
+Program Fee,program Fee,
+Question,otázka,
+Single Correct Answer,Jedna správna odpoveď,
+Multiple Correct Answer,Viacnásobná správna odpoveď,
+Quiz Configuration,Konfigurácia testu,
+Passing Score,Skóre skóre,
+Score out of 100,Skóre zo 100,
+Max Attempts,Max Pokusy,
+Enter 0 to waive limit,"Ak chcete upustiť od limitu, zadajte 0",
+Grading Basis,Základ klasifikácie,
+Latest Highest Score,Najvyššie skóre,
+Latest Attempt,Najnovší pokus,
+Quiz Activity,Kvízová aktivita,
+Enrollment,Zápis,
+Pass,priechod,
+Quiz Question,Kvízová otázka,
+Quiz Result,Výsledok testu,
+Selected Option,Vybraná možnosť,
+Correct,korektné,
+Wrong,zle,
+Room Name,Room Meno,
+Room Number,Číslo izby,
+Seating Capacity,Počet miest na sedenie,
+House Name,Meno dom,
+EDU-STU-.YYYY.-,EDU-STU-.YYYY.-,
+Student Mobile Number,Študent Číslo mobilného telefónu,
+Joining Date,spájanie Dátum,
+Blood Group,Krevní Skupina,
+A+,A +,
+A-,A-,
+B+,B +,
+B-,B-,
+O+,O +,
+O-,O-,
+AB+,AB +,
+AB-,AB-,
+Nationality,národnosť,
+Home Address,Adresa bydliska,
+Guardian Details,Guardian Podrobnosti,
+Guardians,Guardians,
+Sibling Details,súrodenec Podrobnosti,
+Siblings,súrodenci,
+Exit,Východ,
+Date of Leaving,Dátum odchodu,
+Leaving Certificate Number,maturita číslo,
+Student Admission,študent Vstupné,
+Application Form Route,prihláška Trasa,
+Admission Start Date,Vstupné Dátum začatia,
+Admission End Date,Vstupné Dátum ukončenia,
+Publish on website,Publikovať na webových stránkach,
+Eligibility and Details,Oprávnenosť a podrobnosti,
+Student Admission Program,Prijímací program pre študentov,
+Minimum Age,Minimálny vek,
+Maximum Age,Maximálny vek,
+Application Fee,Poplatok za prihlášku,
+Naming Series (for Student Applicant),Pomenovanie Series (pre študentské prihlasovateľ),
+LMS Only,Iba LMS,
+EDU-APP-.YYYY.-,EDU-APP-.YYYY.-,
+Application Status,stav aplikácie,
+Application Date,aplikácie Dátum,
+Student Attendance Tool,Študent Účasť Tool,
+Students HTML,študenti HTML,
+Group Based on,Skupina založená na,
+Student Group Name,Meno Študent Group,
+Max Strength,Max Sila,
+Set 0 for no limit,Nastavte 0 pre žiadny limit,
+Instructors,inštruktori,
+Student Group Creation Tool,Študent Group Tool Creation,
+Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne",
+Get Courses,získať kurzy,
+Separate course based Group for every Batch,Samostatná skupina kurzov pre každú dávku,
+Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechajte nezačiarknuté, ak nechcete zohľadňovať dávku pri zaradení do skupín.",
+Student Group Creation Tool Course,Študent Group Creation Tool ihrisko,
+Course Code,kód predmetu,
+Student Group Instructor,Inštruktor skupiny študentov,
+Student Group Student,Študent Skupina Student,
+Group Roll Number,Číslo skupiny rollov,
+Student Guardian,študent Guardian,
+Relation,Vztah,
+Mother,matka,
+Father,otec,
+Student Language,študent Language,
+Student Leave Application,Študent nechať aplikáciu,
+Mark as Present,Označiť ako prítomný,
+Will show the student as Present in Student Monthly Attendance Report,Ukáže na študenta bol prítomný v Student mesačnú návštevnosť Správa,
+Student Log,študent Log,
+Academic,akademický,
+Achievement,úspech,
+Student Report Generation Tool,Nástroj na generovanie správ študentov,
+Include All Assessment Group,Zahrnúť celú hodnotiacu skupinu,
+Show Marks,Zobraziť značky,
+Add letterhead,Pridať hlavičkový papier,
+Print Section,Tlačiť sekciu,
+Total Parents Teacher Meeting,Celkové stretnutie učiteľov rodičov,
+Attended by Parents,Zúčastnili sa rodičia,
+Assessment Terms,Hodnotiace podmienky,
+Student Sibling,študent Súrodenec,
+Studying in Same Institute,Štúdium v Same ústave,
+Student Siblings,študentské Súrodenci,
+Topic Content,Obsah témy,
+Amazon MWS Settings,Amazon MWS Settings,
+ERPNext Integrations,ERPNext integrácie,
+Enable Amazon,Povoliť Amazon,
+MWS Credentials,Poverenia MWS,
+Seller ID,ID predávajúceho,
+AWS Access Key ID,Identifikátor prístupového kľúča AWS,
+MWS Auth Token,MWS Auth Token,
+Market Place ID,ID miesta na trhu,
+AU,AU,
+BR,BR,
+CA,CA,
+CN,CN,
+DE,DE,
+ES,ES,
+FR,FR,
+JP,JP,
+IT,IT,
+UK,Spojené kráľovstvo,
+US,US,
+Customer Type,Typ zákazníka,
+Market Place Account Group,Skupina účtov na trhu,
+After Date,Po dátume,
+Amazon will synch data updated after this date,Spoločnosť Amazon bude synchronizovať údaje aktualizované po tomto dátume,
+Get financial breakup of Taxes and charges data by Amazon ,Získajte finančné rozdelenie údajov o daniach a poplatkoch od spoločnosti Amazon,
+Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačidlo vyberiete údaje o predajnej objednávke od spoločnosti Amazon MWS.,
+Check this to enable a scheduled Daily synchronization routine via scheduler,"Začiarknite toto, ak chcete povoliť plánovanú dennú synchronizáciu prostredníctvom plánovača",
+Max Retry Limit,Maximálny limit opakovania,
+Exotel Settings,Nastavenia exotelu,
+Account SID,SID účtu,
+API Token,Rozhranie API,
+GoCardless Mandate,GoCardless Mandate,
+Mandate,mandát,
+GoCardless Customer,Zákazník spoločnosti GoCardless,
+GoCardless Settings,Nastavenia GoCardless,
+Webhooks Secret,Webhooks Secret,
+Plaid Settings,Plaid Settings,
+Synchronize all accounts every hour,Synchronizujte všetky účty každú hodinu,
+Plaid Client ID,ID platného klienta,
+Plaid Secret,Plaid Secret,
+Plaid Public Key,Plaid Public Key,
+Plaid Environment,Plaid Environment,
+sandbox,pieskovisko,
+development,vývoj,
+QuickBooks Migrator,QuickBooks Migrator,
+Application Settings,Nastavenia aplikácie,
+Token Endpoint,Koncový bod tokenu,
+Scope,Rozsah,
+Authorization Settings,Nastavenia autorizácie,
+Authorization Endpoint,Koncový bod autorizácie,
+Authorization URL,Autorizačná adresa URL,
+Quickbooks Company ID,Identifikátor spoločnosti Quickbooks,
+Company Settings,Nastavenia firmy,
+Default Shipping Account,Predvolený dodací účet,
+Default Warehouse,Predvolený sklad,
+Default Cost Center,Predvolené nákladové stredisko,
+Undeposited Funds Account,Účet neukladaných finančných prostriedkov,
+Shopify Log,Obchodný záznam,
+Request Data,Vyžiadajte si údaje,
+Shopify Settings,Nastavenie nakupovania,
+status html,status html,
+Enable Shopify,Povoliť funkciu Shopify,
+App Type,Typ aplikácie,
+Last Sync Datetime,Dátum posledného synchronizácie,
+Shop URL,Adresa URL obchodu,
+eg: frappe.myshopify.com,napr .: frappe.myshopify.com,
+Shared secret,Zdieľané tajomstvo,
+Webhooks Details,Webhooks Details,
+Webhooks,Webhooks,
+Customer Settings,Nastavenia zákazníka,
+Default Customer,Predvolený zákazník,
+"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ak služba Shopify neobsahuje zákazníka v objednávke, pri synchronizácii objednávok systém zváži objednávku predvoleného zákazníka",
+Customer Group will set to selected group while syncing customers from Shopify,Zákaznícka skupina nastaví vybranú skupinu pri synchronizácii zákazníkov so službou Shopify,
+For Company,Pre spoločnosť,
+Cash Account will used for Sales Invoice creation,Pokladničný účet sa použije na vytvorenie faktúry za predaj,
+Update Price from Shopify To ERPNext Price List,Aktualizovať cenu z Shopify do ERPNext Cenník,
+Default Warehouse to to create Sales Order and Delivery Note,Predvolená skladačka na vytvorenie objednávky predaja a dodacieho listu,
+Sales Order Series,Séria objednávok,
+Import Delivery Notes from Shopify on Shipment,Importovať doručené poznámky z Shopify pri odoslaní,
+Delivery Note Series,Séria dodacích poznámok,
+Import Sales Invoice from Shopify if Payment is marked,"Importovať faktúru z predaja, ak je platba označená",
+Sales Invoice Series,Séria predajných faktúr,
+Shopify Tax Account,Nakupujte daňový účet,
+Shopify Tax/Shipping Title,Nakupujte názov dane / plavby,
+ERPNext Account,Následný účet ERP,
+Shopify Webhook Detail,Nakupujte podrobnosti Webhook,
+Webhook ID,Webhook ID,
+Tally Migration,Tally Migration,
+Master Data,Hlavné dáta,
+Is Master Data Processed,Spracovávajú sa kmeňové údaje,
+Is Master Data Imported,Importujú sa kmeňové údaje,
+Tally Creditors Account,Účet veriteľov,
+Tally Debtors Account,Účet Tally dlžníkov,
+Tally Company,Spoločnosť Tally,
+ERPNext Company,ERPĎalšia spoločnosť,
+Processed Files,Spracované súbory,
+Parties,strany,
+UOMs,Merné Jednotky,
+Vouchers,poukážky,
+Round Off Account,Zaokrúhliť účet,
+Day Book Data,Údaje o dennej knihe,
+Is Day Book Data Processed,Spracovávajú sa údaje dennej knihy,
+Is Day Book Data Imported,Importujú sa údaje dennej knihy,
+Woocommerce Settings,Woocommerce Settings,
+Enable Sync,Povoliť synchronizáciu,
+Woocommerce Server URL,Woocommerce URL servera,
+Secret,tajomstvo,
+API consumer key,API spotrebiteľský kľúč,
+API consumer secret,API spotrebiteľské tajomstvo,
+Tax Account,Daňový účet,
+Freight and Forwarding Account,Účet pre prepravu a prepravu,
+Creation User,Vytvorenie používateľa,
+"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Používateľ, ktorý sa použije na vytvorenie zákazníkov, položiek a zákaziek odberateľa. Tento používateľ by mal mať príslušné povolenia.",
+"This warehouse will be used to create Sales Orders. The fallback warehouse is ""Stores"".",Tento sklad sa použije na vytvorenie zákaziek odberateľa. Núdzový sklad je „Obchody“.,
+"The fallback series is ""SO-WOO-"".",Záložná séria je „SO-WOO-“.,
+This company will be used to create Sales Orders.,Táto spoločnosť sa použije na vytvorenie zákaziek odberateľa.,
+Delivery After (Days),Dodanie po (dňoch),
+This is the default offset (days) for the Delivery Date in Sales Orders. The fallback offset is 7 days from the order placement date.,Toto je predvolený ofset (dni) pre Dátum dodania v zákazkách odberateľa. Náhradný odstup je 7 dní od dátumu zadania objednávky.,
+"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Toto je predvolené UOM použité pre položky a predajné objednávky. Záložná UOM je „Nos“.,
+Endpoints,Endpoints,
+Endpoint,Endpoint,
+Antibiotic Name,Názov antibiotika,
+Healthcare Administrator,Administrátor zdravotnej starostlivosti,
+Laboratory User,Laboratórny používateľ,
+Is Inpatient,Je hospitalizovaný,
+HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
+Procedure Template,Šablóna postupu,
+Procedure Prescription,Predpísaný postup,
+Service Unit,Servisná jednotka,
+Consumables,Spotrebný,
+Consume Stock,Spotreba akcií,
+Nursing User,Ošetrujúci používateľ,
+Clinical Procedure Item,Položka klinickej procedúry,
+Invoice Separately as Consumables,Faktúra samostatne ako spotrebný materiál,
+Transfer Qty,Množstvo prenosu,
+Actual Qty (at source/target),Skutečné množství (u zdroje/cíle),
+Is Billable,Je fakturovaná,
+Allow Stock Consumption,Povoliť skladovú zásobu,
+Collection Details,Podrobnosti zbierky,
+Codification Table,Kodifikačná tabuľka,
+Complaints,Sťažnosti,
+Dosage Strength,Pevnosť dávkovania,
+Strength,pevnosť,
+Drug Prescription,Predpísaný liek,
+Dosage,dávkovanie,
+Dosage by Time Interval,Dávkovanie podľa časového intervalu,
+Interval,interval,
+Interval UOM,Interval UOM,
+Hour,Hodina,
+Update Schedule,Aktualizovať plán,
+Max number of visit,Maximálny počet návštev,
+Visited yet,Navštívené,
+Mobile,Mobilné,
+Phone (R),Telefón (R),
+Phone (Office),Telefón (Office),
+Hospital,Nemocnica,
+Appointments,schôdzky,
+Practitioner Schedules,Pracovník plánuje,
+Charges,Poplatky,
+Default Currency,Predvolená mena,
+Healthcare Schedule Time Slot,Časový rozvrh časového harmonogramu zdravotnej starostlivosti,
+Parent Service Unit,Rodičovská služba,
+Service Unit Type,Typ servisnej jednotky,
+Allow Appointments,Povoliť schôdzky,
+Allow Overlap,Povoliť prekrytie,
+Inpatient Occupancy,Umiestnenie v nemocnici,
+Occupancy Status,Stav obsadenosti,
+Vacant,prázdny,
+Occupied,obsadený,
+Item Details,Položka Podrobnosti,
+UOM Conversion in Hours,UOM Konverzia v hodinách,
+Rate / UOM,Sadzba / MJ,
+Change in Item,Zmeniť položku,
+Out Patient Settings,Nastavenia pre pacienta,
+Patient Name By,Názov pacienta,
+Patient Name,Názov pacienta,
+"If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Ak je začiarknuté, vytvorí sa zákazník, zmapovaný na pacienta. Faktúry pacienta budú vytvorené voči tomuto zákazníkovi. Môžete tiež vybrať existujúceho zákazníka pri vytváraní pacienta.",
+Default Medical Code Standard,Predvolený štandard medicínskeho kódu,
+Collect Fee for Patient Registration,Získať poplatok za registráciu pacienta,
+Registration Fee,Registračný poplatok,
+Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Spravujte faktúru odstupňovania a automaticky zrušte za stretnutie pacienta,
+Valid Number of Days,Platný počet dní,
+Clinical Procedure Consumable Item,Klinický postup Spotrebný bod,
+Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Predpokladané výnosové účty, ktoré sa použijú, ak nie sú stanovené v zdravotníckom praktickom lekári na vyúčtovanie poplatkov za schôdzku.",
+Out Patient SMS Alerts,SMS upozorňovanie na pacientov,
+Patient Registration,Registrácia pacienta,
+Registration Message,Registrácia Správa,
+Confirmation Message,Potvrdzujúca správa,
+Avoid Confirmation,Vyhnite sa konfirmácii,
+Do not confirm if appointment is created for the same day,"Nepotvrdzujú, či sa schôdzka vytvorí v ten istý deň",
+Appointment Reminder,Pripomienka na menovanie,
+Reminder Message,Pripomenutie správy,
+Remind Before,Pripomenúť predtým,
+Laboratory Settings,Laboratórne nastavenia,
+Employee name and designation in print,Meno a označenie zamestnanca v tlači,
+Custom Signature in Print,Vlastný podpis v tlači,
+Laboratory SMS Alerts,Laboratórne SMS upozornenia,
+Check In,Prihlásiť sa,
+Check Out,Odhlásiť sa,
+HLC-INP-.YYYY.-,HLC-INP-.YYYY.-,
+A Positive,Pozitívny,
+A Negative,Negatívny,
+AB Positive,AB Pozitívny,
+AB Negative,AB Negatívny,
+B Positive,B Pozitívne,
+B Negative,B Negatívny,
+O Positive,O pozitívne,
+O Negative,O Negatívny,
+Date of birth,Dátum narodenia,
+Admission Scheduled,Prijatie naplánované,
+Discharge Scheduled,Plnenie je naplánované,
+Discharged,Vybitý,
+Admission Schedule Date,Dátum schôdze prijatia,
+Admitted Datetime,Pripravený dátum,
+Expected Discharge,Očakávané vybitie,
+Discharge Date,Dátum vykládky,
+Discharge Note,Poznámka o vyčerpaní,
+Lab Prescription,Lab Prescription,
+Test Created,Test bol vytvorený,
+LP-,LP-,
+Submitted Date,Dátum odoslania,
+Approved Date,Schválený dátum,
+Sample ID,ID vzorky,
+Lab Technician,Laboratórny technik,
+Technician Name,Názov technikov,
+Report Preference,Preferencia prehľadu,
+Test Name,Názov testu,
+Test Template,Šablóna testu,
+Test Group,Testovacia skupina,
+Custom Result,Vlastný výsledok,
+LabTest Approver,LabTest Approver,
+Lab Test Groups,Laboratórne testovacie skupiny,
+Add Test,Pridať test,
+Add new line,Pridať nový riadok,
+Normal Range,Normálny rozsah,
+Result Format,Formát výsledkov,
+"Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single pre výsledky, ktoré vyžadujú iba jeden vstup, výsledok UOM a normálnu hodnotu <br> Zlúčenina pre výsledky, ktoré vyžadujú viac vstupných polí so zodpovedajúcimi názvami udalostí, výsledok UOM a normálne hodnoty <br> Popisné pre testy, ktoré majú viaceré komponenty výsledkov a zodpovedajúce polia zadávania výsledkov. <br> Zoskupené pre testovacie šablóny, ktoré sú skupinou iných testovacích šablón. <br> Žiadny výsledok pre testy bez výsledkov. Taktiež nie je vytvorený žiadny test Lab. eg. Podskupiny pre zoskupené výsledky.",
+Single,Slobodný/á,
+Compound,zlúčenina,
+Descriptive,opisný,
+Grouped,zoskupené,
+No Result,žiadny výsledok,
+"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Ak nie je začiarknuté, položka sa nezobrazí v faktúre predaja, ale môže sa použiť pri vytváraní testov skupiny.",
+This value is updated in the Default Sales Price List.,Táto hodnota sa aktualizuje v Predvolenom zozname cien predaja.,
+Lab Routine,Lab Rutine,
+Special,špeciálna,
+Normal Test Items,Normálne testované položky,
+Result Value,Výsledná hodnota,
+Require Result Value,Vyžadovať výslednú hodnotu,
+Normal Test Template,Normálna šablóna testu,
+Patient Demographics,Demografia pacienta,
+HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
+Inpatient Status,Stav lôžka,
+Personal and Social History,Osobná a sociálna história,
+Marital Status,Rodinný stav,
+Married,Ženatý,
+Divorced,Rozvedený,
+Widow,vdova,
+Patient Relation,Vzťah pacientov,
+"Allergies, Medical and Surgical History","Alergie, lekárske a chirurgické dejepisy",
+Allergies,alergie,
+Medication,liečenie,
+Medical History,História medicíny,
+Surgical History,Chirurgická história,
+Risk Factors,Rizikové faktory,
+Occupational Hazards and Environmental Factors,Pracovné nebezpečenstvo a environmentálne faktory,
+Other Risk Factors,Ďalšie rizikové faktory,
+Patient Details,Podrobnosti o pacientoch,
+Additional information regarding the patient,Ďalšie informácie týkajúce sa pacienta,
+Patient Age,Vek pacienta,
+More Info,Více informací,
+Referring Practitioner,Odporúčajúci lekár,
+Reminded,pripomenul,
+Parameters,parametre,
+HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
+Encounter Date,Dátum stretnutia,
+Encounter Time,Stretnutie s časom,
+Encounter Impression,Zaznamenajte zobrazenie,
+In print,V tlači,
+Medical Coding,Lekárske kódovanie,
+Procedures,postupy,
+Review Details,Prehľad podrobností,
+HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
+Spouse,manželka,
+Family,Rodina,
+Schedule Name,Názov plánu,
+Time Slots,Časové úseky,
+Practitioner Service Unit Schedule,Časový plán služby pre praktizujúcich,
+Procedure Name,Názov procedúry,
+Appointment Booked,Schôdza rezervovaná,
+Procedure Created,Postup bol vytvorený,
+HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
+Collected By,Zhromaždené podľa,
+Collected Time,Zhromaždený čas,
+No. of print,Počet potlače,
+Sensitivity Test Items,Položky testu citlivosti,
+Special Test Items,Špeciálne testovacie položky,
+Particulars,podrobnosti,
+Special Test Template,Špeciálna šablóna testu,
+Result Component,Zložka výsledkov,
+Body Temperature,Teplota tela,
+Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prítomnosť horúčky (teplota&gt; 38,5 ° C alebo udržiavaná teplota&gt; 38 ° C / 100,4 ° F)",
+Heart Rate / Pulse,Srdcová frekvencia / pulz,
+Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Dávka dospelých sa pohybuje od 50 do 80 úderov za minútu.,
+Respiratory rate,Dýchacia frekvencia,
+Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normálny referenčný rozsah pre dospelého je 16-20 dych / minúta (RCP 2012),
+Tongue,jazyk,
+Coated,obalený,
+Very Coated,Veľmi potiahnuté,
+Normal,normálne,
+Furry,srstnatý,
+Cuts,rezy,
+Abdomen,brucho,
+Bloated,nafúknutý,
+Fluid,tekutina,
+Constipated,zápchu,
+Reflexes,reflexy,
+Hyper,hyper,
+Very Hyper,Veľmi Hyper,
+One Sided,Jednostranné,
+Blood Pressure (systolic),Krvný tlak (systolický),
+Blood Pressure (diastolic),Krvný tlak (diastolický),
+Blood Pressure,Krvný tlak,
+"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normálny pokojový krvný tlak u dospelého pacienta je približne 120 mmHg systolický a diastolický 80 mmHg, skrátený &quot;120/80 mmHg&quot;",
+Nutrition Values,Výživové hodnoty,
+Height (In Meter),Výška (v metre),
+Weight (In Kilogram),Hmotnosť (v kilogramoch),
+BMI,BMI,
+Hotel Room,Hotelová izba,
+Hotel Room Type,Typ izby hotela,
+Capacity,kapacita,
+Extra Bed Capacity,Kapacita prístelky,
+Hotel Manager,Hotelový manažér,
+Hotel Room Amenity,Hotel Amenity,
+Billable,Zúčtovatelná,
+Hotel Room Package,Balík hotelových izieb,
+Amenities,Vybavenie,
+Hotel Room Pricing,Ceny izieb v hoteli,
+Hotel Room Pricing Item,Položka ceny izieb hotela,
+Hotel Room Pricing Package,Balík ceny izieb v hoteli,
+Hotel Room Reservation,Rezervácia izieb v hoteli,
+Guest Name,Meno hosťa,
+Late Checkin,Neskoro checkin,
+Booked,rezervovaný,
+Hotel Reservation User,Používateľ rezervácie hotelov,
+Hotel Room Reservation Item,Položka rezervácie izieb hotela,
+Hotel Settings,Nastavenia hotela,
+Default Taxes and Charges,Východiskové Dane a poplatky,
+Default Invoice Naming Series,Predvolená séria pomenovaní faktúr,
+Additional Salary,Dodatočný plat,
+HR,HR,
+HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-,
+Salary Component,Komponent platu,
+Overwrite Salary Structure Amount,Prepísať sumu štruktúry platu,
+Deduct Full Tax on Selected Payroll Date,Odpočítajte plnú daň na vybraný dátum výplaty,
+Payroll Date,Dátum mzdy,
+Date on which this component is applied,"Dátum, kedy sa táto zložka použije",
+Salary Slip,Výplatná páska,
+Salary Component Type,Typ platového komponentu,
+HR User,HR User,
+Appointment Letter,Menovací list,
+Job Applicant,Job Žadatel,
+Applicant Name,Meno žiadateľa,
+Appointment Date,Dátum stretnutia,
+Appointment Letter Template,Šablóna menovacieho listu,
+Body,telo,
+Closing Notes,Záverečné poznámky,
+Appointment Letter content,Obsah menovacieho listu,
+Appraisal,Ocenění,
+HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.,
+Appraisal Template,Posouzení Template,
+For Employee Name,Pro jméno zaměstnance,
+Goals,Ciele,
+Calculate Total Score,Vypočítať celkové skóre,
+Total Score (Out of 5),Celkové skóre (Out of 5),
+"Any other remarks, noteworthy effort that should go in the records.","Akékoľvek iné poznámky, pozoruhodné úsilie, ktoré by mali ísť v záznamoch.",
+Appraisal Goal,Posouzení Goal,
+Key Responsibility Area,Key Odpovědnost Area,
+Weightage (%),Weightage (%),
+Score (0-5),Score (0-5),
+Score Earned,Skóre Zasloužené,
+Appraisal Template Title,Posouzení Template Název,
+Appraisal Template Goal,Posouzení Template Goal,
+KRA,KRA,
+Key Performance Area,Key Performance Area,
+HR-ATT-.YYYY.-,HR-ATT-.YYYY.-,
+On Leave,Na odchode,
+Work From Home,Práca z domu,
+Leave Application,Aplikácia na priepustky,
+Attendance Date,Účast Datum,
+Attendance Request,Žiadosť o účasť,
+Late Entry,Neskorý vstup,
+Early Exit,Skorý východ,
+Half Day Date,Half Day Date,
+On Duty,V službe,
+Explanation,vysvetlenie,
+Compensatory Leave Request,Žiadosť o kompenzačnú dovolenku,
+Leave Allocation,Nechte Allocation,
+Worked On Holiday,Pracoval na dovolenke,
+Work From Date,Práca od dátumu,
+Work End Date,Dátum ukončenia práce,
+Select Users,Vyberte používateľov,
+Send Emails At,Posielať e-maily At,
+Reminder,pripomienka,
+Daily Work Summary Group User,Používateľ skupiny pre denné zhrnutie práce,
+Parent Department,Rodičovské oddelenie,
+Leave Block List,Nechte Block List,
+Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení.",
+Leave Approvers,Schvaľovatelia priepustiek,
+Leave Approver,Schvaľovateľ voľna,
+The first Leave Approver in the list will be set as the default Leave Approver.,Prvý prideľovač odchýlok v zozname bude nastavený ako predvolený neprístupný.,
+Expense Approvers,Sprostredkovatelia výdavkov,
+Expense Approver,Schvalovatel výdajů,
+The first Expense Approver in the list will be set as the default Expense Approver.,Prvý odhadovač výdavkov v zozname bude nastavený ako predvolený odhadovač nákladov.,
+Department Approver,Schôdza oddelenia,
+Approver,Schvalovatel,
+Required Skills,Požadované zručnosti,
+Skills,zručností,
+Designation Skill,Označenie Zručnosť,
+Skill,zručnosť,
+Driver,vodič,
+HR-DRI-.YYYY.-,HR-DRI-.YYYY.-,
+Suspended,suspendovaný,
+Transporter,prepravca,
+Applicable for external driver,Platí pre externý ovládač,
+Cellphone Number,Mobilné číslo,
+License Details,Detaily licencie,
+License Number,Číslo licencie,
+Issuing Date,Dátum vydania,
+Driving License Categories,Kategórie vodičských preukazov,
+Driving License Category,Kategória vodičského preukazu,
+Fleet Manager,fleet manager,
+Driver licence class,Trieda vodičského preukazu,
+HR-EMP-,HR-EMP,
+Employment Type,Typ zaměstnání,
+Emergency Contact,Kontakt v nouzi,
+Emergency Contact Name,Núdzové kontaktné meno,
+Emergency Phone,Nouzový telefon,
+ERPNext User,ERPĎalší používateľ,
+"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR.",
+Create User Permission,Vytvoriť povolenie používateľa,
+This will restrict user access to other employee records,Tým sa obmedzí prístup používateľov k iným záznamom zamestnancov,
+Joining Details,Podrobnosti spojenia,
+Offer Date,Dátum Ponuky,
+Confirmation Date,Dátum potvrdenia,
+Contract End Date,Smlouva Datum ukončení,
+Notice (days),Oznámenie (dni),
+Date Of Retirement,Dátum odchodu do dôchodku,
+Department and Grade,Oddelenie a trieda,
+Reports to,Zprávy,
+Attendance and Leave Details,Účasť a podrobnosti o dovolenke,
+Leave Policy,Opustiť pravidlá,
+Attendance Device ID (Biometric/RF tag ID),ID dochádzkového zariadenia (biometrické / RF ID značky),
+Applicable Holiday List,Použitelný Seznam Svátků,
+Default Shift,Predvolená zmena,
+Salary Details,Podrobnosti platu,
+Salary Mode,Mode Plat,
+Bank A/C No.,"Č, bank. účtu",
+Health Insurance,Zdravotné poistenie,
+Health Insurance Provider,Poskytovateľ zdravotného poistenia,
+Health Insurance No,Zdravotné poistenie č,
+Prefered Email,preferovaný Email,
+Personal Email,Osobný e-mail,
+Permanent Address Is,Trvalé bydliště je,
+Rented,Pronajato,
+Owned,Vlastník,
+Permanent Address,Trvalé bydliště,
+Prefered Contact Email,Preferovaný Kontaktný e-mail,
+Company Email,E-mail spoločnosti,
+Provide Email Address registered in company,Poskytnúť e-mailovú adresu registrovanú vo firme,
+Current Address Is,Aktuálna adresa je,
+Current Address,Aktuálna adresa,
+Personal Bio,Osobná bio,
+Bio / Cover Letter,Bio / Cover Letter,
+Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.,
+Passport Number,Číslo pasu,
+Date of Issue,Datum vydání,
+Place of Issue,Místo vydání,
+Widowed,Ovdovělý,
+Family Background,Rodinné pomery,
+"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi",
+Health Details,Zdravotní Podrobnosti,
+"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd",
+Educational Qualification,Vzdělávací Kvalifikace,
+Previous Work Experience,Předchozí pracovní zkušenosti,
+External Work History,Vnější práce History,
+History In Company,Historie ve Společnosti,
+Internal Work History,Vnitřní práce History,
+Resignation Letter Date,Rezignace Letter Datum,
+Relieving Date,Uvolnění Datum,
+Reason for Leaving,Dôvod priepustky,
+Leave Encashed?,Ponechte zpeněžení?,
+Encashment Date,Inkaso Datum,
+Exit Interview Details,Exit Rozhovor Podrobnosti,
+Held On,Které se konalo dne,
+Reason for Resignation,Dôvod rezignácie,
+Better Prospects,Lepší vyhlídky,
+Health Concerns,Zdravotní Obavy,
+New Workplace,Nové pracovisko,
+HR-EAD-.YYYY.-,HR-EAD-.YYYY.-,
+Due Advance Amount,Splatná výška zálohy,
+Returned Amount,Vrátená suma,
+Claimed,vyhlasoval,
+Advance Account,Advance účet,
+Employee Attendance Tool,Účasť zamestnancov Tool,
+Unmarked Attendance,Neoznačené Návštevnosť,
+Employees HTML,Zamestnanci HTML,
+Marked Attendance,Výrazná Návštevnosť,
+Marked Attendance HTML,Výrazná Účasť HTML,
+Employee Benefit Application,Žiadosť o zamestnanecké požitky,
+Max Benefits (Yearly),Maximálne výhody (ročné),
+Remaining Benefits (Yearly),Zvyšné výhody (ročné),
+Payroll Period,Mzdové obdobie,
+Benefits Applied,Výhody aplikované,
+Dispensed Amount (Pro-rated),Vyčlenená čiastka (premenná),
+Employee Benefit Application Detail,Podrobnosti o žiadosti o zamestnanecké benefity,
+Earning Component,Zisková zložka,
+Pay Against Benefit Claim,Platba proti nároku na dávku,
+Max Benefit Amount,Maximálna výška dávky,
+Employee Benefit Claim,Požiadavka na zamestnanecké požitky,
+Claim Date,Dátum nároku,
+Benefit Type and Amount,Druh dávky a výška dávky,
+Claim Benefit For,Nárok na dávku pre,
+Max Amount Eligible,Maximálna výška oprávnenia,
+Expense Proof,Dôkaz o nákladoch,
+Employee Boarding Activity,Aktivita nástupu zamestnancov,
+Activity Name,Názov aktivity,
+Task Weight,úloha Hmotnosť,
+Required for Employee Creation,Požadované pre tvorbu zamestnancov,
+Applicable in the case of Employee Onboarding,Platí v prípade zamestnania na palube,
+Employee Checkin,Kontrola zamestnancov,
+Log Type,Typ denníka,
+OUT,VON,
+Location / Device ID,Miesto / ID zariadenia,
+Skip Auto Attendance,Preskočiť automatickú účasť,
+Shift Start,Shift Start,
+Shift End,Shift End,
+Shift Actual Start,Shift Skutočný štart,
+Shift Actual End,Presunúť skutočný koniec,
+Employee Education,Vzdelávanie zamestnancov,
+School/University,Škola / University,
+Graduate,Absolvent,
+Post Graduate,Postgraduální,
+Under Graduate,Za absolventa,
+Year of Passing,Rok Passing,
+Class / Percentage,Třída / Procento,
+Major/Optional Subjects,Hlavní / Volitelné předměty,
+Employee External Work History,Externá pracovná história zamestnanca,
+Total Experience,Celková zkušenost,
+Default Leave Policy,Predvolené pravidlá pre dovolenku,
+Default Salary Structure,Štandardná platová štruktúra,
+Employee Group Table,Tabuľka skupiny zamestnancov,
+ERPNext User ID,ERPĎalšie ID používateľa,
+Employee Health Insurance,Zdravotné poistenie zamestnancov,
+Health Insurance Name,Názov zdravotného poistenia,
+Employee Incentive,Zamestnanecké stimuly,
+Incentive Amount,Suma stimuly,
+Employee Internal Work History,Interní historie práce zaměstnance,
+Employee Onboarding,Zamestnanec na palube,
+Notify users by email,Upozorniť používateľov e-mailom,
+Employee Onboarding Template,Šablóna zamestnancov na palube,
+Activities,aktivity,
+Employee Onboarding Activity,Činnosť zamestnancov na palube,
+Employee Promotion,Podpora zamestnancov,
+Promotion Date,Dátum propagácie,
+Employee Promotion Details,Podrobnosti o podpore zamestnancov,
+Employee Promotion Detail,Podrobnosti o propagácii zamestnancov,
+Employee Property History,História vlastníctva zamestnancov,
+Employee Separation,Oddelenie zamestnancov,
+Employee Separation Template,Šablóna oddelenia zamestnancov,
+Exit Interview Summary,Ukončiť zhrnutie rozhovoru,
+Employee Skill,Zručnosť zamestnancov,
+Proficiency,zručnosť,
+Evaluation Date,Dátum vyhodnotenia,
+Employee Skill Map,Mapa zručností zamestnancov,
+Employee Skills,Zručnosti zamestnancov,
+Trainings,tréningy,
+Employee Tax Exemption Category,Kategória oslobodenia od dane z príjmov zamestnancov,
+Max Exemption Amount,Maximálna suma výnimky,
+Employee Tax Exemption Declaration,Vyhlásenie o oslobodení od dane z príjmu zamestnancov,
+Declarations,vyhlásenie,
+Total Declared Amount,Celková deklarovaná suma,
+Total Exemption Amount,Celková suma oslobodenia od dane,
+Employee Tax Exemption Declaration Category,Vyhlásenie o oslobodení od dane zamestnancov,
+Exemption Sub Category,Výnimka Podkategória,
+Exemption Category,Kategória výnimky,
+Maximum Exempted Amount,Maximálna oslobodená suma,
+Declared Amount,Deklarovaná suma,
+Employee Tax Exemption Proof Submission,Oslobodenie od dane z oslobodenia od dane zamestnancov,
+Submission Date,Dátum predloženia,
+Tax Exemption Proofs,Dôkazy o oslobodení od dane,
+Total Actual Amount,Celková skutočná suma,
+Employee Tax Exemption Proof Submission Detail,Podrobnosti o predložení dokladu o oslobodení od dane zamestnanca,
+Maximum Exemption Amount,Maximálna výška výnimky,
+Type of Proof,Druh dôkazu,
+Actual Amount,Skutočná suma,
+Employee Tax Exemption Sub Category,Oslobodenie od dane pre zamestnancov,
+Tax Exemption Category,Kategória oslobodenia od dane,
+Employee Training,Školenie zamestnancov,
+Training Date,Dátum školenia,
+Employee Transfer,Prevod zamestnancov,
+Transfer Date,Dátum prenosu,
+Employee Transfer Details,Podrobnosti o zamestnancovi,
+Employee Transfer Detail,Podrobnosti o zamestnancovi,
+Re-allocate Leaves,Prerozdeľte listy,
+Create New Employee Id,Vytvoriť nové číslo zamestnanca,
+New Employee ID,Nové číslo zamestnanca,
+Employee Transfer Property,Vlastníctvo prevodu zamestnancov,
+HR-EXP-.YYYY.-,HR-EXP-.YYYY.-,
+Expense Taxes and Charges,Dane a poplatky za výdavky,
+Total Sanctioned Amount,Celková částka potrestána,
+Total Advance Amount,Celková čiastka preddavku,
+Total Claimed Amount,Celkem žalované částky,
+Total Amount Reimbursed,Celkovej sumy vyplatenej,
+Vehicle Log,jázd,
+Employees Email Id,Email ID zamestnanca,
+Expense Claim Account,Náklady na poistné Account,
+Expense Claim Advance,Nároky na nárok na výdavky,
+Unclaimed amount,Nevyžiadaná suma,
+Expense Claim Detail,Detail úhrady výdajů,
+Expense Date,Datum výdaje,
+Expense Claim Type,Náklady na pojistná Type,
+Holiday List Name,Názov zoznamu sviatkov,
+Total Holidays,Celkové prázdniny,
+Add Weekly Holidays,Pridajte týždenné sviatky,
+Weekly Off,Týdenní Off,
+Add to Holidays,Pridať do sviatkov,
+Holidays,Prázdniny,
+Clear Table,Clear Table,
+HR Settings,Nastavení HR,
+Employee Settings,Nastavení zaměstnanců,
+Retirement Age,dôchodkový vek,
+Enter retirement age in years,Zadajte vek odchodu do dôchodku v rokoch,
+Employee Records to be created by,Zamestnanecké záznamy na vytvorenie kým,
+Employee record is created using selected field. ,Zamestnanecký záznam sa vytvorí použitím vybraného poľa,
+Stop Birthday Reminders,Zastaviť pripomenutie narodenín,
+Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin,
+Expense Approver Mandatory In Expense Claim,Povinnosť priraďovania nákladov v nárokoch na výdavky,
+Payroll Settings,Nastavení Mzdové,
+Max working hours against Timesheet,Maximálna pracovná doba proti časového rozvrhu,
+Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní,
+"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den",
+"If checked, hides and disables Rounded Total field in Salary Slips","Ak je toto políčko začiarknuté, skryje a zakáže pole Zaokrúhlený celkový počet v mzdových listoch",
+Email Salary Slip to Employee,Email výplatnej páske pre zamestnancov,
+Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatnej páske, aby zamestnanci na základe prednostného e-mailu vybraného v zamestnaneckých",
+Encrypt Salary Slips in Emails,Zašifrujte výplatné pásky v e-mailoch,
+"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","E-mail s platom zaslaný zamestnancovi bude chránený heslom, heslo sa vygeneruje na základe politiky hesiel.",
+Password Policy,Zásady hesla,
+<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Príklad:</b> SAL- {first_name} - {date_of_birth.year} <br> Takto sa vygeneruje heslo ako SAL-Jane-1972,
+Leave Settings,Nechajte nastavenia,
+Leave Approval Notification Template,Ponechať šablónu oznámenia o schválení,
+Leave Status Notification Template,Opustiť šablónu oznamovania stavu,
+Role Allowed to Create Backdated Leave Application,Úloha povolená na vytvorenie aplikácie s opusteným dátumom,
+Leave Approver Mandatory In Leave Application,Povolenie odchýlky je povinné v aplikácii zanechať,
+Show Leaves Of All Department Members In Calendar,Zobraziť listy všetkých členov katedry v kalendári,
+Auto Leave Encashment,Automatické opustenie inkasa,
+Restrict Backdated Leave Application,Obmedzte aplikáciu neaktuálnej dovolenky,
+Hiring Settings,Nastavenia prijímania,
+Check Vacancies On Job Offer Creation,Skontrolujte voľné pracovné miesta pri vytváraní pracovných ponúk,
+Identification Document Type,Identifikačný typ dokumentu,
+Standard Tax Exemption Amount,Suma štandardného oslobodenia od dane,
+Taxable Salary Slabs,Zdaniteľné platové platne,
+Applicant for a Job,Žadatel o zaměstnání,
+Accepted,Přijato,
+Job Opening,Job Zahájení,
+Cover Letter,Sprievodný list,
+Resume Attachment,Resume Attachment,
+Job Applicant Source,Zdroj žiadateľa o zamestnanie,
+Applicant Email Address,E-mailová adresa žiadateľa,
+Awaiting Response,Čaká odpoveď,
+Job Offer Terms,Podmienky ponuky práce,
+Select Terms and Conditions,Vyberte Podmienky,
+Printing Details,Detaily tlače,
+Job Offer Term,Ponuka pracovnej doby,
+Offer Term,Ponuka Term,
+Value / Description,Hodnota / Popis,
+Description of a Job Opening,Popis jednoho volných pozic,
+Job Title,Názov pozície,
+Staffing Plan,Personálny plán,
+Planned number of Positions,Plánovaný počet pozícií,
+"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd.",
+HR-LAL-.YYYY.-,HR-LAL-.YYYY.-,
+Allocation,Pridelenie,
+New Leaves Allocated,Nové Listy Přidělené,
+Add unused leaves from previous allocations,Pridať nevyužité listy z predchádzajúcich prídelov,
+Unused leaves,Nepoužité listy,
+Total Leaves Allocated,Celkem Leaves Přidělené,
+Total Leaves Encashed,Celkový počet zapuzdrených listov,
+Leave Period,Opustiť obdobie,
+Carry Forwarded Leaves,Carry Předáno listy,
+Apply / Approve Leaves,Použít / Schválit listy,
+HR-LAP-.YYYY.-,HR-LAP-.YYYY.-,
+Leave Balance Before Application,Nechte zůstatek před aplikací,
+Total Leave Days,Celkový počet dnů dovolené,
+Leave Approver Name,Meno schvaľovateľa priepustky,
+Follow via Email,Sledovať e-mailom,
+Block Holidays on important days.,Blokové Dovolená na významných dnů.,
+Leave Block List Name,Nechte Jméno Block List,
+Applies to Company,Platí pre firmu,
+"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit.",
+Block Days,Blokové dny,
+Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.,
+Leave Block List Dates,Nechte Block List termíny,
+Allow Users,Povolit uživatele,
+Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.,
+Leave Block List Allowed,Nechte Block List povolena,
+Leave Block List Allow,Nechte Block List Povolit,
+Allow User,Umožňuje uživateli,
+Leave Block List Date,Nechte Block List Datum,
+Block Date,Block Datum,
+Leave Control Panel,Nechte Ovládací panely,
+Select Employees,Vybrať Zamestnanci,
+Employment Type (optional),Druh zamestnania (voliteľné),
+Branch (optional),Pobočka (voliteľné),
+Department (optional),Oddelenie (voliteľné),
+Designation (optional),Označenie (voliteľné),
+Employee Grade (optional),Trieda zamestnanca (voliteľné),
+Employee (optional),Zamestnanec (voliteľné),
+Allocate Leaves,Prideliť listy,
+Carry Forward,Preniesť,
+Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku",
+New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech),
+Allocate,Přidělit,
+Leave Balance,Nechajte zostatok,
+Encashable days,Zapamätateľné dni,
+Encashment Amount,Suma inkasa,
+Leave Ledger Entry,Opustiť zadanie knihy,
+Transaction Name,Názov transakcie,
+Is Carry Forward,Je převádět,
+Is Expired,Platnosť vypršala,
+Is Leave Without Pay,Je odísť bez Pay,
+Holiday List for Optional Leave,Dovolenkový zoznam pre voliteľnú dovolenku,
+Leave Allocations,Ponechajte alokácie,
+Leave Policy Details,Nechajte detaily pravidiel,
+Leave Policy Detail,Zanechať podrobnosti o pravidlách,
+Annual Allocation,Ročné pridelenie,
+Leave Type Name,Nechte Typ Jméno,
+Max Leaves Allowed,Max povolené povolenia,
+Applicable After (Working Days),Platné po (pracovné dni),
+Maximum Continuous Days Applicable,Maximálne nepretržité dni,
+Is Optional Leave,Je voliteľná dovolenka,
+Allow Negative Balance,Povolit záporný zůstatek,
+Include holidays within leaves as leaves,Zahrnúť dovolenku v listoch sú listy,
+Is Compensatory,Je kompenzačný,
+Maximum Carry Forwarded Leaves,Maximálny počet prepravených listov,
+Expire Carry Forwarded Leaves (Days),Platnosť doručených listov (dní),
+Calculated in days,Vypočítané v dňoch,
+Encashment,inkaso,
+Allow Encashment,Povoliť zaplnenie,
+Encashment Threshold Days,Denné prahové hodnoty pre inkasovanie,
+Earned Leave,Získaná dovolenka,
+Is Earned Leave,Získaná dovolenka,
+Earned Leave Frequency,Frekvencia získanej dovolenky,
+Rounding,zaokrúhľovania,
+Payroll Employee Detail,Mzdový detail zamestnancov,
+Payroll Frequency,mzdové frekvencia,
+Fortnightly,dvojtýždňové,
+Bimonthly,dvojmesačne,
+Employees,zamestnanci,
+Number Of Employees,Počet zamestnancov,
+Employee Details,Podrobnosti o zaměstnanci,
+Validate Attendance,Overenie účasti,
+Salary Slip Based on Timesheet,Plat Slip na základe časového rozvrhu,
+Select Payroll Period,Vyberte mzdové,
+Deduct Tax For Unclaimed Employee Benefits,Odpočítajte daň za nevyžiadané zamestnanecké výhody,
+Deduct Tax For Unsubmitted Tax Exemption Proof,Odpočítajte daň z nezdaniteľnej daňovej výnimky,
+Select Payment Account to make Bank Entry,"Vybrať Platobný účet, aby Bank Entry",
+Salary Slips Created,Vytvorené platobné pásky,
+Salary Slips Submitted,Príspevky na platy boli odoslané,
+Payroll Periods,Mzdové obdobia,
+Payroll Period Date,Dátum mzdového obdobia,
+Purpose of Travel,Účel cesty,
+Retention Bonus,Retenčný bonus,
+Bonus Payment Date,Dátum výplaty bonusu,
+Bonus Amount,Bonusová suma,
+Abbr,Zkr,
+Depends on Payment Days,Závisí od platobných dní,
+Is Tax Applicable,Je možné uplatniť daň,
+Variable Based On Taxable Salary,Premenná založená na zdaniteľnom platu,
+Round to the Nearest Integer,Zaokrúhlite na najbližšie celé číslo,
+Statistical Component,Štatistická zložka,
+"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Ak je vybratá, hodnota špecifikovaná alebo vypočítaná v tejto zložke neprispieva k výnosom alebo odpočtom. Avšak, jeho hodnota môže byť odkazovaná na iné komponenty, ktoré môžu byť pridané alebo odpočítané.",
+Flexible Benefits,Flexibilné výhody,
+Is Flexible Benefit,Je flexibilný prínos,
+Max Benefit Amount (Yearly),Maximálna výška dávky (ročná),
+Only Tax Impact (Cannot Claim But Part of Taxable Income),"Iba daňový vplyv (nemožno nárokovať, ale časť zdaniteľného príjmu)",
+Create Separate Payment Entry Against Benefit Claim,Vytvorte samostatné zadanie platby pred nárokom na dávku,
+Condition and Formula,Podmienka a vzorec,
+Amount based on formula,Suma podľa vzorca,
+Formula,vzorec,
+Salary Detail,Detail platu,
+Component,komponentov,
+Do not include in total,Nezaradenie celkom,
+Default Amount,Výchozí částka,
+Additional Amount,Dodatočná suma,
+Tax on flexible benefit,Daň z flexibilného prínosu,
+Tax on additional salary,Daň z dodatočného platu,
+Condition and Formula Help,Nápoveda pre podmienky a vzorce,
+Salary Structure,Štruktúra platu,
+Working Days,Pracovní dny,
+Salary Slip Timesheet,Plat Slip časový rozvrh,
+Total Working Hours,Celkovej pracovnej doby,
+Hour Rate,Hodinová sadzba,
+Bank Account No.,Číslo bankového účtu,
+Earning & Deduction,Príjem a odpočty,
+Earnings,Príjmy,
+Deductions,Odpočty,
+Employee Loan,Pôžička zamestnanca,
+Total Principal Amount,Celková hlavná čiastka,
+Total Interest Amount,Celková výška úroku,
+Total Loan Repayment,celkové splátky,
+net pay info,Čistá mzda info,
+Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Total dedukcie - splátky,
+Total in words,Celkem slovy,
+Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce.",
+Salary Component for timesheet based payroll.,Plat komponentov pre mzdy časového rozvrhu.,
+Leave Encashment Amount Per Day,Ponechajte sumu zaplatenia za deň,
+Max Benefits (Amount),Maximálne výhody (čiastka),
+Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.,
+Total Earning,Celkem Zisk,
+Salary Structure Assignment,Priradenie štruktúry platov,
+Shift Assignment,Presunutie posunu,
+Shift Type,Typ posunu,
+Shift Request,Žiadosť o posun,
+Enable Auto Attendance,Povoliť automatickú účasť,
+Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Označte účasť na základe kontroly zamestnancov pre zamestnancov priradených k tejto zmene.,
+Auto Attendance Settings,Nastavenia automatickej dochádzky,
+Determine Check-in and Check-out,Určite nahlásenie a odhlásenie,
+Alternating entries as IN and OUT during the same shift,Striedanie záznamov ako IN a OUT počas tej istej zmeny,
+Strictly based on Log Type in Employee Checkin,Prísne na základe typu denníka pri kontrole zamestnancov,
+Working Hours Calculation Based On,Výpočet pracovnej doby na základe,
+First Check-in and Last Check-out,Prvé prihlásenie a posledné prihlásenie,
+Every Valid Check-in and Check-out,Každá platná check-in a check-out,
+Begin check-in before shift start time (in minutes),Začať registráciu pred začiatkom smeny (v minútach),
+The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začiatkom zmeny, počas ktorého sa za účasť považuje registrácia zamestnancov.",
+Allow check-out after shift end time (in minutes),Povoliť odhlásenie po čase ukončenia zmeny (v minútach),
+Time after the end of shift during which check-out is considered for attendance.,"Čas po ukončení zmeny, počas ktorého sa check-out považuje za účasť.",
+Working Hours Threshold for Half Day,Prah pracovných hodín na pol dňa,
+Working hours below which Half Day is marked. (Zero to disable),"Pracovné hodiny, pod ktorými je vyznačený poldeň. (Nulovanie na deaktiváciu)",
+Working Hours Threshold for Absent,Prah pracovných hodín pre neprítomnosť,
+Working hours below which Absent is marked. (Zero to disable),"Pracovná doba, pod ktorou je označená neprítomnosť. (Nulovanie na deaktiváciu)",
+Process Attendance After,Účasť na procese po,
+Attendance will be marked automatically only after this date.,Účasť bude automaticky označená až po tomto dátume.,
+Last Sync of Checkin,Posledná synchronizácia Checkin,
+Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,"Posledná známa úspešná synchronizácia kontroly zamestnancov. Obnovte to, iba ak ste si istí, že všetky protokoly sú synchronizované zo všetkých miest. Ak si nie ste niečím istí, neupravujte to.",
+Grace Period Settings For Auto Attendance,Nastavenie doby odkladu pre automatickú účasť,
+Enable Entry Grace Period,Povoliť obdobie odkladu vstupu,
+Late Entry Grace Period,Obdobie odkladu vstupu,
+The time after the shift start time when check-in is considered as late (in minutes).,"Čas po začiatku začatia zmeny, keď sa nahlásenie považuje za oneskorené (v minútach).",
+Enable Exit Grace Period,Povoliť ukončovacie obdobie odkladu,
+Early Exit Grace Period,Predčasné ukončenie odkladu,
+The time before the shift end time when check-out is considered as early (in minutes).,"Čas pred ukončením zmeny, keď sa check-out považuje za skorý (v minútach).",
+Skill Name,Názov zručnosti,
+Staffing Plan Details,Podrobnosti personálneho plánu,
+Staffing Plan Detail,Podrobný plán personálneho plánu,
+Total Estimated Budget,Celkový odhadovaný rozpočet,
+Vacancies,voľné miesta,
+Estimated Cost Per Position,Odhadovaná cena za pozíciu,
+Total Estimated Cost,Celkové odhadované náklady,
+Current Count,Aktuálny počet,
+Current Openings,Aktuálne otvorenia,
+Number Of Positions,Počet pozícií,
+Taxable Salary Slab,Zdaniteľné platové dosky,
+From Amount,Z čiastky,
+To Amount,Suma,
+Percent Deduction,Percentuálna zrážka,
+Training Program,Tréningový program,
+Event Status,event Status,
+Has Certificate,Má certifikát,
+Seminar,seminár,
+Theory,teória,
+Workshop,Dielňa,
+Conference,konferencie,
+Exam,skúška,
+Internet,internet,
+Self-Study,Samoštúdium,
+Advance,záloha,
+Trainer Name,Meno tréner,
+Trainer Email,tréner Email,
+Attendees,Účastníci,
+Employee Emails,E-maily zamestnancov,
+Training Event Employee,Vzdelávanie zamestnancov Event,
+Invited,pozvaný,
+Feedback Submitted,Spätná väzba Vložené,
+Optional,voliteľný,
+Training Result Employee,vzdelávacie Výsledok,
+Travel Itinerary,Cestovný itinerár,
+Travel From,Cestovanie z,
+Travel To,Cestovať do,
+Mode of Travel,Spôsob cestovania,
+Flight,Let,
+Train,Vlak,
+Taxi,taxi,
+Rented Car,Nájomné auto,
+Meal Preference,Preferencia jedla,
+Vegetarian,vegetarián,
+Non-Vegetarian,Non-vegetariánska,
+Gluten Free,Bezlepkový,
+Non Diary,Bez deníku,
+Travel Advance Required,Cestovanie Advance Povinné,
+Departure Datetime,Dátum odchodu,
+Arrival Datetime,Dátum príchodu,
+Lodging Required,Požadované ubytovanie,
+Preferred Area for Lodging,Preferovaná oblasť ubytovania,
+Check-in Date,Dátum registrácie,
+Check-out Date,Dátum odchodu,
+Travel Request,Žiadosť o cestu,
+Travel Type,Typ cesty,
+Domestic,domáci,
+International,medzinárodný,
+Travel Funding,Cestovné financovanie,
+Require Full Funding,Vyžadovať úplné financovanie,
+Fully Sponsored,Plne sponzorované,
+"Partially Sponsored, Require Partial Funding","Čiastočne sponzorované, vyžadujú čiastočné financovanie",
+Copy of Invitation/Announcement,Kópia pozvánky / oznámenia,
+"Details of Sponsor (Name, Location)","Podrobnosti sponzora (meno, miesto)",
+Identification Document Number,Identifikačné číslo dokladu,
+Any other details,Ďalšie podrobnosti,
+Costing Details,Podrobnosti o kalkulácii,
+Costing,Rozpočet,
+Event Details,Podrobnosti udalosti,
+Name of Organizer,Názov organizátora,
+Address of Organizer,Adresa organizátora,
+Travel Request Costing,Kalkulácia požiadaviek na cesty,
+Expense Type,Typ výdavkov,
+Sponsored Amount,Sponzorovaná čiastka,
+Funded Amount,Finančná čiastka,
+Upload Attendance,Nahráť Dochádzku,
+Attendance From Date,Účast Datum od,
+Attendance To Date,Účast na data,
+Get Template,Získat šablonu,
+Import Attendance,Importovat Docházku,
+Upload HTML,Nahrát HTML,
+Vehicle,vozidlo,
+License Plate,Poznávacia značka,
+Odometer Value (Last),Hodnota počítadla kilometrov (Last),
+Acquisition Date,akvizície Dátum,
+Chassis No,Číslo podvozku,
+Vehicle Value,hodnota vozidla,
+Insurance Details,poistenie Podrobnosti,
+Insurance Company,Poisťovňa,
+Policy No,nie politika,
+Additional Details,Ďalšie podrobnosti,
+Fuel Type,Druh paliva,
+Petrol,benzín,
+Diesel,Diesel,
+Natural Gas,Zemný plyn,
+Electric,elektrický,
+Fuel UOM,palivo UOM,
+Last Carbon Check,Posledné Carbon Check,
+Wheels,kolesá,
+Doors,dvere,
+HR-VLOG-.YYYY.-,HR-Vlog-.YYYY.-,
+Odometer Reading,stav tachometra,
+Current Odometer value ,Aktuálna hodnota počítadla kilometrov,
+last Odometer Value ,posledná hodnota počítadla kilometrov,
+Refuelling Details,tankovacie Podrobnosti,
+Invoice Ref,faktúra Ref,
+Service Details,Podrobnosti o službe,
+Service Detail,servis Detail,
+Vehicle Service,servis vozidiel,
+Service Item,servis Položka,
+Brake Oil,Brake Oil,
+Brake Pad,Brzdová doštička,
+Clutch Plate,kotúč spojky,
+Engine Oil,Motorový olej,
+Oil Change,výmena oleja,
+Inspection,inšpekcia,
+Mileage,Najazdené,
+Hub Tracked Item,Pásová sledovaná položka,
+Hub Node,Hub Node,
+Image List,Zoznam obrázkov,
+Item Manager,Manažér položiek,
+Hub User,Používateľ Hubu,
+Hub Password,Heslo Hubu,
+Hub Users,Používatelia Hubu,
+Marketplace Settings,Nastavenia trhov,
+Disable Marketplace,Zakázať trhovisko,
+Marketplace URL (to hide and update label),Adresa URL Marketplace (skryť a aktualizovať štítok),
+Registered,registrovaný,
+Sync in Progress,Priebeh synchronizácie,
+Hub Seller Name,Názov predajcu Hubu,
+Custom Data,Vlastné údaje,
+Member,člen,
+Partially Disbursed,čiastočne Vyplatené,
+Loan Closure Requested,Vyžaduje sa uzavretie úveru,
+Repay From Salary,Splatiť z platu,
+Loan Details,pôžička Podrobnosti,
+Loan Type,pôžička Type,
+Loan Amount,Výška pôžičky,
+Is Secured Loan,Je zabezpečená pôžička,
+Rate of Interest (%) / Year,Úroková sadzba (%) / rok,
+Disbursement Date,vyplatenie Date,
+Disbursed Amount,Vyplatená suma,
+Is Term Loan,Je termín úver,
+Repayment Method,splácanie Method,
+Repay Fixed Amount per Period,Splácať paušálna čiastka za obdobie,
+Repay Over Number of Periods,Splatiť Over počet období,
+Repayment Period in Months,Doba splácania v mesiacoch,
+Monthly Repayment Amount,Mesačné splátky čiastka,
+Repayment Start Date,Dátum začiatku splácania,
+Loan Security Details,Podrobnosti o zabezpečení pôžičky,
+Maximum Loan Value,Maximálna hodnota úveru,
+Account Info,Informácie o účte,
+Loan Account,Úverový účet,
+Interest Income Account,Účet Úrokové výnosy,
+Penalty Income Account,Trestný účet,
+Repayment Schedule,splátkový kalendár,
+Total Payable Amount,Celková suma Splatné,
+Total Principal Paid,Celková zaplatená istina,
+Total Interest Payable,Celkové úroky splatné,
+Total Amount Paid,Celková čiastka bola zaplatená,
+Loan Manager,Úverový manažér,
+Loan Info,pôžička Informácie,
+Rate of Interest,Úroková sadzba,
+Proposed Pledges,Navrhované sľuby,
+Maximum Loan Amount,Maximálna výška úveru,
+Repayment Info,splácanie Info,
+Total Payable Interest,Celková splatný úrok,
+Loan Interest Accrual,Prírastok úrokov z úveru,
+Amounts,množstvo,
+Pending Principal Amount,Čakajúca hlavná suma,
+Payable Principal Amount,Splatná istina,
+Process Loan Interest Accrual,Časové rozlíšenie úrokov z úveru na spracovanie,
+Regular Payment,Pravidelná platba,
+Loan Closure,Uzavretie úveru,
+Payment Details,Platobné údaje,
+Interest Payable,Splatný úrok,
+Amount Paid,Zaplacené částky,
+Principal Amount Paid,Vyplatená istina,
+Loan Security Name,Názov zabezpečenia úveru,
+Loan Security Code,Bezpečnostný kód úveru,
+Loan Security Type,Druh zabezpečenia pôžičky,
+Haircut %,Zrážka%,
+Loan  Details,Podrobnosti o pôžičke,
+Unpledged,Unpledged,
+Pledged,zastavené,
+Partially Pledged,Čiastočne prisľúbené,
+Securities,cenné papiere,
+Total Security Value,Celková hodnota zabezpečenia,
+Loan Security Shortfall,Nedostatok úverovej bezpečnosti,
+Loan ,pôžička,
+Shortfall Time,Čas výpadku,
+America/New_York,America / New_York,
+Shortfall Amount,Suma schodku,
+Security Value ,Hodnota zabezpečenia,
+Process Loan Security Shortfall,Nedostatok zabezpečenia procesných úverov,
+Loan To Value Ratio,Pomer pôžičky k hodnote,
+Unpledge Time,Čas uvoľnenia,
+Unpledge Type,Unpledge Type,
+Loan Name,pôžička Name,
+Rate of Interest (%) Yearly,Úroková sadzba (%) Ročné,
+Penalty Interest Rate (%) Per Day,Trestná úroková sadzba (%) za deň,
+Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,V prípade omeškania splácania sa každý deň vyberá sankčná úroková sadzba z omeškanej úrokovej sadzby,
+Grace Period in Days,Milosť v dňoch,
+Pledge,zástava,
+Post Haircut Amount,Suma po zrážke,
+Update Time,Aktualizovať čas,
+Proposed Pledge,Navrhovaný prísľub,
+Total Payment,celkové platby,
+Balance Loan Amount,Bilancia Výška úveru,
+Is Accrued,Je nahromadené,
+Salary Slip Loan,Úverový splátkový úver,
+Loan Repayment Entry,Zadanie splátky úveru,
+Sanctioned Loan Amount,Suma schváleného úveru,
+Sanctioned Amount Limit,Sankčný limit sumy,
+Unpledge,Unpledge,
+Against Pledge,Proti prísľube,
+Haircut,strih,
+MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
+Generate Schedule,Generování plán,
+Schedules,Plány,
+Maintenance Schedule Detail,Plán údržby Detail,
+Scheduled Date,Plánované datum,
+Actual Date,Skutečné datum,
+Maintenance Schedule Item,Plán údržby Item,
+No of Visits,Počet návštěv,
+MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
+Maintenance Date,Datum údržby,
+Maintenance Time,Údržba Time,
+Completion Status,Dokončení Status,
+Partially Completed,Částečně Dokončeno,
+Fully Completed,Plně Dokončeno,
+Unscheduled,Neplánovaná,
+Breakdown,Rozbor,
+Purposes,Cíle,
+Customer Feedback,Zpätná väzba od zákazníkov,
+Maintenance Visit Purpose,Maintenance Visit Účel,
+Work Done,Odvedenou práci,
+Against Document No,Proti dokumentu č,
+Against Document Detail No,Proti Detail dokumentu č,
+MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-,
+Order Type,Typ objednávky,
+Blanket Order Item,Objednávka tovaru,
+Ordered Quantity,Objednané množstvo,
+Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena,
+Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin,
+Set rate of sub-assembly item based on BOM,Nastavte rýchlosť položky podsúboru na základe kusovníka,
+Allow Alternative Item,Povoliť alternatívnu položku,
+Item UOM,MJ položky,
+Conversion Rate,Konverzný kurz,
+Rate Of Materials Based On,Hodnotit materiálů na bázi,
+With Operations,S operacemi,
+Manage cost of operations,Správa nákladů na provoz,
+Transfer Material Against,Preneste materiál proti,
+Routing,Smerovanie,
+Materials,Materiály,
+Quality Inspection Required,Vyžaduje sa kontrola kvality,
+Quality Inspection Template,Šablóna inšpekcie kvality,
+Scrap,šrot,
+Scrap Items,šrot položky,
+Operating Cost,Provozní náklady,
+Raw Material Cost,Cena surovin,
+Scrap Material Cost,Šrot Material Cost,
+Operating Cost (Company Currency),Prevádzkové náklady (Company mena),
+Raw Material Cost (Company Currency),Náklady na suroviny (mena spoločnosti),
+Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company mena),
+Total Cost,Celkové náklady,
+Total Cost (Company Currency),Celkové náklady (mena spoločnosti),
+Materials Required (Exploded),Potřebný materiál (Rozložený),
+Exploded Items,Rozložené položky,
+Item Image (if not slideshow),Item Image (ne-li slideshow),
+Thumbnail,Thumbnail,
+Website Specifications,Webových stránek Specifikace,
+Show Items,Zobraziť položky,
+Show Operations,ukázať Operations,
+Website Description,Popis webu,
+BOM Explosion Item,BOM Explosion Item,
+Qty Consumed Per Unit,Množství spotřebované na jednotku,
+Include Item In Manufacturing,Zahrnúť položku do výroby,
+BOM Item,BOM Item,
+Item operation,Funkcia položky,
+Rate & Amount,Sadzba a množstvo,
+Basic Rate (Company Currency),Basic Rate (Company měny),
+Scrap %,Scrap%,
+Original Item,Pôvodná položka,
+BOM Operation,BOM Operation,
+Batch Size,Veľkosť šarže,
+Base Hour Rate(Company Currency),Základňa hodinová sadzba (Company meny),
+Operating Cost(Company Currency),Prevádzkové náklady (Company mena),
+BOM Scrap Item,BOM Scrap Item,
+Basic Amount (Company Currency),Základná suma (Company mena),
+BOM Update Tool,Nástroj na aktualizáciu kusovníka,
+"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.","Nahradiť konkrétny kusovník vo všetkých ostatných kusovníkoch, kde sa používa. Bude nahradiť starý odkaz BOM, aktualizovať cenu a obnoviť tabuľku &quot;BOM Explosion Item&quot; podľa nového kusovníka. Aktualizuje tiež poslednú cenu vo všetkých kusovníkoch.",
+Replace BOM,Nahraďte kusovník,
+Current BOM,Aktuální BOM,
+The BOM which will be replaced,"BOM, který bude nahrazen",
+The new BOM after replacement,Nový BOM po výměně,
+Replace,Vyměnit,
+Update latest price in all BOMs,Aktualizujte najnovšiu cenu vo všetkých kusovníkoch,
+BOM Website Item,BOM Website Item,
+BOM Website Operation,BOM Website Operation,
+Operation Time,Provozní doba,
+PO-JOB.#####,PO-JOB. #####,
+Timing Detail,Časový detail,
+Time Logs,Čas Záznamy,
+Total Time in Mins,Celkový čas v minútach,
+Transferred Qty,Přenesená Množství,
+Job Started,Úloha sa začala,
+Started Time,Čas začiatku,
+Current Time,Aktuálny čas,
+Job Card Item,Položka Job Card,
+Job Card Time Log,Denník pracovných kariet,
+Time In Mins,Čas v minútach,
+Completed Qty,Dokončené množstvo,
+Manufacturing Settings,Nastavenia Výroby,
+Raw Materials Consumption,Spotreba surovín,
+Allow Multiple Material Consumption,Povoliť viacnásobnú spotrebu materiálu,
+Allow multiple Material Consumption against a Work Order,Povoliť viacnásobnú spotrebu materiálu proti pracovnej objednávke,
+Backflush Raw Materials Based On,So spätným suroviny na základe,
+Material Transferred for Manufacture,Prevádza jadrový materiál pre Výroba,
+Capacity Planning,Plánovanie kapacít,
+Disable Capacity Planning,Vypnite plánovanie kapacity,
+Allow Overtime,Povoliť Nadčasy,
+Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovných hodín.,
+Allow Production on Holidays,Povolit Výrobu při dovolené,
+Capacity Planning For (Days),Plánovanie kapacít Pro (dni),
+Try planning operations for X days in advance.,Skúste plánovanie operácií pre X dní vopred.,
+Time Between Operations (in mins),Doba medzi operáciou (v min),
+Default 10 mins,Predvolené 10 min,
+Default Warehouses for Production,Predvolené sklady na výrobu,
+Default Work In Progress Warehouse,Východiskové prácu v sklade Progress,
+Default Finished Goods Warehouse,Predvolený sklad hotových výrobkov,
+Default Scrap Warehouse,Predvolený sklad šrotu,
+Over Production for Sales and Work Order,Nad výroba pre predaj a zákazku,
+Overproduction Percentage For Sales Order,Percento nadprodukcie pre objednávku predaja,
+Overproduction Percentage For Work Order,Percento nadprodukcie pre pracovnú objednávku,
+Other Settings,ďalšie nastavenie,
+Update BOM Cost Automatically,Automaticky sa aktualizuje cena kusovníka,
+"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",Aktualizujte náklady na BOM automaticky prostredníctvom Plánovača na základe najnovšej sadzby ocenenia / cien / posledného nákupu surovín.,
+Material Request Plan Item,Položka materiálu požadovaného plánu,
+Material Request Type,Materiál Typ požadavku,
+Material Issue,Material Issue,
+Customer Provided,Poskytnuté zákazníkom,
+Minimum Order Quantity,Minimálna objednávka,
+Default Workstation,Výchozí Workstation,
+Production Plan,Výrobný plán,
+MFG-PP-.YYYY.-,MFG-PP-.YYYY.-,
+Get Items From,Získať predmety z,
+Get Sales Orders,Získat Prodejní objednávky,
+Material Request Detail,Podrobnosti o vyžiadaní materiálu,
+Get Material Request,Získať Materiál Request,
+Material Requests,materiál Žiadosti,
+Get Items For Work Order,Získajte položky pre pracovnú objednávku,
+Material Request Planning,Plánovanie žiadostí o materiál,
+Include Non Stock Items,"Zahrňte položky, ktoré nie sú na sklade",
+Include Subcontracted Items,Zahrňte subdodávateľné položky,
+Ignore Existing Projected Quantity,Ignorujte existujúce predpokladané množstvo,
+"To know more about projected quantity, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">click here</a>.","Ak sa chcete dozvedieť viac o plánovanom množstve, <a href=""https://erpnext.com/docs/user/manual/en/stock/projected-quantity"" style=""text-decoration: underline;"" target=""_blank"">kliknite sem</a> .",
+Download Required Materials,Stiahnite si požadované materiály,
+Get Raw Materials For Production,Získajte suroviny pre výrobu,
+Total Planned Qty,Celkový plánovaný počet,
+Total Produced Qty,Celkový vyrobený počet,
+Material Requested,Požadovaný materiál,
+Production Plan Item,Výrobní program Item,
+Make Work Order for Sub Assembly Items,Vykonajte objednávku práce pre položky podzostavy,
+"If enabled, system will create the work order for the exploded items against which BOM is available.","Ak je povolený, systém vytvorí pracovný príkaz pre rozložené položky, proti ktorým je kusovník k dispozícii.",
+Planned Start Date,Plánované datum zahájení,
+Quantity and Description,Množstvo a popis,
+material_request_item,material_request_item,
+Product Bundle Item,Položka produktového balíčka,
+Production Plan Material Request,Výroba Dopyt Plán Materiál,
+Production Plan Sales Order,Výrobní program prodejní objednávky,
+Sales Order Date,Dátum predajnej objednávky,
+Routing Name,Názov smerovania,
+MFG-WO-.YYYY.-,MFG-WO-.YYYY.-,
+Item To Manufacture,Bod K výrobě,
+Material Transferred for Manufacturing,Materiál Prenesená pre výrobu,
+Manufactured Qty,Vyrobeno Množství,
+Use Multi-Level BOM,Použijte Multi-Level BOM,
+Plan material for sub-assemblies,Plán materiál pro podsestavy,
+Skip Material Transfer to WIP Warehouse,Preskočiť prenos materiálu do skladu WIP,
+Check if material transfer entry is not required,"Skontrolujte, či sa nepožaduje zadávanie materiálu",
+Backflush Raw Materials From Work-in-Progress Warehouse,Spätné suroviny z nedokončeného skladu,
+Update Consumed Material Cost In Project,Aktualizácia spotrebovaných materiálových nákladov v projekte,
+Warehouses,Sklady,
+This is a location where raw materials are available.,"Toto je miesto, kde sú k dispozícii suroviny.",
+Work-in-Progress Warehouse,Work-in-Progress sklad,
+This is a location where operations are executed.,"Toto je miesto, kde sa vykonávajú operácie.",
+This is a location where final product stored.,"Toto je miesto, kde je uložený konečný produkt.",
+Scrap Warehouse,šrot Warehouse,
+This is a location where scraped materials are stored.,"Toto je miesto, kde sa skladujú zoškrabané materiály.",
+Required Items,povinné predmety,
+Actual Start Date,Skutečné datum zahájení,
+Planned End Date,Plánované datum ukončení,
+Actual End Date,Skutečné datum ukončení,
+Operation Cost,Provozní náklady,
+Planned Operating Cost,Plánované provozní náklady,
+Actual Operating Cost,Skutečné provozní náklady,
+Additional Operating Cost,Další provozní náklady,
+Total Operating Cost,Celkové provozní náklady,
+Manufacture against Material Request,Výroba proti Materiál Request,
+Work Order Item,Položka pracovnej objednávky,
+Available Qty at Source Warehouse,Dostupné množstvo v zdrojovom sklade,
+Available Qty at WIP Warehouse,Dostupné množstvo v WIP Warehouse,
+Work Order Operation,Obsluha pracovnej objednávky,
+Operation Description,Operace Popis,
+Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?,
+Work in Progress,Work in Progress,
+Estimated Time and Cost,Odhadovná doba a náklady,
+Planned Start Time,Plánované Start Time,
+Planned End Time,Plánované End Time,
+in Minutes,V minútach,
+Actual Time and Cost,Skutečný Čas a Náklady,
+Actual Start Time,Skutečný čas začátku,
+Actual End Time,Aktuální End Time,
+Updated via 'Time Log',"Aktualizováno přes ""Time Log""",
+Actual Operation Time,Aktuální Provozní doba,
+in Minutes\nUpdated via 'Time Log',"v minútach \n aktualizované pomocou ""Time Log""",
+(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutočná Prevádzková doba,
+Workstation Name,Meno pracovnej stanice,
+Production Capacity,Výrobná kapacita,
+Operating Costs,Provozní náklady,
+Electricity Cost,Cena elektřiny,
+per hour,za hodinu,
+Consumable Cost,Spotrebné náklady,
+Rent Cost,Rent Cost,
+Wages,Mzdy,
+Wages per hour,Mzda za hodinu,
+Net Hour Rate,Net Hour Rate,
+Workstation Working Hour,Pracovní stanice Pracovní Hour,
+Certification Application,Certifikačná aplikácia,
+Name of Applicant,Meno žiadateľa,
+Certification Status,Stav certifikácie,
+Yet to appear,Napriek tomu sa objaví,
+Certified,certifikované,
+Not Certified,Nie je certifikovaný,
+USD,Americký dolár,
+INR,INR,
+Certified Consultant,Certifikovaný konzultant,
+Name of Consultant,Názov konzultanta,
+Certification Validity,Platnosť certifikátu,
+Discuss ID,Diskutujte ID,
+GitHub ID,Identifikátor GitHub,
+Non Profit Manager,Neziskový manažér,
+Chapter Head,Kapitola hlavu,
+Meetup Embed HTML,Meetup Vložiť HTML,
+chapters/chapter_name\nleave blank automatically set after saving chapter.,kapitoly / názov_kategórie nechajte prázdne automaticky nastavené po uložení kapitoly.,
+Chapter Members,Členovia kapitoly,
+Members,členovia,
+Chapter Member,Člen kapitoly,
+Website URL,URL webu,
+Leave Reason,Nechajte dôvod,
+Donor Name,Názov darcu,
+Donor Type,Typ darcu,
+Withdrawn,uzavretý,
+Grant Application Details ,Podrobnosti o žiadosti o grant,
+Grant Description,Názov grantu,
+Requested Amount,Požadovaná suma,
+Has any past Grant Record,Má nejaký predchádzajúci grantový záznam,
+Show on Website,Zobraziť na webovej stránke,
+Assessment  Mark (Out of 10),Značka hodnotenia (z 10),
+Assessment  Manager,Manažér pre hodnotenie,
+Email Notification Sent,E-mailové upozornenie bolo odoslané,
+NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
+Membership Expiry Date,Dátum ukončenia členstva,
+Non Profit Member,Neziskový člen,
+Membership Status,Stav členstva,
+Member Since,Členom od,
+Volunteer Name,Názov dobrovoľníka,
+Volunteer Type,Typ dobrovoľníka,
+Availability and Skills,Dostupnosť a zručnosti,
+Availability,Dostupnosť,
+Weekends,víkendy,
+Availability Timeslot,Dostupnosť Timeslot,
+Morning,dopoludnia,
+Afternoon,Popoludnie,
+Evening,Večer,
+Anytime,kedykoľvek,
+Volunteer Skills,Dobrovoľnícke zručnosti,
+Volunteer Skill,Dobrovoľnícka zručnosť,
+Homepage,Úvodné,
+Hero Section Based On,Hero Section Na základe,
+Homepage Section,Domovská stránka,
+Hero Section,Sekcia hrdinov,
+Tag Line,tag linka,
+Company Tagline for website homepage,Firemný slogan na titulnej stránke webu,
+Company Description for website homepage,Spoločnosť Popis pre webové stránky domovskú stránku,
+Homepage Slideshow,Domovská stránka Slideshow,
+"URL for ""All Products""",URL pre &quot;všetky produkty&quot;,
+Products to be shown on website homepage,"Produkty, ktoré majú byť uvedené na internetových stránkach domovskej",
+Homepage Featured Product,Úvodná Odporúčané tovar,
+Section Based On,Časť založená na,
+Section Cards,Karty sekcií,
+Number of Columns,Počet stĺpcov,
+Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Počet stĺpcov pre túto sekciu. Ak vyberiete 3 stĺpce, zobrazia sa 3 karty na riadok.",
+Section HTML,Sekcia HTML,
+Use this field to render any custom HTML in the section.,Toto pole slúži na vykreslenie vlastného HTML v tejto sekcii.,
+Section Order,Poradie sekcií,
+"Order in which sections should appear. 0 is first, 1 is second and so on.","Poradie, v ktorom sa majú sekcie zobraziť. 0 je prvý, 1 je druhý a tak ďalej.",
+Homepage Section Card,Karta sekcie domovskej stránky,
+Subtitle,podtitul,
+Products Settings,nastavenie Produkty,
+Home Page is Products,Domovskou stránkou je stránka Produkty.,
+"If checked, the Home page will be the default Item Group for the website","Ak je zaškrtnuté, domovská stránka bude východiskový bod skupina pre webové stránky",
+Show Availability Status,Zobraziť stav dostupnosti,
+Product Page,Stránka produktu,
+Products per Page,Produkty na stránku,
+Enable Field Filters,Povoliť filtre polí,
+Item Fields,Polia položky,
+Enable Attribute Filters,Povoliť filtre atribútov,
+Attributes,Atribúty,
+Hide Variants,Skryť varianty,
+Website Attribute,Atribút webovej stránky,
+Attribute,Atribút,
+Website Filter Field,Pole filtra webových stránok,
+Activity Cost,Náklady Aktivita,
+Billing Rate,Fakturačná cena,
+Costing Rate,Sadzba kalkulácie nákladov,
+Projects User,Projekty uživatele,
+Default Costing Rate,Predvolená sadzba kalkulácie nákladov,
+Default Billing Rate,Predvolené fakturácia Rate,
+Dependent Task,Závislá úloha,
+Project Type,Typ projektu,
+% Complete Method,Dokončené% Method,
+Task Completion,úloha Dokončenie,
+Task Progress,pokrok úloha,
+% Completed,% Dokončených,
+From Template,Zo šablóny,
+Project will be accessible on the website to these users,Projekt bude k dispozícii na webových stránkach k týmto užívateľom,
+Copied From,Skopírované z,
+Start and End Dates,Dátum začatia a ukončenia,
+Costing and Billing,Kalkulácia a fakturácia,
+Total Costing Amount (via Timesheets),Celková výška sumy (prostredníctvom časových rozpisov),
+Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nárokov),
+Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry),
+Total Sales Amount (via Sales Order),Celková výška predaja (prostredníctvom objednávky predaja),
+Total Billable Amount (via Timesheets),Celková fakturovaná suma (prostredníctvom dochádzky),
+Total Billed Amount (via Sales Invoices),Celková fakturovaná suma (prostredníctvom faktúr za predaj),
+Total Consumed Material Cost  (via Stock Entry),Celková spotreba materiálových nákladov (prostredníctvom vkladu),
+Gross Margin,Hrubá marža,
+Gross Margin %,Hrubá Marža %,
+Monitor Progress,Monitorovanie pokroku,
+Collect Progress,Zbierajte postup,
+Frequency To Collect Progress,Frekvencia na zhromažďovanie pokroku,
+Twice Daily,Dva krát denne,
+First Email,Prvý e-mail,
+Second Email,Druhý e-mail,
+Time to send,Čas odoslania,
+Day to Send,Deň na odoslanie,
+Projects Manager,Správce projektů,
+Project Template,Šablóna projektu,
+Project Template Task,Úloha šablóny projektu,
+Begin On (Days),Začať dňa (dni),
+Duration (Days),Trvanie (dni),
+Project Update,Aktualizácia projektu,
+Project User,projekt Užívateľ,
+View attachments,Zobraziť prílohy,
+Projects Settings,Nastavenia projektov,
+Ignore Workstation Time Overlap,Ignorovať prekrytie pracovnej doby,
+Ignore User Time Overlap,Ignorovať prekrytie času používateľa,
+Ignore Employee Time Overlap,Ignorovať prekrytie času zamestnanca,
+Weight,váha,
+Parent Task,Rodičovská úloha,
+Timeline,časová os,
+Expected Time (in hours),Predpokladaná doba (v hodinách),
+% Progress,% Progress,
+Is Milestone,Je míľnikom,
+Task Description,Popis úlohy,
+Dependencies,závislosti,
+Dependent Tasks,Závislé úlohy,
+Depends on Tasks,Závisí na úlohách,
+Actual Start Date (via Time Sheet),Skutočný dátum začatia (cez Časový rozvrh),
+Actual Time (in hours),Skutočná doba (v hodinách),
+Actual End Date (via Time Sheet),Skutočný dátum ukončenia (cez Time Sheet),
+Total Costing Amount (via Time Sheet),Celková kalkulácie Čiastka (cez Time Sheet),
+Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku),
+Total Billing Amount (via Time Sheet),Celková suma Billing (cez Time Sheet),
+Review Date,Review Datum,
+Closing Date,Uzávěrka Datum,
+Task Depends On,Úloha je závislá na,
+Task Type,Typ úlohy,
+Employee Detail,Detail zamestnanca,
+Billing Details,fakturačné údaje,
+Total Billable Hours,Celkovo zúčtované hodiny,
+Total Billed Hours,Celkom Predpísané Hodiny,
+Total Costing Amount,Celková kalkulácie Čiastka,
+Total Billable Amount,Celková fakturovaná suma,
+Total Billed Amount,Celková suma Fakturovaný,
+% Amount Billed,% Fakturovanej čiastky,
+Hrs,hod,
+Costing Amount,Nákladová Čiastka,
+Corrective/Preventive,Nápravné / preventívne,
+Corrective,nápravný,
+Preventive,preventívna,
+Resolution,Řešení,
+Resolutions,rezolúcia,
+Quality Action Resolution,Kvalitné akčné rozlíšenie,
+Quality Feedback Parameter,Parameter spätnej väzby kvality,
+Quality Feedback Template Parameter,Parameter šablóny spätnej väzby kvality,
+Quality Goal,Cieľ kvality,
+Monitoring Frequency,Frekvencia monitorovania,
+Weekday,všedný deň,
+January-April-July-October,Január-apríl-júl-október,
+Revision and Revised On,Revízia a revízia dňa,
+Revision,opakovanie,
+Revised On,Revidované dňa,
+Objectives,ciele,
+Quality Goal Objective,Cieľ kvality,
+Objective,objektívny,
+Agenda,program,
+Minutes,minúty,
+Quality Meeting Agenda,Program rokovania o kvalite,
+Quality Meeting Minutes,Zápisnica zo zasadnutia o kvalite,
+Minute,Minúta,
+Parent Procedure,Rodičovský postup,
+Processes,Procesy,
+Quality Procedure Process,Proces kvality,
+Process Description,Popis procesu,
+Link existing Quality Procedure.,Prepojiť existujúci postup kvality.,
+Additional Information,Ďalšie informácie,
+Quality Review Objective,Cieľ preskúmania kvality,
+DATEV Settings,Nastavenia DATEV,
+Regional,regionálne,
+Consultant ID,ID konzultanta,
+GST HSN Code,GST kód HSN,
+HSN Code,Kód HSN,
+GST Settings,Nastavenia GST,
+GST Summary,Súhrn GST,
+GSTIN Email Sent On,GSTIN E-mail odoslaný na,
+GST Accounts,Účty GST,
+B2C Limit,B2C Limit,
+Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastavte hodnotu faktúry pre B2C. B2CL a B2CS vypočítané na základe tejto hodnoty faktúry.,
+GSTR 3B Report,Správa GSTR 3B,
+January,január,
+February,február,
+March,marec,
+April,apríl,
+May,Květen,
+June,jún,
+July,júl,
+August,august,
+September,septembra,
+October,október,
+November,november,
+December,December,
+JSON Output,Výstup JSON,
+Invoices with no Place Of Supply,Faktúry bez miesta dodania,
+Import Supplier Invoice,Importovať dodávateľskú faktúru,
+Invoice Series,Fakturačná séria,
+Upload XML Invoices,Odovzdajte faktúry XML,
+Zip File,Súbor ZIP,
+Import Invoices,Importovať faktúry,
+Click on Import Invoices button once the zip file has been attached to the document. Any errors related to processing will be shown in the Error Log.,Po pripojení súboru zip k dokumentu kliknite na tlačidlo Importovať faktúry. Všetky chyby týkajúce sa spracovania sa zobrazia v protokole chýb.,
+Invoice Series Prefix,Prefix radu faktúr,
+Active Menu,Aktívna ponuka,
+Restaurant Menu,Reštaurácia,
+Price List (Auto created),Cenník (vytvorený automaticky),
+Restaurant Manager,Manažér reštaurácie,
+Restaurant Menu Item,Položka ponuky Reštaurácia,
+Restaurant Order Entry,Vstup do objednávky reštaurácie,
+Restaurant Table,Reštaurácia Tabuľka,
+Click Enter To Add,Kliknite na položku Zadat &#39;na pridanie,
+Last Sales Invoice,Posledná faktúra predaja,
+Current Order,Aktuálna objednávka,
+Restaurant Order Entry Item,Položka objednávky reštaurácie,
+Served,slúžil,
+Restaurant Reservation,Rezervácia reštaurácie,
+Waitlisted,poradovníka,
+No Show,Žiadne zobrazenie,
+No of People,Počet ľudí,
+Reservation Time,Čas rezervácie,
+Reservation End Time,Čas ukončenia rezervácie,
+No of Seats,Počet sedadiel,
+Minimum Seating,Minimálne sedenie,
+"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Majte prehľad o predajných kampaniach. Majte prehľad o Iniciatívach, ponukách, objednávkach z kampane, aby ste zistili, návratnosť investície.",
+SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-,
+Campaign Schedules,Harmonogramy kampaní,
+Buyer of Goods and Services.,Kupující zboží a služeb.,
+CUST-.YYYY.-,CUST-.YYYY.-,
+Default Company Bank Account,Predvolený firemný bankový účet,
+From Lead,Od Obchodnej iniciatívy,
+Account Manager,Account Manager,
+Default Price List,Predvolený cenník,
+Primary Address and Contact Detail,Primárna adresa a podrobnosti kontaktu,
+"Select, to make the customer searchable with these fields","Vyberte, ak chcete, aby sa zákazník stal pomocou týchto polí",
+Customer Primary Contact,Primárny kontakt zákazníka,
+"Reselect, if the chosen contact is edited after save","Znova vyberte, ak sa zvolený kontakt upraví po uložení",
+Customer Primary Address,Primárna adresa zákazníka,
+"Reselect, if the chosen address is edited after save","Znovu zvoľte, ak je zvolená adresa upravená po uložení",
+Primary Address,Primárna adresa,
+Mention if non-standard receivable account,Zmienka v prípade neštandardnej pohľadávky účet,
+Credit Limit and Payment Terms,Úverový limit a platobné podmienky,
+Additional information regarding the customer.,Ďalšie informácie týkajúce sa zákazníka.,
+Sales Partner and Commission,Partner predaja a provízia,
+Commission Rate,Výška provízie,
+Sales Team Details,Podrobnosti prodejní tým,
+Customer Credit Limit,Kreditný limit zákazníka,
+Bypass Credit Limit Check at Sales Order,Zablokujte kontrolu kreditného limitu na objednávke,
+Industry Type,Typ Průmyslu,
+MAT-INS-.YYYY.-,MAT-INS-.YYYY.-,
+Installation Date,Datum instalace,
+Installation Time,Instalace Time,
+Installation Note Item,Poznámka k instalaci bod,
+Installed Qty,Instalované množství,
+Lead Source,Zdroj Iniciatívy,
+POS Closing Voucher,Uzávierka POS uzávierky,
+Period Start Date,Dátum začiatku obdobia,
+Period End Date,Dátum ukončenia obdobia,
+Cashier,Pokladník,
+Expense Details,Podrobnosti výdaje,
+Expense Amount,Suma výdavkov,
+Amount in Custody,Suma vo väzbe,
+Total Collected Amount,Celková vyzbieraná suma,
+Difference,Rozdiel,
+Modes of Payment,Spôsoby platby,
+Linked Invoices,Prepojené faktúry,
+Sales Invoices Summary,Prehľad faktúr predaja,
+POS Closing Voucher Details,Podrobnosti o uzatvorení dokladu POS,
+Collected Amount,Zozbieraná suma,
+Expected Amount,Očakávaná suma,
+POS Closing Voucher Invoices,Faktúry POS uzatváracieho dokladu,
+Quantity of Items,Množstvo položiek,
+POS Closing Voucher Taxes,Dane z kupónového uzávierky POS,
+"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials","Súhrnný skupina ** položiek ** do iného ** Položka **. To je užitočné, ak sa zväzovanie niektoré položky ** ** do balíka a budete udržiavať zásoby balených ** Položky ** a nie agregát ** položky **. Balíček ** Položka ** bude mať &quot;Je skladom,&quot; ako &quot;Nie&quot; a &quot;Je predaja Item&quot; ako &quot;Yes&quot;. Napríklad: Ak predávate notebooky a batohy oddelene a majú špeciálnu cenu, ak zákazník kúpi obidva, potom Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Nomenklatúra",
+Parent Item,Nadřazená položka,
+List items that form the package.,"Seznam položek, které tvoří balíček.",
+SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-,
+Quotation To,Ponuka k,
+Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny",
+Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny",
+Additional Discount and Coupon Code,Dodatočný zľavový a kupónový kód,
+Referral Sales Partner,Sprostredkovateľský predajca,
+In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku.",
+Term Details,Termín Podrobnosti,
+Quotation Item,Položka ponuky,
+Against Doctype,Proti DOCTYPE,
+Against Docname,Proti Docname,
+Additional Notes,Doplňujúce Poznámky,
+SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-,
+Skip Delivery Note,Preskočiť dodací list,
+In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky.",
+Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt,
+Billing and Delivery Status,Stav fakturácie a dodania,
+Not Delivered,Nedodané,
+Fully Delivered,Plně Dodáno,
+Partly Delivered,Částečně vyhlášeno,
+Not Applicable,Nehodí se,
+%  Delivered,% Dodaných,
+% of materials delivered against this Sales Order,% materiálov dodaných proti tejto Predajnej objednávke,
+% of materials billed against this Sales Order,% Materiálov fakturovaných proti tejto Predajnej objednávke,
+Not Billed,Nevyúčtované,
+Fully Billed,Plně Fakturovaný,
+Partly Billed,Částečně Účtovaný,
+Ensure Delivery Based on Produced Serial No,Zabezpečte doručenie na základe vyrobeného sériového čísla,
+Supplier delivers to Customer,Dodávateľ doručí zákazníkovi,
+Delivery Warehouse,Dodací sklad,
+Planned Quantity,Plánované Množstvo,
+For Production,Pro Výrobu,
+Work Order Qty,Počet pracovných zákaziek,
+Produced Quantity,Vyrobené Množstvo,
+Used for Production Plan,Používá se pro výrobní plán,
+Sales Partner Type,Typ obchodného partnera,
+Contact No.,Kontakt Číslo,
+Contribution (%),Príspevok (%),
+Contribution to Net Total,Príspevok na celkom netto,
+Selling Settings,Nastavenia pre Predaj,
+Settings for Selling Module,Nastavenie modulu Predaj,
+Customer Naming By,Zákazník Pojmenování By,
+Campaign Naming By,Pomenovanie kampane podľa,
+Default Customer Group,Výchozí Customer Group,
+Default Territory,Výchozí Territory,
+Close Opportunity After Days,Close Opportunity po niekoľkých dňoch,
+Auto close Opportunity after 15 days,Auto zavrieť Opportunity po 15 dňoch,
+Default Quotation Validity Days,Predvolené dni platnosti cenovej ponuky,
+Sales Order Required,Je potrebná predajná objednávka,
+Delivery Note Required,Dodací list povinný,
+Sales Update Frequency,Frekvencia aktualizácie predaja,
+How often should project and company be updated based on Sales Transactions.,Ako často by sa projekt a spoločnosť mali aktualizovať na základe predajných transakcií.,
+Each Transaction,Každá Transakcia,
+Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích,
+Allow multiple Sales Orders against a Customer's Purchase Order,Povoliť viac Predajné objednávky proti Zákazníka Objednávky,
+Validate Selling Price for Item against Purchase Rate or Valuation Rate,Overenie predajná cena výtlačku proti platbe alebo ocenenia Rate,
+Hide Customer's Tax Id from Sales Transactions,Inkognito dane zákazníka z predajných transakcií,
+SMS Center,SMS centrum,
+Send To,Odoslať na,
+All Contact,Vše Kontakt,
+All Customer Contact,Všetky Kontakty Zákazníka,
+All Supplier Contact,Vše Dodavatel Kontakt,
+All Sales Partner Contact,Všechny Partneři Kontakt,
+All Lead (Open),Všetky Iniciatívy (Otvorené),
+All Employee (Active),Všichni zaměstnanci (Aktivní),
+All Sales Person,Všichni obchodní zástupci,
+Create Receiver List,Vytvoriť zoznam príjemcov,
+Receiver List,Zoznam príjemcov,
+Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv,
+Total Characters,Celkový počet znaků,
+Total Message(s),Celkem zpráv (y),
+Authorization Control,Autorizace Control,
+Authorization Rule,Autorizační pravidlo,
+Average Discount,Průměrná sleva,
+Customerwise Discount,Sleva podle zákazníka,
+Itemwise Discount,Itemwise Sleva,
+Customer or Item,Zákazník alebo položka,
+Customer / Item Name,Názov zákazníka/položky,
+Authorized Value,Autorizovaný Hodnota,
+Applicable To (Role),Vztahující se na (Role),
+Applicable To (Employee),Vztahující se na (Employee),
+Applicable To (User),Vztahující se na (Uživatel),
+Applicable To (Designation),Vztahující se na (označení),
+Approving Role (above authorized value),Schválenie role (nad oprávnenej hodnoty),
+Approving User  (above authorized value),Schválenie užívateľa (nad oprávnenej hodnoty),
+Brand Defaults,Predvolené hodnoty značky,
+Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace.",
+Change Abbreviation,Zmeniť skratku,
+Parent Company,Materská spoločnosť,
+Default Values,Predvolené hodnoty,
+Default Holiday List,Východzí zoznam sviatkov,
+Standard Working Hours,Štandardná pracovná doba,
+Default Selling Terms,Predvolené podmienky predaja,
+Default Buying Terms,Predvolené nákupné podmienky,
+Default warehouse for Sales Return,Predvolený sklad pre vrátenie predaja,
+Create Chart Of Accounts Based On,Vytvorte účtový rozvrh založený na,
+Standard Template,štandardná šablóna,
+Chart Of Accounts Template,Šablóna účtovného rozvrhu,
+Existing Company ,existujúce Company,
+Date of Establishment,Dátum založenia,
+Sales Settings,Nastavenia predaja,
+Monthly Sales Target,Mesačný cieľ predaja,
+Sales Monthly History,Mesačná história predaja,
+Transactions Annual History,Výročná história transakcií,
+Total Monthly Sales,Celkový mesačný predaj,
+Default Cash Account,Výchozí Peněžní účet,
+Default Receivable Account,Výchozí pohledávek účtu,
+Round Off Cost Center,Zaokrúhliť nákladové stredisko,
+Discount Allowed Account,Zľavový účet,
+Discount Received Account,Zľavový prijatý účet,
+Exchange Gain / Loss Account,Exchange Zisk / straty,
+Unrealized Exchange Gain/Loss Account,Nerealizovaný účet ziskov a strát na výmene,
+Allow Account Creation Against Child Company,Povoliť vytvorenie účtu proti dcérskej spoločnosti,
+Default Payable Account,Výchozí Splatnost účtu,
+Default Employee Advance Account,Predvolený účet predvoleného zamestnanca,
+Default Cost of Goods Sold Account,Východiskové Náklady na predaný tovar účte,
+Default Income Account,Predvolený účet príjmov,
+Default Deferred Revenue Account,Predvolený účet odloženého výnosu,
+Default Deferred Expense Account,Predvolený účet odloženého výdavku,
+Default Payroll Payable Account,"Predvolené mzdy, splatnú Account",
+Default Expense Claim Payable Account,Splatný účet s predpokladaným výdavkom,
+Stock Settings,Nastavenie Skladu,
+Enable Perpetual Inventory,Povoliť trvalý inventár,
+Default Inventory Account,Predvolený inventárny účet,
+Stock Adjustment Account,Reklamní Nastavení účtu,
+Fixed Asset Depreciation Settings,Nastavenie odpisovania dlhodobého majetku,
+Series for Asset Depreciation Entry (Journal Entry),Séria pre odpisy majetku (záznam v účte),
+Gain/Loss Account on Asset Disposal,Zisk / straty na majetku likvidáciu,
+Asset Depreciation Cost Center,Asset Odpisy nákladového strediska,
+Budget Detail,Detail Rozpočtu,
+Exception Budget Approver Role,Role prístupu k výnimke rozpočtu,
+Company Info,Informácie o spoločnosti,
+For reference only.,Pouze orientační.,
+Company Logo,Logo spoločnosti,
+Date of Incorporation,Dátum začlenenia,
+Date of Commencement,Dátum začiatku,
+Phone No,Telefónne číslo,
+Company Description,Popis firmy,
+Registration Details,Registrace Podrobnosti,
+Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd,
+Delete Company Transactions,Zmazať transakcie spoločnosti,
+Currency Exchange,Zmenáreň,
+Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou,
+From Currency,Od Měny,
+To Currency,Chcete-li měny,
+For Buying,Pre nákup,
+For Selling,Pre predaj,
+Customer Group Name,Zákazník Group Name,
+Parent Customer Group,Parent Customer Group,
+Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci,
+Mention if non-standard receivable account applicable,Zmienka v prípade neštandardnej pohľadávky účet použiteľná,
+Credit Limits,Úverové limity,
+Email Digest,Email Digest,
+Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.,
+Email Digest Settings,Nastavení e-mailu Digest,
+How frequently?,Jak často?,
+Next email will be sent on:,Další e-mail bude odeslán dne:,
+Note: Email will not be sent to disabled users,Poznámka: E-mail nebude odoslaný neaktívnym používateľom,
+Profit & Loss,Zisk & Strata,
+New Income,new príjmov,
+New Expenses,nové výdavky,
+Annual Income,Ročný príjem,
+Annual Expenses,ročné náklady,
+Bank Balance,Bankový zostatok,
+Bank Credit Balance,Zostatok bankového úveru,
+Receivables,Pohľadávky,
+Payables,Závazky,
+Sales Orders to Bill,Predajné príkazy k Billovi,
+Purchase Orders to Bill,Objednávky k nákupu,
+New Sales Orders,Nové Prodejní objednávky,
+New Purchase Orders,Nové vydané objednávky,
+Sales Orders to Deliver,Predajné príkazy na dodanie,
+Purchase Orders to Receive,Nákupné príkazy na príjem,
+New Purchase Invoice,Nová nákupná faktúra,
+New Quotations,Nové Citace,
+Open Quotations,Otvorené citácie,
+Purchase Orders Items Overdue,Položky nákupných objednávok Po splatnosti,
+Add Quote,Pridať ponuku,
+Global Defaults,Globální Výchozí,
+Default Company,Predvolená spoločnosť,
+Current Fiscal Year,Aktuálny fiškálny rok,
+Default Distance Unit,Predvolená vzdialenosť jednotky,
+Hide Currency Symbol,Skrýt symbol měny,
+Do not show any symbol like $ etc next to currencies.,Neukazovať žiadny symbol ako $ atď vedľa meny.,
+"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce",
+Disable In Words,Zakázať v slovách,
+"If disable, 'In Words' field will not be visible in any transaction","Pokiaľ zakázať, &quot;v slovách&quot; poli nebude viditeľný v akejkoľvek transakcie",
+Item Classification,Položka Klasifikace,
+General Settings,Všeobecné nastavenia,
+Item Group Name,Názov položkovej skupiny,
+Parent Item Group,Parent Item Group,
+Item Group Defaults,Predvolené položky skupiny položiek,
+Item Tax,Daň Položky,
+Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky",
+Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky,
+HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků.",
+Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí,
+Setup Series,Řada Setup,
+Select Transaction,Vybrat Transaction,
+Help HTML,Nápoveda HTML,
+Series List for this Transaction,Řada seznam pro tuto transakci,
+User must always select,Uživatel musí vždy vybrat,
+Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat.",
+Update Series,Řada Aktualizace,
+Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.,
+Prefix,Prefix,
+Current Value,Current Value,
+This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem,
+Update Series Number,Aktualizace Series Number,
+Quotation Lost Reason,Dôvod neúspešnej ponuky,
+A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi.",
+Sales Partner Name,Meno predajného partnera,
+Partner Type,Partner Type,
+Address & Contacts,Adresa a kontakty,
+Address Desc,Popis adresy,
+Contact Desc,Opis kontaktu,
+Sales Partner Target,Sales Partner Target,
+Targets,Cíle,
+Show In Website,Zobraziť na webstránke,
+Referral Code,referenčný kód,
+To Track inbound purchase,Ak chcete sledovať prichádzajúci nákup,
+Logo,Logo,
+Partner website,webové stránky Partner,
+All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle.",
+Name and Employee ID,Meno a ID zamestnanca,
+Sales Person Name,Meno predajcu,
+Parent Sales Person,Parent obchodník,
+Select company name first.,"Prosím, vyberte najprv názov spoločnosti",
+Sales Person Targets,Obchodnícke ciele,
+Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.,
+Supplier Group Name,Názov skupiny dodávateľov,
+Parent Supplier Group,Rodičovská skupina dodávateľov,
+Target Detail,Target Detail,
+Target Qty,Target Množství,
+Target  Amount,Cílová částka,
+Target Distribution,Target Distribution,
+"Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.","Všeobecné obchodní podmínky, které mohou být přidány do prodejů a nákupů.\n\n Příklady: \n\n 1. Platnost nabídky.\n 1. Platební podmínky (v předstihu, na úvěr, část zálohy atd.)\n 1. Co je to další (nebo zaplatit zákazníkem).\n 1. Bezpečnost / varování využití.\n 1. Záruka, pokud existuje.\n 1. Vrátí zásady.\n 1. Podmínky přepravy, v případě potřeby.\n 1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd \n 1. Adresa a kontakt na vaši společnost.",
+Applicable Modules,Uplatniteľné moduly,
+Terms and Conditions Help,podmienky nápovedy,
+Classification of Customers by region,Rozdělení zákazníků podle krajů,
+Territory Name,Území Name,
+Parent Territory,Parent Territory,
+Territory Manager,Oblastní manažer,
+For reference,Pro srovnání,
+Territory Targets,Území Cíle,
+Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.,
+UOM Name,Názov Mernej Jednotky,
+Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)",
+Website Item Group,Website Item Group,
+Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách,
+Default settings for Shopping Cart,Predvolené nastavenia pre Košík,
+Enable Shopping Cart,Povolit Nákupní košík,
+Display Settings,Nastavenia zobrazení,
+Show Public Attachments,Zobraziť verejné prílohy,
+Show Price,Zobraziť cenu,
+Show Stock Availability,Zobraziť dostupnosť zásob,
+Show Configure Button,Zobraziť tlačidlo Konfigurovať,
+Show Contact Us Button,Zobraziť tlačidlo Kontaktujte nás,
+Show Stock Quantity,Zobraziť množstvo zásob,
+Show Apply Coupon Code,Zobraziť Použiť kód kupónu,
+Allow items not in stock to be added to cart,"Nechajte položky, ktoré nie sú na sklade, pridať do košíka",
+Prices will not be shown if Price List is not set,"Ceny sa nebudú zobrazovať, pokiaľ Cenník nie je nastavený",
+Quotation Series,Číselná rada ponúk,
+Checkout Settings,Nastavenia checkout,
+Enable Checkout,aktivovať Checkout,
+Payment Success Url,Platba Úspech URL,
+After payment completion redirect user to selected page.,Po dokončení platby presmerovať užívateľa na vybrané stránky.,
+Batch ID,Šarže ID,
+Parent Batch,Rodičovská dávka,
+Manufacturing Date,Dátum výroby,
+Source Document Type,Zdrojový typ dokumentu,
+Source Document Name,Názov zdrojového dokumentu,
+Batch Description,Popis Šarže,
+Bin,Kôš,
+Reserved Quantity,Vyhrazeno Množství,
+Actual Quantity,Skutočné Množstvo,
+Requested Quantity,požadované množstvo,
+Reserved Qty for sub contract,Vyhradené množstvo pre subkontrakt,
+Moving Average Rate,Klouzavý průměr,
+FCFS Rate,FCFS Rate,
+Customs Tariff Number,colného sadzobníka,
+Tariff Number,tarif Počet,
+Delivery To,Doručenie do,
+MAT-DN-.YYYY.-,MAT-DN-.YYYY.-,
+Is Return,Je Return,
+Issue Credit Note,Vydanie kreditnej poznámky,
+Return Against Delivery Note,Návrat Proti dodací list,
+Customer's Purchase Order No,Zákazníka Objednávka No,
+Billing Address Name,Názov fakturačnej adresy,
+Required only for sample item.,Požadováno pouze pro položku vzorku.,
+"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ak ste vytvorili štandardné šablónu v predaji daní a poplatkov šablóny, vyberte jednu a kliknite na tlačidlo nižšie.",
+In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku.",
+In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku.",
+Transporter Info,Transporter Info,
+Driver Name,Názov vodiča,
+Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu,
+Inter Company Reference,Inter Company Reference,
+Print Without Amount,Tisknout bez Částka,
+% Installed,% Inštalovaných,
+% of materials delivered against this Delivery Note,% materiálov dodaných proti tomuto dodaciemu listu,
+Installation Status,Stav instalace,
+Excise Page Number,Spotřební Číslo stránky,
+Instructions,Instrukce,
+From Warehouse,Zo skladu,
+Against Sales Order,Proti přijaté objednávce,
+Against Sales Order Item,Proti položce přijaté objednávky,
+Against Sales Invoice,Proti prodejní faktuře,
+Against Sales Invoice Item,Proti položce vydané faktury,
+Available Batch Qty at From Warehouse,K dispozícii dávky Množstvo na Od Warehouse,
+Available Qty at From Warehouse,K dispozícii Množstvo na Od Warehouse,
+Delivery Settings,Nastavenia doručenia,
+Dispatch Settings,Nastavenia odosielania,
+Dispatch Notification Template,Šablóna oznámenia odoslania,
+Dispatch Notification Attachment,Príloha o oznámení odoslania,
+Leave blank to use the standard Delivery Note format,"Nechajte prázdne, ak chcete použiť štandardný formát dodacieho listu",
+Send with Attachment,Odoslať s prílohou,
+Delay between Delivery Stops,Oneskorenie medzi doručením,
+Delivery Stop,Zastavenie doručenia,
+Visited,navštívil,
+Order Information,informacie o objednavke,
+Contact Information,Kontaktné informácie,
+Email sent to,E-mail odoslaný na,
+Dispatch Information,Informácie o odoslaní,
+Estimated Arrival,Odhadovaný príchod,
+MAT-DT-.YYYY.-,MAT-DT-.YYYY.-,
+Initial Email Notification Sent,Odoslané pôvodné oznámenie o e-maile,
+Delivery Details,Detaily dodania,
+Driver Email,E-mail vodiča,
+Driver Address,Adresa vodiča,
+Total Estimated Distance,Celková odhadovaná vzdialenosť,
+Distance UOM,Vzdialenosť UOM,
+Departure Time,Čas odchodu,
+Delivery Stops,Zastavenie doručenia,
+Calculate Estimated Arrival Times,Vypočítať odhadované časy príchodu,
+Use Google Maps Direction API to calculate estimated arrival times,Na výpočet odhadovaných časov príchodu použite rozhranie API služby Mapy Google,
+Optimize Route,Optimalizujte trasu,
+Use Google Maps Direction API to optimize route,Na optimalizáciu trasy použite rozhranie API služby Mapy Google,
+In Transit,V preprave,
+Fulfillment User,Užívateľ splnenia,
+"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje.",
+STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-,
+"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno",
+Is Item from Hub,Je položka z Hubu,
+Default Unit of Measure,Predvolená merná jednotka,
+Maintain Stock,Udržiavať Zásoby,
+Standard Selling Rate,Štandardné predajné kurz,
+Auto Create Assets on Purchase,Automatické vytváranie aktív pri nákupe,
+Asset Naming Series,Asset Naming Series,
+Over Delivery/Receipt Allowance (%),Príspevok na prekročenie dodávky / príjem (%),
+Barcodes,čiarové kódy,
+Shelf Life In Days,Životnosť počas dní,
+End of Life,Konec životnosti,
+Default Material Request Type,Predvolený typ materiálovej požiadavky,
+Valuation Method,Ocenění Method,
+FIFO,FIFO,
+Moving Average,Klouzavý průměr,
+Warranty Period (in days),Záruční doba (ve dnech),
+Auto re-order,Auto re-order,
+Reorder level based on Warehouse,Úroveň Zmena poradia na základe Warehouse,
+Will also apply for variants unless overrridden,"Bude platiť aj pre varianty, pokiaľ nebude prepísané",
+Units of Measure,merné jednotky,
+Will also apply for variants,Bude platiť aj pre varianty,
+Serial Nos and Batches,Sériové čísla a dávky,
+Has Batch No,Má číslo šarže,
+Automatically Create New Batch,Automaticky vytvoriť novú dávku,
+Batch Number Series,Číselná séria šarží,
+"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Príklad: ABCD. #####. Ak je nastavená séria a v transakciách sa neuvádza dávka, potom sa na základe tejto série vytvorí automatické číslo dávky. Ak chcete vždy výslovne uviesť číslo dávky pre túto položku, ponechajte prázdne. Poznámka: Toto nastavenie bude mať prednosť pred prefixom série Naming v nastaveniach zásob.",
+Has Expiry Date,Má dátum skončenia platnosti,
+Retain Sample,Zachovať ukážku,
+Max Sample Quantity,Max. Množstvo vzoriek,
+Maximum sample quantity that can be retained,"Maximálne množstvo vzorky, ktoré možno uchovať",
+Has Serial No,Má Sériové číslo,
+Serial Number Series,Sériové číslo Series,
+"Example: ABCD.#####\nIf 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.","Příklad:. ABCD ##### \n Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné.",
+Variants,Varianty,
+Has Variants,Má varianty,
+"If this item has variants, then it cannot be selected in sales orders etc.","Ak je táto položka má varianty, potom to nemôže byť vybraná v predajných objednávok atď",
+Variant Based On,Variant založená na,
+Item Attribute,Položka Atribut,
+"Sales, Purchase, Accounting Defaults","Predaj, nákup, predvolené účtovníctvo",
+Item Defaults,Predvolené položky,
+"Purchase, Replenishment Details","Podrobnosti o nákupe, doplnení",
+Is Purchase Item,je Nákupní Položka,
+Default Purchase Unit of Measure,Predvolená nákupná merná jednotka,
+Minimum Order Qty,Minimální objednávka Množství,
+Minimum quantity should be as per Stock UOM,Minimálne množstvo by malo byť podľa zásob UOM,
+Average time taken by the supplier to deliver,Priemerná doba zhotovená dodávateľom dodať,
+Is Customer Provided Item,Je položka poskytnutá zákazníkom,
+Delivered by Supplier (Drop Ship),Dodáva Dodávateľom (Drop Ship),
+Supplier Items,Dodavatele položky,
+Foreign Trade Details,Zahraničný obchod Podrobnosti,
+Country of Origin,Krajina pôvodu,
+Sales Details,Predajné podrobnosti,
+Default Sales Unit of Measure,Predvolená predajná jednotka merania,
+Is Sales Item,Je Sales Item,
+Max Discount (%),Max zľava (%),
+No of Months,Počet mesiacov,
+Customer Items,Zákaznícke položky,
+Inspection Criteria,Inšpekčné kritéria,
+Inspection Required before Purchase,Inšpekcia Požadované pred nákupom,
+Inspection Required before Delivery,Inšpekcia Požadované pred pôrodom,
+Default BOM,Východzí BOM,
+Supply Raw Materials for Purchase,Dodávky suroviny pre nákup,
+If subcontracted to a vendor,Ak sa subdodávky na dodávateľa,
+Customer Code,Code zákazníků,
+Show in Website (Variant),Zobraziť na webstránke (Variant),
+Items with higher weightage will be shown higher,Položky s vyšším weightage budú zobrazené vyššie,
+Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky,
+Website Image,Obrázok webovej stránky,
+Website Warehouse,Sklad pro web,
+"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu.",
+Website Item Groups,Webové stránky skupiny položek,
+List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.,
+Copy From Item Group,Kopírovať z položkovej skupiny,
+Website Content,Obsah webových stránok,
+You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tomto poli môžete použiť akékoľvek platné značenie Bootstrap 4. Bude sa zobrazovať na vašej stránke s položkami.,
+Total Projected Qty,Celková predpokladaná Množstvo,
+Hub Publishing Details,Podrobnosti o publikovaní Hubu,
+Publish in Hub,Publikovat v Hub,
+Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com,
+Hub Category to Publish,Kategória Hubu na publikovanie,
+Hub Warehouse,Hub Warehouse,
+"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Zverejnite na sklade &quot;Na sklade&quot; alebo &quot;Nie je na sklade&quot; na základe dostupných zásob v tomto sklade.,
+Synced With Hub,Synchronizovány Hub,
+Item Alternative,Položka Alternatíva,
+Alternative Item Code,Kód alternatívnej položky,
+Two-way,obojsmerný,
+Alternative Item Name,Alternatívny názov položky,
+Attribute Name,Názov atribútu,
+Numeric Values,Číselné hodnoty,
+From Range,Od Rozsah,
+Increment,Prírastok,
+To Range,K Rozsah,
+Item Attribute Values,Položka Hodnoty atributů,
+Item Attribute Value,Položka Hodnota atributu,
+Attribute Value,Hodnota atributu,
+Abbreviation,Zkratka,
+"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM""",
+Item Barcode,Položka Barcode,
+Barcode Type,Typ čiarového kódu,
+EAN,EAN,
+UPC-A,UPC-A,
+Item Customer Detail,Položka Detail Zákazník,
+"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech",
+Ref Code,Ref Code,
+Item Default,Položka Predvolená,
+Purchase Defaults,Predvolené nákupy,
+Default Buying Cost Center,Výchozí Center Nákup Cost,
+Default Supplier,Výchozí Dodavatel,
+Default Expense Account,Výchozí výdajového účtu,
+Sales Defaults,Predvolené hodnoty predaja,
+Default Selling Cost Center,Výchozí Center Prodejní cena,
+Item Manufacturer,položka Výrobca,
+Item Price,Položka Cena,
+Packing Unit,Balenie,
+Quantity  that must be bought or sold per UOM,"Množstvo, ktoré je potrebné zakúpiť alebo predať podľa UOM",
+Valid From ,Platnost od,
+Valid Upto ,Valid aľ,
+Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr,
+Acceptance Criteria,Kritéria přijetí,
+Item Reorder,Položka Reorder,
+Check in (group),Check in (skupina),
+Request for,Žiadosť o,
+Re-order Level,Úroveň doobjednania,
+Re-order Qty,Doobjednacie množstvo,
+Item Supplier,Položka Dodavatel,
+Item Variant,Variant Položky,
+Item Variant Attribute,Vlastnosť Variantu Položky,
+Do not update variants on save,Neaktualizujte varianty uloženia,
+Fields will be copied over only at time of creation.,Polia budú kopírované iba v čase vytvorenia.,
+Allow Rename Attribute Value,Povoliť premenovanie hodnoty atribútu,
+Rename Attribute Value in Item Attribute.,Premenujte hodnotu atribútu v atribúte položky.,
+Copy Fields to Variant,Kopírovať polia na variant,
+Item Website Specification,Položka webových stránek Specifikace,
+Table for Item that will be shown in Web Site,"Tabuľka k Položke, která sa zobrazí na webových stránkách",
+Landed Cost Item,Přistálo nákladovou položkou,
+Receipt Document Type,Príjem Document Type,
+Receipt Document,príjem dokumentov,
+Applicable Charges,Použitelné Poplatky,
+Purchase Receipt Item,Položka příjemky,
+Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi,
+Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky,
+Landed Cost Voucher,Přistálo Náklady Voucher,
+MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-,
+Purchase Receipts,Příjmky,
+Purchase Receipt Items,Položky příjemky,
+Get Items From Purchase Receipts,Získat položky z Příjmového listu,
+Distribute Charges Based On,Distribuovat poplatků na základě,
+Landed Cost Help,Přistálo Náklady Help,
+Manufacturers used in Items,Výrobcovia používané v bodoch,
+Limited to 12 characters,Obmedzené na 12 znakov,
+MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
+Requested For,Požadovaných pro,
+Transferred,prevedená,
+% Ordered,% Objednané,
+Terms and Conditions Content,Podmínky Content,
+Quantity and Warehouse,Množstvo a sklad,
+Lead Time Date,Čas a Dátum Obchodnej iniciatívy,
+Min Order Qty,Min Objednané množství,
+Packed Item,Zabalená položka,
+To Warehouse (Optional),Warehouse (voliteľné),
+Actual Batch Quantity,Skutočné množstvo šarže,
+Prevdoc DocType,Prevdoc DOCTYPE,
+Parent Detail docname,Parent Detail docname,
+"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost.",
+Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)",
+MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-,
+From Package No.,Od č balíčku,
+Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk),
+To Package No.,Balit No.,
+If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk),
+Package Weight Details,Detail hmotnosti zásielky,
+The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek),
+Net Weight UOM,Čistá hmotnosť MJ,
+Gross Weight,Hrubá hmotnost,
+The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk),
+Gross Weight UOM,Hrubá Hmotnosť MJ,
+Packing Slip Item,Balení Slip Item,
+DN Detail,DN Detail,
+STO-PICK-.YYYY.-,STO-PICK-.YYYY.-,
+Material Transfer for Manufacture,Materiál Přenos: Výroba,
+Qty of raw materials will be decided based on the qty of the Finished Goods Item,O množstve surovín sa rozhodne na základe množstva hotového tovaru,
+Parent Warehouse,Parent Warehouse,
+Items under this warehouse will be suggested,Položky v tomto sklade budú navrhnuté,
+Get Item Locations,Získajte informácie o položkách,
+Item Locations,Polohy položiek,
+Pick List Item,Vyberte položku zoznamu,
+Picked Qty,Vybrané množstvo,
+Price List Master,Ceník Master,
+Price List Name,Názov cenníka,
+Price Not UOM Dependent,Cena nie je závislá od UOM,
+Applicable for Countries,Pre krajiny,
+Price List Country,Cenník Krajina,
+MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-,
+Supplier Delivery Note,Dodacie oznámenie dodávateľa,
+Time at which materials were received,"Čas, kdy bylo přijato materiály",
+Return Against Purchase Receipt,Návrat Proti doklad o kúpe,
+Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny",
+Get Current Stock,Získať aktuálny stav,
+Add / Edit Taxes and Charges,Pridať / Upraviť dane a poplatky,
+Auto Repeat Detail,Podrobnosti o automatickom opakovaní,
+Transporter Details,Transporter Podrobnosti,
+Vehicle Number,Číslo vozidla,
+Vehicle Date,Dátum Vehicle,
+Received and Accepted,Prijaté a akceptované,
+Accepted Quantity,Schválené Množstvo,
+Rejected Quantity,Zamítnuto Množství,
+Sample Quantity,Množstvo vzoriek,
+Rate and Amount,Sadzba a množstvo,
+MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
+Report Date,Datum Reportu,
+Inspection Type,Kontrola Type,
+Item Serial No,Položka Výrobní číslo,
+Sample Size,Veľkosť vzorky,
+Inspected By,Zkontrolován,
+Readings,Čtení,
+Quality Inspection Reading,Kvalita Kontrola Reading,
+Reading 1,Čtení 1,
+Reading 2,Čtení 2,
+Reading 3,Čtení 3,
+Reading 4,Čtení 4,
+Reading 5,Čtení 5,
+Reading 6,Čtení 6,
+Reading 7,Čtení 7,
+Reading 8,Čtení 8,
+Reading 9,Čtení 9,
+Reading 10,Čtení 10,
+Quality Inspection Template Name,Názov šablóny inšpekcie kvality,
+Quick Stock Balance,Rýchla bilancia zásob,
+Available Quantity,Dostupné množstvo,
+Distinct unit of an Item,Samostatnou jednotku z položky,
+Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupení,
+Purchase / Manufacture Details,Nákup / Výroba Podrobnosti,
+Creation Document Type,Tvorba Typ dokumentu,
+Creation Document No,Tvorba dokument č,
+Creation Date,Dátum vytvorenia,
+Creation Time,Čas vytvorenia,
+Asset Details,Podrobnosti o majetku,
+Asset Status,Stav majetku,
+Delivery Document Type,Dodávka Typ dokumentu,
+Delivery Document No,Dodávka dokument č,
+Delivery Time,Dodacia doba,
+Invoice Details,Podrobnosti faktúry,
+Warranty / AMC Details,Záruka / AMC Podrobnosti,
+Warranty Expiry Date,Záruka Datum vypršení platnosti,
+AMC Expiry Date,AMC Datum vypršení platnosti,
+Under Warranty,V rámci záruky,
+Out of Warranty,Out of záruky,
+Under AMC,Podle AMC,
+Out of AMC,Out of AMC,
+Warranty Period (Days),Záruční doba (dny),
+Serial No Details,Podrodnosti k sériovému číslu,
+MAT-STE-.YYYY.-,MAT-STE-.YYYY.-,
+Stock Entry Type,Druh položky na sklade,
+Stock Entry (Outward GIT),Zásoby (Outward GIT),
+Material Consumption for Manufacture,Spotreba materiálu na výrobu,
+Repack,Přebalit,
+Send to Subcontractor,Odoslať subdodávateľovi,
+Send to Warehouse,Odoslať do skladu,
+Receive at Warehouse,Prijať do skladu,
+Delivery Note No,Číslo dodacieho listu,
+Sales Invoice No,Číslo odoslanej faktúry,
+Purchase Receipt No,Číslo příjmky,
+Inspection Required,Kontrola je povinná,
+From BOM,Od BOM,
+For Quantity,Pre Množstvo,
+As per Stock UOM,Podľa skladovej MJ,
+Including items for sub assemblies,Vrátane položiek pre montážnych podskupín,
+Default Source Warehouse,Výchozí zdroj Warehouse,
+Source Warehouse Address,Adresa zdrojového skladu,
+Default Target Warehouse,Výchozí Target Warehouse,
+Target Warehouse Address,Adresa cieľového skladu,
+Update Rate and Availability,Obnovovaciu rýchlosť a dostupnosť,
+Total Incoming Value,Celková hodnota Příchozí,
+Total Outgoing Value,Celková hodnota Odchozí,
+Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In),
+Additional Costs,Dodatočné náklady,
+Total Additional Costs,Celkom Dodatočné náklady,
+Customer or Supplier Details,Zákazníka alebo dodávateľa Podrobnosti,
+Per Transferred,Za prevedené,
+Stock Entry Detail,Detail pohybu zásob,
+Basic Rate (as per Stock UOM),Základná sadzba (podľa skladovej MJ),
+Basic Amount,Základná čiastka,
+Additional Cost,Dodatočné náklady,
+Serial No / Batch,Sériové číslo / Dávka,
+BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce,
+Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry,
+Subcontracted Item,Subkontraktovaná položka,
+Against Stock Entry,Proti zásobám,
+Stock Entry Child,Zásoby Dieťa,
+PO Supplied Item,PO Dodaná položka,
+Reference Purchase Receipt,Referenčný doklad o nákupe,
+Stock Ledger Entry,Zápis do súpisu zásob,
+Outgoing Rate,Odchádzajúce Rate,
+Actual Qty After Transaction,Skutečné Množství Po transakci,
+Stock Value Difference,Rozdiel v hodnote zásob,
+Stock Queue (FIFO),Skladové karty (FIFO),
+Is Cancelled,Je zrušené,
+Stock Reconciliation,Inventúra zásob,
+This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech.",
+MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-,
+Reconciliation JSON,Odsouhlasení JSON,
+Stock Reconciliation Item,Inventúrna položka,
+Before reconciliation,Pred odsúhlasením,
+Current Serial No,Aktuálne poradové číslo,
+Current Valuation Rate,Aktuálne ocenenie Rate,
+Current Amount,Aktuálna výška,
+Quantity Difference,Množstvo Rozdiel,
+Amount Difference,vyššie Rozdiel,
+Item Naming By,Položka Pojmenování By,
+Default Item Group,Predvolená skupina položiek,
+Default Stock UOM,Predvolená skladová MJ,
+Sample Retention Warehouse,Sklad pre uchovávanie vzoriek,
+Default Valuation Method,Výchozí metoda ocenění,
+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.,"Percento, ktoré máte možnosť prijať alebo dodať naviac oproti objednanému množstvu. Napríklad: Keď ste si objednali 100 kusov a váša tolerancia je 10%, tak máte možnosť prijať 110 kusov.",
+Action if Quality inspection is not submitted,"Akcia, ak nebola predložená kontrola kvality",
+Show Barcode Field,Show čiarového kódu Field,
+Convert Item Description to Clean HTML,Konvertovať popis položky na HTML,
+Auto insert Price List rate if missing,Automaticky vložiť cenníkovú cenu ak neexistuje,
+Allow Negative Stock,Povoliť mínusové zásoby,
+Automatically Set Serial Nos based on FIFO,Automaticky nastaviť sériové čísla na základe FIFO,
+Set Qty in Transactions based on Serial No Input,Voliť množstvo v transakciách na základe vybratého sériového čísla,
+Auto Material Request,Auto materiálu Poptávka,
+Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order,
+Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka,
+Freeze Stock Entries,Freeze Stock Příspěvky,
+Stock Frozen Upto,Reklamní Frozen aľ,
+Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny],
+Role Allowed to edit frozen stock,"Rola, ktorá má oprávnenie upravovať zmrazené zásoby",
+Batch Identification,Identifikácia šarže,
+Use Naming Series,Použiť pomenovacie série,
+Naming Series Prefix,Pomenovanie predvoľby série,
+UOM Category,UOM kategória,
+UOM Conversion Detail,Detail konverzie MJ,
+Variant Field,Variantné pole,
+A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny.",
+Warehouse Detail,Sklad Detail,
+Warehouse Name,Názov skladu,
+"If blank, parent Warehouse Account or company default will be considered","Ak je prázdny, bude sa brať do úvahy predvolený účet rodičovského skladu alebo spoločnosť",
+Warehouse Contact Info,Sklad Kontaktní informace,
+PIN,PIN,
+Raised By (Email),Vznesené (e-mail),
+Issue Type,Typ vydania,
+Issue Split From,Vydanie rozdelené z,
+Service Level,Úroveň služieb,
+Response By,Odpoveď používateľom,
+Response By Variance,Odpoveď podľa odchýlky,
+Service Level Agreement Fulfilled,Splnená dohoda o úrovni služieb,
+Ongoing,pokračujúce,
+Resolution By,Rozlíšenie podľa,
+Resolution By Variance,Rozlíšenie podľa odchýlky,
+Service Level Agreement Creation,Vytvorenie dohody o úrovni služieb,
+Mins to First Response,Min First Response,
+First Responded On,Prvně odpovězeno dne,
+Resolution Details,Rozlišení Podrobnosti,
+Opening Date,Otvárací dátum,
+Opening Time,Otevírací doba,
+Resolution Date,Rozlišení Datum,
+Via Customer Portal,Prostredníctvom zákazníckeho portálu,
+Support Team,Tým podpory,
+Issue Priority,Priorita vydania,
+Service Day,Servisný deň,
+Workday,pracovný deň,
+Holiday List (ignored during SLA calculation),Zoznam sviatkov (ignorovaný počas výpočtu SLA),
+Default Priority,Predvolená priorita,
+Response and Resoution Time,Čas odozvy a resoúcie,
+Priorities,priority,
+Support Hours,Čas podpory,
+Support and Resolution,Podpora a rozlíšenie,
+Default Service Level Agreement,Predvolená dohoda o úrovni služieb,
+Entity,bytosť,
+Agreement Details,Podrobnosti dohody,
+Response and Resolution Time,Čas odozvy a riešenia problémov,
+Service Level Priority,Priorita na úrovni služby,
+Response Time,Doba odozvy,
+Response Time Period,Časová lehota odozvy,
+Resolution Time,Čas riešenia,
+Resolution Time Period,Časové rozlíšenie riešenia,
+Support Search Source,Zdroj vyhľadávania podpory,
+Source Type,typ zdroja,
+Query Route String,Dotaz reťazca trasy,
+Search Term Param Name,Hľadaný výraz Param Name,
+Response Options,Možnosti odpovede,
+Response Result Key Path,Cesta kľúča výsledku odpovede,
+Post Route String,Pridať reťazec trasy,
+Post Route Key List,Pridať zoznam kľúčov,
+Post Title Key,Kľúč správy titulu,
+Post Description Key,Popisný kľúč Popis,
+Link Options,Možnosti odkazu,
+Source DocType,Zdroj DocType,
+Result Title Field,Pole Názov výsledku,
+Result Preview Field,Pole pre zobrazenie výsledkov,
+Result Route Field,Výsledok Pole trasy,
+Service Level Agreements,Dohody o úrovni služieb,
+Track Service Level Agreement,Dohoda o úrovni sledovania služieb,
+Allow Resetting Service Level Agreement,Povoliť obnovenie dohody o úrovni služieb,
+Close Issue After Days,Close Issue po niekoľkých dňoch,
+Auto close Issue after 7 days,Auto zavrieť Issue po 7 dňoch,
+Support Portal,Podporný portál,
+Get Started Sections,Začnite sekcie,
+Show Latest Forum Posts,Zobraziť najnovšie príspevky vo fórach,
+Forum Posts,Fórum príspevky,
+Forum URL,Adresa URL fóra,
+Get Latest Query,Získajte najnovší dotaz,
+Response Key List,Zoznam kľúčových odpovedí,
+Post Route Key,Pridať kľúč trasy,
+Search APIs,API vyhľadávania,
+SER-WRN-.YYYY.-,SER-WRN-.YYYY.-,
+Issue Date,Datum vydání,
+Item and Warranty Details,Položka a Záruka Podrobnosti,
+Warranty / AMC Status,Záruka / AMC Status,
+Resolved By,Vyřešena,
+Service Address,Servisní adresy,
+If different than customer address,Pokud se liší od adresy zákazníka,
+Raised By,Vznesené,
+From Company,Od Společnosti,
+Rename Tool,Nástroj na premenovanie,
+Utilities,Utilities,
+Type of document to rename.,Typ dokumentu na premenovanie.,
+File to Rename,Súbor premenovať,
+"Attach .csv file with two columns, one for the old name and one for the new name","Pripojiť CSV súbor s dvomi stĺpci, jeden pre starý názov a jeden pre nový názov",
+Rename Log,Premenovať Log,
+SMS Log,SMS Log,
+Sender Name,Meno odosielateľa,
+Sent On,Poslané na,
+No of Requested SMS,Počet žádaným SMS,
+Requested Numbers,Požadované Čísla,
+No of Sent SMS,Počet odeslaných SMS,
+Sent To,Odoslané na,
+Absent Student Report,Absent Študent Report,
+Assessment Plan Status,Stav plánu hodnotenia,
+Asset Depreciation Ledger,Asset Odpisy Ledger,
+Asset Depreciations and Balances,Asset Odpisy a zostatkov,
+Available Stock for Packing Items,K dispozici skladem pro balení položek,
+Bank Clearance Summary,Súhrn bankového zúčtovania,
+Bank Remittance,Bankový prevod,
+Batch Item Expiry Status,Batch Item Zánik Status,
+Batch-Wise Balance History,Batch-Wise Balance History,
+BOM Explorer,Prieskumník kusovníka,
+BOM Search,BOM Search,
+BOM Stock Calculated,Výpočet zásob BOM,
+BOM Variance Report,Správa o odchýlkach kusovníka,
+Campaign Efficiency,Efektívnosť kampane,
+Cash Flow,Cash Flow,
+Completed Work Orders,Dokončené pracovné príkazy,
+To Produce,K výrobě,
+Produced,Produkoval,
+Consolidated Financial Statement,Konsolidovaný finančný výkaz,
+Course wise Assessment Report,Priebežná hodnotiaca správa,
+Customer Acquisition and Loyalty,Zákazník Akvizice a loajality,
+Customer Credit Balance,Zákazník Credit Balance,
+Customer Ledger Summary,Zhrnutie knihy odberateľov,
+Customer-wise Item Price,Cena tovaru podľa priania zákazníka,
+Customers Without Any Sales Transactions,Zákazníci bez akýchkoľvek predajných transakcií,
+Daily Timesheet Summary,Denný súhrn pracovných výkazov,
+Daily Work Summary Replies,Denné zhrnutie pracovných odpovedí,
+DATEV,DATEV,
+Delayed Item Report,Prehľad oneskorených položiek,
+Delayed Order Report,Správa o oneskorení objednávky,
+Delivered Items To Be Billed,Dodávaných výrobků fakturovaných,
+Delivery Note Trends,Dodací list Trendy,
+Department Analytics,Analýza oddelenia,
+Electronic Invoice Register,Elektronický register faktúr,
+Employee Advance Summary,Súhrnný prehľad zamestnancov,
+Employee Billing Summary,Súhrn fakturácie zamestnancov,
+Employee Birthday,Narozeniny zaměstnance,
+Employee Information,Informace o zaměstnanci,
+Employee Leave Balance,Zostatok voľna pre zamestnanca,
+Employee Leave Balance Summary,Zhrnutie stavu zostatku zamestnancov,
+Employees working on a holiday,Zamestnanci pracujúci na dovolenku,
+Eway Bill,Eway Bill,
+Expiring Memberships,Platnosť členstva,
+Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC],
+Final Assessment Grades,Záverečné stupne hodnotenia,
+Fixed Asset Register,Register fixných aktív,
+Gross and Net Profit Report,Správa o hrubom a čistom zisku,
+GST Itemised Purchase Register,Registrovaný nákupný register spoločnosti GST,
+GST Itemised Sales Register,GST Podrobný predajný register,
+GST Purchase Register,Registrácia nákupov GST,
+GST Sales Register,Obchodný register spoločnosti GST,
+GSTR-1,GSTR-1,
+GSTR-2,GSTR-2,
+Hotel Room Occupancy,Hotel Occupancy,
+HSN-wise-summary of outward supplies,HSN-múdre zhrnutie vonkajších dodávok,
+Inactive Customers,Neaktívni zákazníci,
+Inactive Sales Items,Neaktívne predajné položky,
+IRS 1099,IRS 1099,
+Issued Items Against Work Order,Vydané položky proti pracovnému príkazu,
+Projected Quantity as Source,Množstvo projekciou as Zdroj,
+Item Balance (Simple),Zostatok položky (jednoduché),
+Item Price Stock,Položka Cena Sklad,
+Item Prices,Ceny Položek,
+Item Shortage Report,Položka Nedostatek Report,
+Project Quantity,projekt Množstvo,
+Item Variant Details,Podrobnosti o variantoch položky,
+Item-wise Price List Rate,Item-moudrý Ceník Rate,
+Item-wise Purchase History,Item-moudrý Historie nákupů,
+Item-wise Purchase Register,Item-moudrý Nákup Register,
+Item-wise Sales History,Item-moudrý Sales History,
+Item-wise Sales Register,Item-moudrý Sales Register,
+Items To Be Requested,Položky se budou vyžadovat,
+Reserved,Rezervováno,
+Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level,
+Lead Details,Podrobnosti Obchodnej iniciatívy,
+Lead Id,Id Obchodnej iniciatívy,
+Lead Owner Efficiency,Efektívnosť vlastníka iniciatívy,
+Loan Repayment and Closure,Splácanie a ukončenie pôžičky,
+Loan Security Status,Stav zabezpečenia úveru,
+Lost Opportunity,Stratená príležitosť,
+Maintenance Schedules,Plány údržby,
+Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny,
+Minutes to First Response for Issues,Zápisy do prvej reakcie na otázky,
+Minutes to First Response for Opportunity,Zápisy do prvej reakcie na príležitosť,
+Monthly Attendance Sheet,Měsíční Účast Sheet,
+Open Work Orders,Otvorte pracovné príkazy,
+Ordered Items To Be Billed,Objednané zboží fakturovaných,
+Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány",
+Qty to Deliver,Množství k dodání,
+Amount to Deliver,"Suma, ktorá má dodávať",
+Item Delivery Date,Dátum dodania položky,
+Delay Days,Oneskorené dni,
+Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury,
+Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka",
+Procurement Tracker,Sledovanie obstarávania,
+Product Bundle Balance,Zostatok produktu,
+Production Analytics,Analýza výroby,
+Profit and Loss Statement,Výkaz ziskov a strát,
+Profitability Analysis,Analýza ziskovosti,
+Project Billing Summary,Súhrn fakturácie projektu,
+Project wise Stock Tracking ,Sledování zboží dle projektu,
+Prospects Engaged But Not Converted,"Perspektívy zapojené, ale nekonvertované",
+Purchase Analytics,Analýza nákupu,
+Purchase Invoice Trends,Trendy přijatách faktur,
+Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci,
+Purchase Order Items To Be Received,Neprijaté položky odoslanej objednávky,
+Qty to Receive,Množství pro příjem,
+Purchase Order Items To Be Received or Billed,"Položky objednávok, ktoré majú byť prijaté alebo fakturované",
+Base Amount,Základná čiastka,
+Received Qty Amount,Prijatá suma Množstvo,
+Amount to Receive,Suma na príjem,
+Amount To Be Billed,"Suma, ktorá sa má fakturovať",
+Billed Qty,Účtované množstvo,
+Qty To Be Billed,Množstvo na vyúčtovanie,
+Purchase Order Trends,Nákupní objednávka trendy,
+Purchase Receipt Trends,Doklad o koupi Trendy,
+Purchase Register,Nákup Register,
+Quotation Trends,Vývoje ponúk,
+Quoted Item Comparison,Citoval Položka Porovnanie,
+Received Items To Be Billed,"Přijaté položek, které mají být účtovány",
+Requested Items To Be Ordered,Požadované položky je třeba objednat,
+Qty to Order,Množství k objednávce,
+Requested Items To Be Transferred,Požadované položky mají být převedeny,
+Qty to Transfer,Množství pro přenos,
+Salary Register,plat Register,
+Sales Analytics,Analýza predaja,
+Sales Invoice Trends,Prodejní faktury Trendy,
+Sales Order Trends,Prodejní objednávky Trendy,
+Sales Partner Commission Summary,Zhrnutie provízie obchodného partnera,
+Sales Partner Target Variance based on Item Group,Cieľová odchýlka odbytového partnera na základe skupiny položiek,
+Sales Partner Transaction Summary,Zhrnutie transakcií obchodného partnera,
+Sales Partners Commission,Obchodní partneři Komise,
+Average Commission Rate,Průměrná cena Komise,
+Sales Payment Summary,Prehľad platieb z predaja,
+Sales Person Commission Summary,Súhrnný prehľad komisie pre predajcov,
+Sales Person Target Variance Based On Item Group,Cieľová odchýlka predajnej osoby na základe skupiny položiek,
+Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce,
+Sales Register,Sales Register,
+Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti,
+Serial No Status,Serial No Status,
+Serial No Warranty Expiry,Pořadové č záruční lhůty,
+Stock Ageing,Starnutie zásob,
+Stock and Account Value Comparison,Porovnanie hodnoty zásob a účtu,
+Stock Projected Qty,Naprojektovaná úroveň zásob,
+Student and Guardian Contact Details,Študent a Guardian Kontaktné údaje,
+Student Batch-Wise Attendance,Študent Batch-Wise Účasť,
+Student Fee Collection,Študent Fee Collection,
+Student Monthly Attendance Sheet,Študent mesačná návštevnosť Sheet,
+Subcontracted Item To Be Received,"Subdodávaná položka, ktorá sa má prijať",
+Subcontracted Raw Materials To Be Transferred,"Subdodávateľské suroviny, ktoré sa majú preniesť",
+Supplier Ledger Summary,Zhrnutie knihy dodávateľov,
+Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics,
+Support Hour Distribution,Distribúcia hodín podpory,
+TDS Computation Summary,Zhrnutie výpočtu TDS,
+TDS Payable Monthly,TDS splatné mesačne,
+Territory Target Variance Based On Item Group,Variant teritoriálneho cieľa na základe skupiny položiek,
+Territory-wise Sales,Územný predaj,
+Total Stock Summary,Súhrnné zhrnutie zásob,
+Trial Balance,Trial Balance,
+Trial Balance (Simple),Skúšobný zostatok (jednoduchý),
+Trial Balance for Party,Trial váhy pre stranu,
+Unpaid Expense Claim,Neplatené Náklady nárok,
+Warehouse wise Item Balance Age and Value,Skladové číslo Položka Stav veku a hodnoty,
+Work Order Stock Report,Správa o stave pracovnej objednávky,
+Work Orders in Progress,Pracovné príkazy v procese,
