diff --git a/erpnext/translations/cs.csv b/erpnext/translations/cs.csv
index a5bad9c..5b149b0 100644
--- a/erpnext/translations/cs.csv
+++ b/erpnext/translations/cs.csv
@@ -25,7 +25,7 @@
 A {0} exists between {1} and {2} (,A {0} existuje mezi {1} a {2} (,
 A4,A4,
 API Endpoint,Koncový bod rozhraní API,
-API Key,Klíč API,
+API Key,klíč API,
 Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera,
 Abbreviation already used for another company,Zkratka již byla použita pro jinou společnost,
 Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků,
@@ -39,7 +39,7 @@
 Academic Year,Akademický rok,
 Academic Year: ,Akademický rok:,
 Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0},
-Access Token,Přístupový token,
+Access Token,Přístupový Token,
 Accessable Value,Přístupná hodnota,
 Account,Účet,
 Account Number,Číslo účtu,
@@ -83,7 +83,7 @@
 Accounts Payable Summary,Splatné účty Shrnutí,
 Accounts Receivable,Pohledávky,
 Accounts Receivable Summary,Pohledávky Shrnutí,
-Accounts User,Uživatel účtu,
+Accounts User,Uživatel Účtů,
 Accounts table cannot be blank.,Účty tabulka nemůže být prázdné.,
 Accrual Journal Entry for salaries from {0} to {1},Záznam o akruálním deníku pro platy od {0} do {1},
 Accumulated Depreciation,oprávky,
@@ -97,7 +97,6 @@
 Action Initialised,Inicializovaná akce,
 Actions,Akce,
 Active,Aktivní,
-Active Leads / Customers,Aktivní LEADS / Zákazníci,
 Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1},
 Activity Cost per Employee,Náklady na činnost na jednoho zaměstnance,
 Activity Type,Druh činnosti,
@@ -193,16 +192,13 @@
 All Territories,Všechny území,
 All Warehouses,Celý sklad,
 All communications including and above this shall be moved into the new Issue,Veškerá komunikace včetně a nad tímto se přesouvají do nového vydání,
-All items have already been invoiced,Všechny položky již byly fakturovány,
 All items have already been transferred for this Work Order.,Všechny položky byly již převedeny pro tuto pracovní objednávku.,
 All other ITC,Všechny ostatní ITC,
 All the mandatory Task for employee creation hasn't been done yet.,Veškerá povinná úloha pro tvorbu zaměstnanců dosud nebyla dokončena.,
-All these items have already been invoiced,Všechny tyto položky již byly fakturovány,
 Allocate Payment Amount,Přidělit částku platby,
 Allocated Amount,Přidělené sumy,
 Allocated Leaves,Přidělené listy,
 Allocating leaves...,Přidělení listů ...,
-Allow Delete,Povolit mazání,
 Already record exists for the item {0},Již existuje záznam pro položku {0},
 "Already set default in pos profile {0} for user {1}, kindly disabled default",Již nastavený výchozí profil {0} pro uživatele {1} je laskavě vypnut výchozí,
 Alternate Item,Alternativní položka,
@@ -252,7 +248,7 @@
 Appointments and Patient Encounters,Setkání a setkání s pacienty,
 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,Stav schválení,
 Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto""",
 Approve,Schvalovat,
 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,
@@ -306,7 +302,6 @@
 Attachments,Pří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á,
-Attendance Record {0} exists against Student {1},Účast Record {0} existuje proti Student {1},
 Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data,
 Attendance date can not be less than employee's joining date,Datum návštěvnost nemůže být nižší než spojovací data zaměstnance,
 Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen,
@@ -510,14 +505,13 @@
 Cashier Closing,Pokladní pokladna,
 Casual Leave,Casual Leave,
 Category,Kategorie,
-Category Name,Název Kategorie,
+Category Name,Název kategorie,
 Caution,Pozor,
 Central Tax,Centrální daň,
 Certification,Osvědčení,
 Cess,Cess,
 Change Amount,změna Částka,
 Change Item Code,Změnit kód položky,
-Change POS Profile,Změňte profil POS,
 Change Release Date,Změnit datum vydání,
 Change Template Code,Změnit kód šablony,
 Changing Customer Group for the selected Customer is not allowed.,Změna skupiny zákazníků pro vybraného zákazníka není povolena.,
@@ -536,7 +530,6 @@
 Cheque/Reference No,Šek / Referenční číslo,
 Cheques Required,Potřebné kontroly,
 Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávně vymazány,
-Child Item should not be a Product Bundle. Please remove item `{0}` and save,Dítě Položka by neměla být produkt Bundle. Odeberte položku `{0}` a uložit,
 Child Task exists for this Task. You can not delete this Task.,Dětská úloha existuje pro tuto úlohu. Tuto úlohu nelze odstranit.,
 Child nodes can be only created under 'Group' type nodes,Podřízené uzly mohou být vytvořeny pouze na základě typu uzly &quot;skupina&quot;,
 Child warehouse exists for this warehouse. You can not delete this warehouse.,Dítě sklad existuje pro tento sklad. Nemůžete odstranit tento sklad.,
@@ -585,7 +578,6 @@
 Company is manadatory for company account,Společnost je řídící na účet společnosti,
 Company name not same,Název společnosti není stejný,
 Company {0} does not exist,Společnost {0} neexistuje,
-"Company, Payment Account, From Date and To Date is mandatory","Společnost, platební účet, datum a datum jsou povinné",
 Compensatory Off,Vyrovnávací Off,
 Compensatory leave request days not in valid holidays,Kompenzační prázdniny nejsou v platných prázdninách,
 Complaint,Stížnost,
@@ -671,7 +663,6 @@
 Create Invoices,Vytvářejte faktury,
 Create Job Card,Vytvořit pracovní kartu,
 Create Journal Entry,Vytvořit zápis do deníku,
-Create Lab Test,Vytvořit laboratorní test,
 Create Lead,Vytvořit potenciálního zákazníka,
 Create Leads,vytvoření vede,
 Create Maintenance Visit,Vytvořte návštěvu údržby,
@@ -700,7 +691,6 @@
 Create Users,Vytvořit uživatele,
 Create Variant,Vytvořte variantu,
 Create Variants,Vytvoření variant,
-Create a new Customer,Vytvořit nový zákazník,
 "Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest.",
 Create customer quotes,Vytvořit citace zákazníků,
 Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.,
@@ -750,7 +740,6 @@
 Customer Contact,Kontakt se zákazníky,
 Customer Database.,Databáze zákazníků.,
 Customer Group,Zákazník Group,
-Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu,
 Customer LPO,Zákazník LPO,
 Customer LPO No.,Zákaznické číslo LPO,
 Customer Name,Jméno zákazníka,
@@ -807,7 +796,6 @@
 Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.,
 Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.,
 Default tax templates for sales and purchase are created.,Výchozí daňové šablony pro prodej a nákup jsou vytvořeny.,
-Default warehouse is required for selected item,Výchozí sklad je vyžadováno pro vybraná položka,
 Defaults,Výchozí,
 Defense,Obrana,
 Define Project type.,Definujte typ projektu.,
@@ -816,7 +804,6 @@
 Del,Del,
 Delay in payment (Days),Zpoždění s platbou (dny),
 Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost,
-Delete permanently?,Smazat trvale?,
 Deletion is not permitted for country {0},Smazání není povoleno pro zemi {0},
 Delivered,Dodává,
 Delivered Amount,Dodává Částka,
@@ -832,7 +819,7 @@
 Delivery Status,Delivery Status,
 Delivery Trip,Výlet za doručení,
 Delivery warehouse required for stock item {0},Dodávka sklad potřebný pro živočišnou položku {0},
-Department,oddělení,
+Department,Oddělení,
 Department Stores,Obchodní domy,
 Depreciation,Znehodnocení,
 Depreciation Amount,odpisy Částka,
@@ -868,7 +855,6 @@
 Discharge,Vybít,
 Discount,Sleva,
 Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.,
-Discount amount cannot be greater than 100%,Výše slevy nesmí být vyšší než 100%,
 Discount must be less than 100,Sleva musí být menší než 100,
 Diseases & Fertilizers,Nemoci a hnojiva,
 Dispatch,Odeslání,
@@ -888,7 +874,6 @@
 Document Name,Název dokumentu,
 Document Status,Stav dokumentu,
 Document Type,Typ dokumentu,
-Documentation,Dokumentace,
 Domain,Doména,
 Domains,Domény,
 Done,Hotový,
@@ -937,7 +922,6 @@
 Email Sent,Email odeslán,
 Email Template,Šablona e-mailu,
 Email not found in default contact,E-mail nebyl nalezen ve výchozím kontaktu,
-Email sent to supplier {0},E-mailu zaslaného na dodavatele {0},
 Email sent to {0},Email odeslán (komu) {0},
 Employee,Zaměstnanec,
 Employee A/C Number,Číslo A / C zaměstnance,
@@ -955,7 +939,6 @@
 Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,"Stav zaměstnance nelze nastavit na „Vlevo“, protože následující zaměstnanci v současné době hlásí tomuto zaměstnanci:",
 Employee {0} already submited an apllication {1} for the payroll period {2},Zaměstnanec {0} již podal žádost o platbu {2} {1},
 Employee {0} has already applied for {1} between {2} and {3} : ,Zaměstnanec {0} již požádal {1} mezi {2} a {3}:,
-Employee {0} has already applied for {1} on {2} : ,Zaměstnanec {0} již požádal o {1} dne {2}:,
 Employee {0} has no maximum benefit amount,Zaměstnanec {0} nemá maximální částku prospěchu,
 Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje,
 Employee {0} is on Leave on {1},Zaměstnanec {0} je zapnut Nechat na {1},
@@ -984,19 +967,17 @@
 Enter the name of the Beneficiary before submittting.,Před odesláním zadejte jméno příjemce.,
 Enter the name of the bank or lending institution before submittting.,Před zasláním zadejte název banky nebo instituce poskytující úvěr.,
 Enter value betweeen {0} and {1},Zadejte hodnotu mezi {0} a {1},
-Enter value must be positive,Zadejte hodnota musí být kladná,
 Entertainment & Leisure,Entertainment & Leisure,
 Entertainment Expenses,Výdaje na reprezentaci,
 Equity,Hodnota majetku,
 Error Log,Error Log,
 Error evaluating the criteria formula,Chyba při vyhodnocování vzorce kritéria,
 Error in formula or condition: {0},Chyba ve vzorci nebo stavu: {0},
-Error while processing deferred accounting for {0},Chyba při zpracování odloženého účetnictví pro {0},
 Error: Not a valid id?,Chyba: Není platný id?,
 Estimated Cost,Odhadované náklady,
 Evaluation,ohodnocení,
 "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,událost,
+Event,Událost,
 Event Location,Umístění události,
 Event Name,Název události,
 Exchange Gain/Loss,Exchange zisk / ztráta,
@@ -1019,7 +1000,6 @@
 Expense Claim {0} already exists for the Vehicle Log,Náklady na pojistná {0} již existuje pro jízd,
 Expense Claims,Nákladové Pohledávky,
 Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0},
-Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob,
 Expenses,Výdaje,
 Expenses Included In Asset Valuation,Náklady zahrnuté do ocenění majetku,
 Expenses Included In Valuation,Náklady ceně oceňování,
@@ -1079,7 +1059,6 @@
 Fiscal Year {0} does not exist,Fiskální rok {0} neexistuje,
 Fiscal Year {0} is required,Fiskální rok {0} je vyžadována,
 Fiscal Year {0} not found,Fiskální rok {0} nebyl nalezen,
-Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje,
 Fixed Asset,Základní Jmění,
 Fixed Asset Item must be a non-stock item.,Fixed Asset položky musí být non-skladová položka.,
 Fixed Assets,Dlouhodobý majetek,
@@ -1109,7 +1088,7 @@
 Free item code is not selected,Volný kód položky není vybrán,
 Freight and Forwarding Charges,Nákladní a Spediční Poplatky,
 Frequency,Frekvence,
-Friday,pátek,
+Friday,Pátek,
 From,Od,
 From Address 1,Z adresy 1,
 From Address 2,Z adresy 2,
@@ -1275,7 +1254,6 @@
 Import Day Book Data,Importovat údaje o denní knize,
 Import Log,Záznam importu,
 Import Master Data,Import kmenových dat,
-Import Successfull,Import byl úspěšný,
 Import in Bulk,Dovoz hromadnou,
 Import of goods,Dovoz zboží,
 Import of services,Dovoz služeb,
@@ -1322,7 +1300,7 @@
 Integrated Tax,Integrovaná daň,
 Inter-State Supplies,Mezistátní dodávky,
 Interest Amount,Zájem Částka,
-Interests,Zájmy,
+Interests,zájmy,
 Intern,Internovat,
 Internet Publishing,Internet Publishing,
 Intra-State Supplies,Vnitrostátní zásoby,
@@ -1356,11 +1334,10 @@
 Invoiced Amount,Fakturovaná částka,
 Invoices,Faktury,
 Invoices for Costumers.,Faktury pro zákazníky.,
-Inward Supplies(liable to reverse charge,Dočasné dodávky (podléhají zpětnému poplatku,
 Inward supplies from ISD,Spotřební materiál od ISD,
 Inward supplies liable to reverse charge (other than 1 & 2 above),Dočasné dodávky podléhající zpětnému poplatku (jiné než výše uvedené výše 1 a 2),
-Is Active,Je aktivní,
-Is Default,Je výchozí,
+Is Active,Je Aktivní,
+Is Default,Je Výchozí,
 Is Existing Asset,Je existujícímu aktivu,
 Is Frozen,Je Frozen,
 Is Group,Is Group,
@@ -1396,7 +1373,6 @@
 Item Variants updated,Varianty položek byly aktualizovány,
 Item has variants.,Položka má varianty.,
 Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidána pomocí tlačítka""položka získaná z dodacího listu""",
-Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka,
 Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu,
 Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy,
 Item {0} does not exist,Bod {0} neexistuje,
@@ -1438,7 +1414,6 @@
 Key Reports,Klíčové zprávy,
 LMS Activity,Aktivita LMS,
 Lab Test,Laboratorní test,
-Lab Test Prescriptions,Předpisy pro laboratorní testy,
 Lab Test Report,Zkušební protokol,
 Lab Test Sample,Laboratorní testovací vzorek,
 Lab Test Template,Šablona zkušebního laboratoře,
@@ -1513,8 +1488,6 @@
 Loans (Liabilities),Úvěry (závazky),
 Loans and Advances (Assets),Úvěry a zálohy (aktiva),
 Local,Místní,
-"LocalStorage is full , did not save","Místní úložiště je plná, nezachránil",
-"LocalStorage is full, did not save","Místní úložiště je plné, nezachránil",
 Log,Log,
 Logs for maintaining sms delivery status,Protokoly pro udržení stavu doručení sms,
 Lost,Ztracený,
@@ -1574,7 +1547,6 @@
 Marketing Expenses,Marketingové náklady,
 Marketplace,Trh,
 Marketplace Error,Chyba trhu,
-"Master data syncing, it might take some time","Kmenová data synchronizace, může to trvat nějaký čas",
 Masters,Masters,
 Match Payments with Invoices,Zápas platby fakturami,
 Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.,
@@ -1625,7 +1597,7 @@
 Merge Account,Sloučit účet,
 Merge with Existing Account,Sloučit se stávajícím účtem,
 "Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company",
-Message Examples,Příklady zpráv,
+Message Examples,Příklady Zpráv,
 Message Sent,Zpráva byla odeslána,
 Method,Metoda,
 Middle Income,Středními příjmy,
@@ -1645,7 +1617,7 @@
 Mode of payment is required to make a payment,Způsob platby je povinen provést platbu,
 Model,Model,
 Moderate Sensitivity,Mírná citlivost,
-Monday,pondělí,
+Monday,Pondělí,
 Monthly,Měsíčně,
 Monthly Distribution,Měsíční Distribution,
 Monthly Repayment Amount cannot be greater than Loan Amount,Měsíční splátka částka nemůže být větší než Výše úvěru,
@@ -1661,10 +1633,9 @@
 Multiple Loyalty Program found for the Customer. Please select manually.,Pro zákazníka byl nalezen vícenásobný věrnostní program. Zvolte prosím ručně.,
 "Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Více Cena pravidla existuje u stejných kritérií, prosím vyřešit konflikt tím, že přiřadí prioritu. Cena Pravidla: {0}",
 Multiple Variants,Více variant,
-Multiple default mode of payment is not allowed,Vícenásobný výchozí způsob platby není povolen,
 Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Několik fiskálních let existují pro data {0}. Prosím nastavte společnost ve fiskálním roce,
 Music,Hudba,
-My Account,Můj účet,
+My Account,Můj Účet,
 Name error: {0},Název chyba: {0},
 Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavateli",
 Name or Email is mandatory,Jméno nebo e-mail je povinné,
@@ -1696,9 +1667,7 @@
 New BOM,Nový BOM,
 New Batch ID (Optional),Nové číslo dávky (volitelné),
 New Batch Qty,Nové dávkové množství,
-New Cart,New košík,
 New Company,Nová společnost,
-New Contact,Nový kontakt,
 New Cost Center Name,Jméno Nového Nákladového Střediska,
 New Customer Revenue,Nový zákazník Příjmy,
 New Customers,noví zákazníci,
@@ -1715,7 +1684,7 @@
 New {0} pricing rules are created,Vytvoří se nová {0} pravidla pro tvorbu cen,
 Newsletters,Zpravodaje,
 Newspaper Publishers,Vydavatelé novin,
-Next,další,
+Next,Další,
 Next Contact By cannot be same as the Lead Email Address,Následující Kontakt Tím nemůže být stejný jako hlavní e-mailovou adresu,
 Next Contact Date cannot be in the past,Následující Kontakt datum nemůže být v minulosti,
 Next Steps,Další kroky,
@@ -1726,13 +1695,11 @@
 No Employee Found,Nebyl nalezen žádný zaměstnanec,
 No Item with Barcode {0},No Položka s čárovým kódem {0},
 No Item with Serial No {0},No Položka s Serial č {0},
-No Items added to cart,Do košíku nejsou přidány žádné položky,
 No Items available for transfer,K přenosu nejsou k dispozici žádné položky,
 No Items selected for transfer,Nebyly vybrány žádné položky pro přenos,
 No Items to pack,Žádné položky k balení,
 No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě,
 No Items with Bill of Materials.,Žádné položky s kusovníkem.,
-No Lab Test created,Nebyl vytvořen žádný laboratorní test,
 No Permission,Nemáte oprávnění,
 No Quote,Žádná citace,
 No Remarks,Žádné poznámky,
@@ -1745,8 +1712,6 @@
 No Work Orders created,Nebyly vytvořeny žádné pracovní příkazy,
 No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady,
 No active or default Salary Structure found for employee {0} for the given dates,Žádný aktivní nebo implicitní Plat Struktura nalezených pro zaměstnance {0} pro dané termíny,
-No address added yet.,Žádná adresa přidán dosud.,
-No contacts added yet.,Žádné kontakty přidán dosud.,
 No contacts with email IDs found.,Nebyly nalezeny žádné kontakty s identifikátory e-mailu.,
 No data for this period,Pro toto období nejsou k dispozici žádná data,
 No description given,No vzhledem k tomu popis,
@@ -1788,8 +1753,6 @@
 Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0},
 Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0},
 Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity,
-Not eligible for the admission in this program as per DOB,Není způsobilý pro přijetí do tohoto programu podle DOB,
-Not items found,Nebyl nalezen položek,
 Not permitted for {0},Není dovoleno {0},
 "Not permitted, configure Lab Test Template as required","Není povoleno, podle potřeby nastavte šablonu testování laboratoře",
 Not permitted. Please disable the Service Unit Type,Nepovoleno. Zakažte typ servisní jednotky,
@@ -1820,12 +1783,10 @@
 On Hold,Pozastaveno,
 On Net Total,On Net Celkem,
 One customer can be part of only single Loyalty Program.,Jeden zákazník může být součástí pouze jednoho loajálního programu.,
-Online,Online,
 Online Auctions,Aukce online,
 Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Nechte pouze aplikace, které mají status &quot;schváleno&quot; i &quot;Zamítnuto&quot; může být předložena",
 "Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Do následující tabulky bude vybrán pouze žadatel o studium se statusem &quot;Schváleno&quot;.,
 Only users with {0} role can register on Marketplace,Pouze uživatelé s rolí {0} se mohou zaregistrovat na trhu,
-Only {0} in stock for item {1},Pouze {0} skladem pro položku {1},
 Open BOM {0},Otevřená BOM {0},
 Open Item {0},Otevřít položku {0},
 Open Notifications,Otevřené Oznámení,
@@ -1899,7 +1860,6 @@
 PAN,PÁNEV,
 PO already created for all sales order items,PO již vytvořeno pro všechny položky prodejní objednávky,
 POS,POS,
-POS Closing Voucher alreday exists for {0} between date {1} and {2},POS Uzavírací kupón alreday existuje pro {0} mezi datem {1} a {2},
 POS Profile,POS Profile,
 POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro použití prodejního místa,
 POS Profile required to make POS Entry,"POS Profile požadováno, aby POS Vstup",
@@ -1953,7 +1913,6 @@
 "Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně.",
 Payment Gateway Name,Název platební 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 není nakonfigurován. Prosím zkontrolujte, zda je účet byl nastaven na režim plateb nebo na POS Profilu.",
 Payment Receipt Note,Doklad o zaplacení Note,
 Payment Request,Platba Poptávka,
 Payment Request for {0},Žádost o platbu za {0},
@@ -1971,7 +1930,6 @@
 Payroll,Mzdy,
 Payroll Number,Mzdové číslo,
 Payroll Payable,Mzdové Splatné,
-Payroll date can not be less than employee's joining date,"Den výplaty nesmí být menší, než je datum přihlášení zaměstnance",
 Payslip,výplatní páska,
 Pending Activities,Nevyřízené Aktivity,
 Pending Amount,Čeká Částka,
@@ -1992,7 +1950,6 @@
 Pharmaceuticals,Farmaceutické,
 Physician,Lékař,
 Piecework,Úkolová práce,
-Pin Code,PIN kód,
 Pincode,PSČ,
 Place Of Supply (State/UT),Místo dodávky (stát / UT),
 Place Order,Objednat,
@@ -2011,8 +1968,6 @@
 Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}",
 Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán",
 Please confirm once you have completed your training,Potvrďte prosím po dokončení školení,
-Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli",
-Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0},
 Please create purchase receipt or purchase invoice for the item {0},Pro položku {0} vytvořte potvrzení o nákupu nebo nákupní fakturu.,
 Please define grade for Threshold 0%,Zadejte prosím stupeň pro Threshold 0%,
 Please enable Applicable on Booking Actual Expenses,Uveďte prosím platný údaj o skutečných výdajích za rezervaci,
@@ -2032,7 +1987,6 @@
 Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no",
 Please enter Item first,"Prosím, nejdřív zadejte položku",
 Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti",
-Please enter Material Requests in the above table,"Prosím, zadejte Žádosti materiál ve výše uvedené tabulce",
 Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}",
 Please enter Preferred Contact Email,"Prosím, zadejte Preferred Kontakt e-mail",
 Please enter Production Item first,"Prosím, zadejte první výrobní položku",
@@ -2041,7 +1995,6 @@
 Please enter Reference date,"Prosím, zadejte Referenční den",
 Please enter Repayment Periods,"Prosím, zadejte dobu splácení",
 Please enter Reqd by Date,Zadejte Reqd podle data,
-Please enter Sales Orders in the above table,"Prosím, zadejte Prodejní objednávky v tabulce výše",
 Please enter Woocommerce Server URL,Zadejte adresu URL serveru Woocommerce,
 Please enter Write Off Account,"Prosím, zadejte odepsat účet",
 Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce,
@@ -2059,7 +2012,6 @@
 Please fill in all the details to generate Assessment Result.,"Vyplňte prosím všechny podrobnosti, abyste vygenerovali výsledek hodnocení.",
 Please identify/create Account (Group) for type - {0},Určete / vytvořte účet (skupinu) pro typ - {0},
 Please identify/create Account (Ledger) for type - {0},Určete / vytvořte účet (účetní kniha) pro typ - {0},
-Please input all required Result Value(s),Zadejte prosím všechny požadované hodnoty výsledků,
 Please login as another user to register on Marketplace,"Přihlaste se jako další uživatel, který se zaregistruje na trhu",
 Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět.",
 Please mention Basic and HRA component in Company,Uveďte prosím součást Basic a HRA ve společnosti,
@@ -2068,7 +2020,6 @@
 Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv",
 Please mention the Lead Name in Lead {0},Uvedete prosím vedoucí jméno ve vedoucím {0},
 Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list",
-Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení,
 Please register the SIREN number in the company information file,Zaregistrujte prosím číslo SIREN v informačním souboru společnosti,
 Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1},
 Please save the patient first,Nejprve uložit pacienta,
@@ -2090,7 +2041,6 @@
 Please select Course,Vyberte možnost Kurz,
 Please select Drug,Vyberte prosím lék,
 Please select Employee,Vyberte prosím zaměstnance,
-Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první.",
 Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh,
 Please select Healthcare Service,Vyberte prosím službu zdravotní péče,
 "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 skladem,&quot; je &quot;Ne&quot; a &quot;je Sales Item&quot; &quot;Ano&quot; a není tam žádný jiný produkt Bundle",
@@ -2111,22 +2061,18 @@
 Please select a Company,Vyberte společnost,
 Please select a batch,Vyberte dávku,
 Please select a csv file,Vyberte soubor csv,
-Please select a customer,Vyberte prosím zákazníka,
 Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla",
 Please select a table,Vyberte prosím tabulku,
 Please select a valid Date,Vyberte prosím platný datum,
 Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1},
 Please select a warehouse,Vyberte prosím sklad,
-Please select an item in the cart,Vyberte prosím položku v košíku,
 Please select at least one domain.,Vyberte alespoň jednu doménu.,
 Please select correct account,"Prosím, vyberte správný účet",
-Please select customer,Vyberte zákazníka,
 Please select date,"Prosím, vyberte datum",
 Please select item code,"Prosím, vyberte položku kód",
 Please select month and year,Vyberte měsíc a rok,
 Please select prefix first,"Prosím, vyberte první prefix",
 Please select the Company,Vyberte prosím společnost,
-Please select the Company first,Nejprve vyberte společnost,
 Please select the Multiple Tier Program type for more than one collection rules.,Zvolte typ víceúrovňového programu pro více než jednu pravidla kolekce.,
 Please select the assessment group other than 'All Assessment Groups',Vyberte jinou skupinu hodnocení než skupinu Všechny skupiny,
 Please select the document type first,Vyberte první typ dokumentu,
@@ -2155,7 +2101,6 @@
 Please set at least one row in the Taxes and Charges Table,Nastavte prosím alespoň jeden řádek v tabulce daní a poplatků,
 Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0},
 Please set default account in Salary Component {0},Prosím nastavit výchozí účet platu Component {0},
-Please set default customer group and territory in Selling Settings,Nastavte výchozí skupinu zákazníků a území v nastavení prodeje,
 Please set default customer in Restaurant Settings,Nastavte výchozího zákazníka v nastavení restaurace,
 Please set default template for Leave Approval Notification in HR Settings.,Prosím nastavte výchozí šablonu pro Notification Notification při nastavení HR.,
 Please set default template for Leave Status Notification in HR Settings.,Prosím nastavte výchozí šablonu pro ohlášení stavu o stavu v HR nastaveních.,
@@ -2217,7 +2162,6 @@
 Price List Rate,Ceník Rate,
 Price List master.,Ceník master.,
 Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej,
-Price List not found or disabled,Ceník nebyl nalezen nebo zakázán,
 Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje,
 Price or product discount slabs are required,Vyžadovány jsou desky s cenou nebo cenou produktu,
 Pricing,Stanovení ceny,
@@ -2226,7 +2170,6 @@
 "Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií.",
 Pricing Rule {0} is updated,Pravidlo pro stanovení cen {0} je aktualizováno,
 Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.,
-Primary,Primární,
 Primary Address Details,Údaje o primární adrese,
 Primary Contact Details,Primární kontaktní údaje,
 Principal Amount,jistina,
@@ -2334,7 +2277,6 @@
 Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1},
 Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}",
 Quantity must be less than or equal to {0},Množství musí být menší než nebo rovno {0},
-Quantity must be positive,Množství musí být kladné,
 Quantity must not be more than {0},Množství nesmí být větší než {0},
 Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1},
 Quantity should be greater than 0,Množství by měla být větší než 0,
@@ -2376,7 +2318,6 @@
 Receipt document must be submitted,Příjem dokument musí být předložen,
 Receivable,Pohledávky,
 Receivable Account,Účet pohledávky,
-Receive at Warehouse Entry,Příjem na vstupu do skladu,
 Received,Přijato,
 Received On,Přijaté On,
 Received Quantity,Přijaté množství,
@@ -2393,7 +2334,7 @@
 Reference #{0} dated {1},Reference # {0} ze dne {1},
 Reference Date,Referenční datum,
 Reference Doctype must be one of {0},Referenční Doctype musí být jedním z {0},
-Reference Document,Referenční dokument,
+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í datum je povinný pro bankovní transakce,
@@ -2432,12 +2373,10 @@
 Report Builder,Konfigurátor Reportu,
 Report Type,Typ výpisu,
 Report Type is mandatory,Report Type je povinné,
-Report an Issue,Nahlásit problém,
-Reports,Zprávy,
+Reports,zprávy,
 Reqd By Date,Př p Podle data,
 Reqd Qty,Požadovaný počet,
 Request for Quotation,Žádost o cenovou nabídku,
-"Request for Quotation is disabled to access from portal, for more check portal settings.",Žádost o cenovou nabídku je zakázán přístup z portálu pro více Zkontrolujte nastavení portálu.,
 Request for Quotations,Žádost o citátů,
 Request for Raw Materials,Žádost o suroviny,
 Request for purchase.,Žádost o koupi.,
@@ -2466,7 +2405,6 @@
 Reserved for sub contracting,Vyhrazeno pro uzavření smlouvy,
 Resistant,Odolný,
 Resolve error and upload again.,Vyřešte chybu a nahrajte znovu.,
-Response,Odpověď,
 Responsibilities,Odpovědnost,
 Rest Of The World,Zbytek světa,
 Restart Subscription,Restartujte předplatné,
@@ -2501,7 +2439,6 @@
 Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí být stejné, jako {1} {2}",
 Row # {0}: Cannot return more than {1} for Item {2},Řádek # {0}: Nelze vrátit více než {1} pro bodu {2},
 Row # {0}: Rate cannot be greater than the rate used in {1} {2},Řádek # {0}: Míra nemůže být větší než rychlost použitá v {1} {2},
-Row # {0}: Returned Item {1} does not exists in {2} {3},Řádek # {0}: vrácené položky {1} neexistuje v {2} {3},
 Row # {0}: Serial No is mandatory,Řádek # {0}: Výrobní číslo je povinné,
 Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3},
 Row #{0} (Payment Table): Amount must be negative,Řádek # {0} (platební tabulka): Částka musí být záporná,
@@ -2522,7 +2459,6 @@
 Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Řádek # {0}: Cena musí být stejné, jako {1}: {2} ({3} / {4})",
 Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Řádek # {0}: Referenční typ dokumentu musí být jedním z nákladového tvrzení nebo záznamu v deníku,
 "Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním z objednávky, faktury nebo Journal Entry",
-"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním ze zakázky odběratele, prodejní faktury nebo Journal Entry",
 Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat,
 Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1},
 Row #{0}: Reqd by Date cannot be before Transaction Date,Řádek # {0}: Reqd by Date nemůže být před datem transakce,
@@ -2552,7 +2488,6 @@
 Row {0}: Enter location for the asset item {1},Řádek {0}: Zadejte umístění položky aktiv {1},
 Row {0}: Exchange Rate is mandatory,Řádek {0}: Exchange Rate je povinné,
 Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Řádek {0}: Očekávaná hodnota po uplynutí životnosti musí být nižší než částka hrubého nákupu,
-Row {0}: For supplier {0} Email Address is required to send email,Řádek {0}: Pro dodavatele je zapotřebí {0} E-mailová adresa pro odeslání e-mailu,
 Row {0}: From Time and To Time is mandatory.,Řádek {0}: From Time a na čas je povinná.,
 Row {0}: From Time and To Time of {1} is overlapping with {2},Řádek {0}: čas od času i na čas z {1} se překrývá s {2},
 Row {0}: From time must be less than to time,Řádek {0}: Čas od času musí být kratší než čas,
@@ -2631,7 +2566,7 @@
 Sanctioned Amount,Sankcionována Částka,
 Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.,
 Sand,Písek,
-Saturday,sobota,
+Saturday,Sobota,
 Saved,Uloženo,
 Saving {0},Uložení {0},
 Scan Barcode,Naskenujte čárový kód,
@@ -2648,8 +2583,6 @@
 Scorecards,Scorecards,
 Scrapped,sešrotován,
 Search,Hledat,
-Search Item,Hledání položky,
-Search Item (Ctrl + i),Položka vyhledávání (Ctrl + i),
 Search Results,Výsledky vyhledávání,
 Search Sub Assemblies,Vyhledávání Sub Assemblies,
 "Search by item code, serial number, batch no or barcode","Vyhledávání podle kódu položky, sériového čísla, šarže nebo čárového kódu",
@@ -2671,7 +2604,6 @@
 Select BOM and Qty for Production,Vyberte BOM a Množství pro výrobu,
 "Select BOM, Qty and For Warehouse","Vyberte kusovník, množství a pro sklad",
 Select Batch,Vyberte možnost Dávka,
-Select Batch No,Vyberte číslo šarže,
 Select Batch Numbers,Zvolte čísla šarží,
 Select Brand...,Select Brand ...,
 Select Company,Vyberte společnost,
@@ -2685,7 +2617,6 @@
 Select Items based on Delivery Date,Vyberte položky podle data doručení,
 Select Items to Manufacture,Vyberte položky do Výroba,
 Select Loyalty Program,Vyberte Věrnostní program,
-Select POS Profile,Zvolte Profil POS,
 Select Patient,Vyberte pacienta,
 Select Possible Supplier,Vyberte Možné dodavatele,
 Select Property,Vyberte vlastnost,
@@ -2698,8 +2629,6 @@
 Select at least one value from each of the attributes.,Vyberte alespoň jednu hodnotu z každého atributu.,
 Select change amount account,Vybrat změna výše účet,
 Select company first,Nejprve vyberte společnost,
-Select items to save the invoice,"Vyberte položky, které chcete uložit fakturu",
-Select or add new customer,Vyberte nebo přidání nového zákazníka,
 Select students manually for the Activity based Group,Vyberte studenty ručně pro skupinu založenou na aktivitách,
 Select the customer or supplier.,Vyberte zákazníka nebo dodavatele.,
 Select the nature of your business.,Vyberte podstatu svého podnikání.,
@@ -2713,7 +2642,6 @@
 Selling Price List,Prodejní ceník,
 Selling Rate,Prodejní sazba,
 "Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}",
-Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní cena pro položku {0} je nižší než její {1}. Míra prodeje by měla být nejméně {2},
 Send Grant Review Email,Odeslání e-mailu o revizi grantu,
 Send Now,Odeslat nyní,
 Send SMS,Pošlete SMS,
@@ -2740,7 +2668,6 @@
 Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je již uvedeno v prodejní faktuře: {1},
 Serial Numbers,Sériová čísla,
 Serial Numbers in row {0} does not match with Delivery Note,Sériová čísla v řádku {0} neodpovídají poznámce k doručení,
-Serial no item cannot be a fraction,Sériové žádná položka nemůže být zlomkem,
 Serial no {0} has been already returned,Sériové číslo {0} již bylo vráceno,
 Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou,
 Serialized Inventory,Serialized Zásoby,
@@ -2768,7 +2695,6 @@
 Set as Lost,Nastavit jako Lost,
 Set as Open,Nastavit jako Otevřít,
 Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář,
-Set default mode of payment,Nastavte výchozí způsob platby,
 Set this if the customer is a Public Administration company.,"Nastavte, pokud je zákazníkem společnost veřejné správy.",
 Set {0} in asset category {1} or company {2},Nastavte {0} v kategorii aktiv {1} nebo ve firmě {2},
 "Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavení událostí do {0}, protože zaměstnanec připojena k níže prodejcům nemá ID uživatele {1}",
@@ -2918,7 +2844,6 @@
 Student Group,Student Group,
 Student Group Strength,Síla skupiny studentů,
 Student Group is already updated.,Studentská skupina je již aktualizována.,
-Student Group or Course Schedule is mandatory,Studentská skupina nebo program je povinný,
 Student Group: ,Studentská skupina:,
 Student ID,Student ID,
 Student ID: ,Student ID:,
@@ -2942,7 +2867,6 @@
 Submit Salary Slip,Odeslat výplatní pásce,
 Submit this Work Order for further processing.,Předložit tuto pracovní objednávku k dalšímu zpracování.,
 Submit this to create the Employee record,"Chcete-li vytvořit záznam zaměstnance, odešlete jej",
-Submitted orders can not be deleted,Předložené objednávky nelze smazat,
 Submitting Salary Slips...,Odeslání platebních karet ...,
 Subscription,Předplatné,
 Subscription Management,Řízení předplatného,
@@ -2960,7 +2884,6 @@
 Summary for this week and pending activities,Shrnutí pro tento týden a probíhajícím činnostem,
 Sunday,Neděle,
 Suplier,Suplier,
-Suplier Name,Jméno suplier,
 Supplier,Dodavatel,
 Supplier Group,Skupina dodavatelů,
 Supplier Group master.,Hlavní dodavatel skupiny.,
@@ -2971,7 +2894,6 @@
 Supplier Name,Dodavatel Name,
 Supplier Part No,Žádný dodavatel Part,
 Supplier Quotation,Dodavatel Nabídka,
-Supplier Quotation {0} created,Dodavatel Cen {0} vytvořil,
 Supplier Scorecard,Hodnotící karta dodavatele,
 Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení,
 Supplier database.,Databáze dodavatelů.,
@@ -2987,8 +2909,6 @@
 Support Tickets,Vstupenky na podporu,
 Support queries from customers.,Podpora dotazy ze strany zákazníků.,
 Susceptible,Citlivý,
-Sync Master Data,Sync Master Data,
-Sync Offline Invoices,Sync Offline Faktury,
 Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizace byla dočasně deaktivována, protože byly překročeny maximální počet opakování",
 Syntax error in condition: {0},Chyba syntaxe ve stavu: {0},
 Syntax error in formula or condition: {0},syntaktická chyba ve vzorci nebo stavu: {0},
@@ -3037,7 +2957,6 @@
 Terms and Conditions,Podmínky,
 Terms and Conditions Template,Podmínky Template,
 Territory,Území,
-Territory is Required in POS Profile,Území je vyžadováno v POS profilu,
 Test,Test,
 Thank you,Děkujeme Vám,
 Thank you for your business!,Děkuji za Váš obchod!,
@@ -3169,7 +3088,6 @@
 Total Allocated Leaves,Celkové přidělené listy,
 Total Amount,Celková částka,
 Total Amount Credited,Celková částka připsána,
-Total Amount {0},Celková částka {0},
 Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,"Celkový počet použitelných poplatcích v dokladu o koupi zboží, které tabulky musí být stejná jako celkem daní a poplatků",
 Total Budget,Celkový rozpočet,
 Total Collected: {0},Celkové shromáždění: {0},
@@ -3282,10 +3200,7 @@
 Unverified Webhook Data,Neověřené data Webhook,
 Update Account Name / Number,Aktualizovat název účtu / číslo,
 Update Account Number / Name,Aktualizovat číslo účtu / název,
-Update Bank Transaction Dates,Transakční Data aktualizace Bank,
 Update Cost,Aktualizace nákladů,
-Update Cost Center Number,Aktualizovat číslo nákladového střediska,
-Update Email Group,Aktualizace Email Group,
 Update Items,Aktualizovat položky,
 Update Print Format,Aktualizace Print Format,
 Update Response,Aktualizace odpovědi,
@@ -3299,7 +3214,6 @@
 Use Sandbox,použití Sandbox,
 Used Leaves,Použité listy,
 User,Uživatel,
-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,
@@ -3392,7 +3306,7 @@
 Website Listing,Seznam webových stránek,
 Website Manager,Správce webu,
 Website Settings,Nastavení www stránky,
-Wednesday,středa,
+Wednesday,Středa,
 Week,Týden,
 Weekdays,V pracovní dny,
 Weekly,Týdenní,
@@ -3425,7 +3339,6 @@
 Wrapping up,Obalte se,
 Wrong Password,Špatné heslo,
 Year start date or end date is overlapping with {0}. To avoid please set company,Rok datum zahájení nebo ukončení se překrývá s {0}. Aby se zabránilo nastavte firmu,
-You are in offline mode. You will not be able to reload until you have network.,"Jste v režimu offline. Nebudete moci obnovit stránku, dokud nebudete na síťi.",
 You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0},
 You are not authorized to approve leaves on Block Dates,Nejste oprávněni schvalovat listí na bloku Termíny,
 You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení,
@@ -3481,7 +3394,6 @@
 {0} - {1} is not enrolled in the Course {2},{0} - {1} není zařazen do kurzu {2},
 {0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude přesahovat o {5},
 {0} Digest,{0} Digest,
-{0} Number {1} already used in account {2},{0} Číslo {1} již použité v účtu {2},
 {0} Request for {1},{0} Žádost o {1},
 {0} Result submittted,{0} Výsledek byl předložen,
 {0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériová čísla požadované pro položky {1}. Poskytli jste {2}.,
@@ -3556,7 +3468,6 @@
 {0} {1} not in any active Fiscal Year.,{0} {1} není v žádném aktivním fiskální rok.,
 {0} {1} status is {2},{0} {1} je stav {2},
 {0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""výkaz zisků a ztrát"" typ účtu {2} není povolen do Otevírací vstup",
-{0} {1}: Account {2} cannot be a Group,{0} {1}: Účet {2} nemůže být skupina,
 {0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatří do společnosti {3},
 {0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktivní,
 {0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Účetní Vstup pro {2} mohou být prováděny pouze v měně: {3},
@@ -3582,11 +3493,19 @@
 "Dear System Manager,","Vážení System Manager,",
 Default Value,Výchozí hodnota,
 Email Group,Email Group,
+Email Settings,Nastavení emailu,
+Email not sent to {0} (unsubscribed / disabled),Email není poslán do {0} (odhlásili / vypnuto),
+Error Message,Chybové hlášení,
 Fieldtype,Typ pole,
+Help Articles,Články nápovědy,
 ID,ID,
 Images,snímky,
 Import,Importovat,
+Language,Jazyk,
+Likes,Záliby,
+Merge with existing,Sloučit s existujícím,
 Office,Kancelář,
+Orientation,Orientace,
 Passive,Pasivní,
 Percent,Procento,
 Permanent,Trvalý,
@@ -3595,14 +3514,17 @@
 Post,Příspěvek,
 Postal,Poštovní,
 Postal Code,PSČ,
+Previous,Předchozí,
 Provider,Poskytovatel,
 Read Only,Pouze pro čtení,
 Recipient,Příjemce,
 Reviews,Recenze,
-Sender,Odesílatel,
+Sender,Odesilatel,
 Shop,Obchod,
+Sign Up,Přihlásit se,
 Subsidiary,Dceřiný,
 There is some problem with the file url: {0},Tam je nějaký problém s URL souboru: {0},
+There were errors while sending email. Please try again.,Narazili jsme na problémy při odesílání emailu. Prosím zkuste to znovu.,
 Values Changed,hodnoty Změnil,
 or,nebo,
 Ageing Range 4,Rozsah stárnutí 4,
@@ -3634,20 +3556,26 @@
 Show {0},Zobrazit {0},
 "Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Zvláštní znaky kromě &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; A &quot;}&quot; nejsou v názvových řadách povoleny",
 Target Details,Podrobnosti o cíli,
-{0} already has a Parent Procedure {1}.,{0} již má rodičovský postup {1}.,
 API,API,
 Annual,Roční,
 Approved,Schválený,
 Change,Změna,
 Contact Email,Kontaktní e-mail,
+Export Type,Typ exportu,
 From Date,Od data,
 Group By,Skupina vytvořená,
 Importing {0} of {1},Importuje se {0} z {1},
+Invalid URL,neplatná URL,
+Landscape,Krajina,
 Last Sync On,Poslední synchronizace je zapnutá,
 Naming Series,Číselné řady,
 No data to export,Žádné údaje k exportu,
+Portrait,Portrét,
 Print Heading,Tisk záhlaví,
+Show Document,Zobrazit dokument,
+Show Traceback,Zobrazit Traceback,
 Video,Video,
+Webhook Secret,Webhook Secret,
 % Of Grand Total,% Z celkového součtu,
 'employee_field_value' and 'timestamp' are required.,jsou vyžadovány &#39;customer_field_value&#39; a &#39;timestamp&#39;.,
 <b>Company</b> is a mandatory filter.,<b>Společnost</b> je povinný filtr.,
@@ -3735,12 +3663,10 @@
 Cancelled,Zrušeno,
 Cannot Calculate Arrival Time as Driver Address is Missing.,"Nelze vypočítat čas příjezdu, protože chybí adresa řidiče.",
 Cannot Optimize Route as Driver Address is Missing.,"Nelze optimalizovat trasu, protože chybí adresa ovladače.",
-"Cannot Unpledge, loan security value is greater than the repaid amount","Nelze zrušit, hodnota zabezpečení úvěru je vyšší než splacená částka",
 Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,"Nelze dokončit úkol {0}, protože jeho závislá úloha {1} není dokončena / zrušena.",
 Cannot create loan until application is approved,"Dokud nebude žádost schválena, nelze vytvořit půjčku",
 Cannot find a matching Item. Please select some other value for {0}.,Nelze najít odpovídající položku. Vyberte nějakou jinou hodnotu pro {0}.,
 "Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nelze přeplatit za položku {0} v řádku {1} více než {2}. Chcete-li povolit nadměrnou fakturaci, nastavte v Nastavení účtu povolenky",
-Cannot unpledge more than {0} qty of {0},Nelze odpojit více než {0} množství z {0},
 "Capacity Planning Error, planned start time can not be same as end time","Chyba plánování kapacity, plánovaný čas zahájení nemůže být stejný jako čas ukončení",
 Categories,Kategorie,
 Changes in {0},Změny v {0},
@@ -3780,7 +3706,7 @@
 Customer PO,Zákaznická PO,
 Customize,Přizpůsobit,
 Daily,Denně,
-Date,datum,
+Date,Datum,
 Date Range,Časové období,
 Date of Birth cannot be greater than Joining Date.,Datum narození nemůže být větší než datum připojení.,
 Dear,Vážený (á),
@@ -3796,7 +3722,6 @@
 Difference Value,Hodnota rozdílu,
 Dimension Filter,Filtr rozměrů,
 Disabled,Vypnuto,
-Disbursed Amount cannot be greater than loan amount,Vyplacená částka nesmí být vyšší než výše půjčky,
 Disbursement and Repayment,Vyplacení a vrácení,
 Distance cannot be greater than 4000 kms,Vzdálenost nesmí být větší než 4000 km,
 Do you want to submit the material request,Chcete odeslat materiální žádost,
@@ -3847,8 +3772,6 @@
 File Manager,Správce souborů,
 Filters,Filtry,
 Finding linked payments,Nalezení propojených plateb,
-Finished Product,Dokončený produkt,
-Finished Qty,Dokončeno Množství,
 Fleet Management,Fleet management,
 Following fields are mandatory to create address:,K vytvoření adresy jsou povinná následující pole:,
 For Month,Za měsíc,
@@ -3857,7 +3780,6 @@
 For quantity {0} should not be greater than work order quantity {1},Pro množství {0} by nemělo být větší než množství pro pracovní objednávku {1},
 Free item not set in the pricing rule {0},Bezplatná položka není nastavena v cenovém pravidle {0},
 From Date and To Date are Mandatory,Od data do dne jsou povinné,
-From date can not be greater than than To date,Od data nemůže být větší než Do dne,
 From employee is required while receiving Asset {0} to a target location,Od zaměstnance je vyžadováno při přijímání díla {0} na cílové místo,
 Fuel Expense,Náklady na palivo,
 Future Payment Amount,Částka budoucí platby,
@@ -3885,11 +3807,10 @@
 In Progress,Pokrok,
 Incoming call from {0},Příchozí hovor od {0},
 Incorrect Warehouse,Nesprávný sklad,
-Interest Amount is mandatory,Výše úroku je povinná,
 Intermediate,přechodný,
 Invalid Barcode. There is no Item attached to this barcode.,Neplatný čárový kód. K tomuto čárovému kódu není připojena žádná položka.,
 Invalid credentials,Neplatné přihlašovací údaje,
-Invite as User,Pozvat jako uživatel,
+Invite as User,Pozvat jako Uživatel,
 Issue Priority.,Priorita vydání.,
 Issue Type.,Typ problému.,
 "It seems that there is an issue with the server's stripe configuration. In case of failure, the amount will get refunded to your account.","Zdá se, že je problém s konfigurací proužku serveru. V případě selhání bude částka vrácena na váš účet.",
@@ -3898,7 +3819,6 @@
 Item quantity can not be zero,Množství položky nemůže být nula,
 Item taxes updated,Daň z položek byla aktualizována,
 Item {0}: {1} qty produced. ,Položka {0}: {1} vyrobeno množství.,
-Items are required to pull the raw materials which is associated with it.,"Položky jsou vyžadovány pro tahání surovin, které jsou s ním spojeny.",
 Joining Date can not be greater than Leaving Date,Datum připojení nesmí být větší než datum opuštění,
 Lab Test Item {0} already exist,Testovací položka laboratoře {0} již existuje,
 Last Issue,Poslední vydání,
@@ -3914,10 +3834,7 @@
 Loan Processes,Úvěrové procesy,
 Loan Security,Zabezpečení půjčky,
 Loan Security Pledge,Úvěrový příslib,
-Loan Security Pledge Company and Loan Company must be same,Společnost poskytující záruku za půjčku a společnost pro půjčku musí být stejná,
 Loan Security Pledge Created : {0},Vytvořen záložní úvěr: {0},
-Loan Security Pledge already pledged against loan {0},Zástavní záruka na úvěr již byla zajištěna proti půjčce {0},
-Loan Security Pledge is mandatory for secured loan,Peníze za zajištění úvěru jsou povinné pro zajištěný úvěr,
 Loan Security Price,Cena za půjčku,
 Loan Security Price overlapping with {0},Cena půjčky se překrývá s {0},
 Loan Security Unpledge,Zabezpečení úvěru Unpledge,
@@ -3969,7 +3886,6 @@
 Not permitted. Please disable the Lab Test Template,Nepovoleno. Zakažte prosím šablonu pro testování laboratoře,
 Note,Poznámka,
 Notes: ,Poznámky:,
-Offline,Offline,
 On Converting Opportunity,O převodu příležitostí,
 On Purchase Order Submission,Při zadávání objednávky,
 On Sales Order Submission,Při zadávání prodejní objednávky,
@@ -4013,9 +3929,7 @@
 Please enter GSTIN and state for the Company Address {0},Zadejte GSTIN a uveďte adresu společnosti {0},
 Please enter Item Code to get item taxes,"Zadejte kód položky, abyste získali daně z zboží",
 Please enter Warehouse and Date,Zadejte prosím sklad a datum,
-Please enter coupon code !!,Zadejte kód kupónu !!,
 Please enter the designation,Zadejte označení,
-Please enter valid coupon code !!,Zadejte prosím platný kuponový kód !!,
 Please login as a Marketplace User to edit this item.,"Chcete-li tuto položku upravit, přihlaste se jako uživatel Marketplace.",
 Please login as a Marketplace User to report this item.,"Chcete-li tuto položku nahlásit, přihlaste se jako uživatel Marketplace.",
 Please select <b>Template Type</b> to download template,Vyberte <b>šablonu</b> pro stažení šablony,
@@ -4083,7 +3997,6 @@
 Release date must be in the future,Datum vydání musí být v budoucnosti,
 Relieving Date must be greater than or equal to Date of Joining,Datum vydání musí být větší nebo rovno Datum připojení,
 Rename,Přejmenovat,
-Rename Not Allowed,Přejmenovat není povoleno,
 Repayment Method is mandatory for term loans,Způsob splácení je povinný pro termínované půjčky,
 Repayment Start Date is mandatory for term loans,Datum zahájení splácení je povinné pro termínované půjčky,
 Report Item,Položka sestavy,
@@ -4092,7 +4005,6 @@
 Reset,resetovat,
 Reset Service Level Agreement,Obnovit dohodu o úrovni služeb,
 Resetting Service Level Agreement.,Obnovení dohody o úrovni služeb.,
-Response Time for {0} at index {1} can't be greater than Resolution Time.,Doba odezvy pro {0} při indexu {1} nemůže být delší než doba řešení.,
 Return amount cannot be greater unclaimed amount,Vrácená částka nemůže být větší nevyžádaná částka,
 Review,Posouzení,
 Room,Pokoj,
@@ -4124,7 +4036,6 @@
 Save,Uložit,
 Save Item,Uložit položku,
 Saved Items,Uložené položky,
-Scheduled and Admitted dates can not be less than today,Plánovaná a přijatá data nemohou být menší než dnes,
 Search Items ...,Prohledat položky ...,
 Search for a payment,Vyhledejte platbu,
 Search for anything ...,Hledat cokoli ...,
@@ -4147,12 +4058,10 @@
 Series,Série,
 Server Error,Chyba serveru,
 Service Level Agreement has been changed to {0}.,Smlouva o úrovni služeb byla změněna na {0}.,
-Service Level Agreement tracking is not enabled.,Sledování dohody o úrovni služeb není povoleno.,
 Service Level Agreement was reset.,Dohoda o úrovni služeb byla resetována.,
 Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Dohoda o úrovni služeb s typem entity {0} a entitou {1} již existuje.,
 Set,Nastavit,
 Set Meta Tags,Nastavte značky meta,
-Set Response Time and Resolution for Priority {0} at index {1}.,Nastavte čas odezvy a rozlišení pro prioritu {0} na indexu {1}.,
 Set {0} in company {1},Set {0} ve společnosti {1},
 Setup,Nastavení,
 Setup Wizard,Průvodce nastavením,
@@ -4164,9 +4073,6 @@
 Show Warehouse-wise Stock,Zobrazit skladové zásoby,
 Size,Velikost,
 Something went wrong while evaluating the quiz.,Při vyhodnocování kvízu se něco pokazilo.,
-"Sorry,coupon code are exhausted","Litujeme, kód kupónu je vyčerpán",
-"Sorry,coupon code validity has expired","Litujeme, platnost kódu kupónu vypršela",
-"Sorry,coupon code validity has not started","Litujeme, platnost kódu kupónu nezačala",
 Sr,Řádek,
 Start,Start,
 Start Date cannot be before the current date,Datum zahájení nemůže být před aktuálním datem,
@@ -4202,7 +4108,6 @@
 The selected payment entry should be linked with a creditor bank transaction,Vybraný platební záznam by měl být spojen s transakcí věřitelské banky,
 The selected payment entry should be linked with a debtor bank transaction,Vybraný platební záznam by měl být spojen s transakcí s dlužníkem,
 The total allocated amount ({0}) is greated than the paid amount ({1}).,Celková přidělená částka ({0}) je převedena na zaplacenou částku ({1}).,
-The value {0} is already assigned to an exisiting Item {2}.,Hodnota {0} je již přiřazena k existující položce {2}.,
 There are no vacancies under staffing plan {0},V rámci personálního plánu nejsou žádná volná místa {0},
 This Service Level Agreement is specific to Customer {0},Tato smlouva o úrovni služeb je specifická pro zákazníka {0},
 This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Tato akce odpojí tento účet od jakékoli externí služby integrující ERPNext s vašimi bankovními účty. Nelze jej vrátit zpět. Jsi si jistý ?,
@@ -4227,7 +4132,7 @@
 Transactions already retreived from the statement,Transakce již byly z výkazu odebrány,
 Transfer Material to Supplier,Přeneste materiál Dodavateli,
 Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Číslo a datum dopravy jsou pro zvolený druh dopravy povinné,
-Tuesday,úterý,
+Tuesday,Úterý,
 Type,Typ,
 Unable to find Salary Component {0},Nelze najít komponentu platu {0},
 Unable to find the time slot in the next {0} days for the operation {1}.,V následujících {0} dnech operace nebylo možné najít časový úsek {1}.,
@@ -4249,7 +4154,6 @@
 Vacancies cannot be lower than the current openings,Volná pracovní místa nemohou být nižší než stávající otvory,
 Valid From Time must be lesser than Valid Upto Time.,Platný od času musí být menší než platný až do doby.,
 Valuation Rate required for Item {0} at row {1},Míra ocenění požadovaná pro položku {0} v řádku {1},
-"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting / cancelling this entry.","Míra ocenění nebyla pro položku {0} nalezena, což je nutné pro účetní záznamy pro {1} {2}. Pokud položka obchoduje jako položka s nulovou hodnotou ocenění v {1}, uveďte to v tabulce {1} Položka. V opačném případě vytvořte příchozí transakci s akciemi pro položku nebo uveďte záznamovou hodnotu v záznamu o položce a zkuste tento záznam odeslat nebo zrušit.",
 Values Out Of Sync,Hodnoty ze synchronizace,
 Vehicle Type is required if Mode of Transport is Road,"Typ vozidla je vyžadován, pokud je způsob dopravy silniční",
 Vendor Name,Jméno prodejce,
@@ -4272,7 +4176,6 @@
 You can Feature upto 8 items.,Můžete zadat až 8 položek.,
 You can also copy-paste this link in your browser,Můžete také kopírovat - vložit tento odkaz do Vašeho prohlížeče,
 You can publish upto 200 items.,Můžete publikovat až 200 položek.,
-You can't create accounting entries in the closed accounting period {0},V uzavřeném účetním období nelze vytvářet účetní záznamy {0},
 You have to enable auto re-order in Stock Settings to maintain re-order levels.,"Chcete-li zachovat úrovně opětovného objednání, musíte povolit automatickou změnu pořadí v Nastavení skladu.",
 You must be a registered supplier to generate e-Way Bill,"Chcete-li vygenerovat e-Way Bill, musíte být registrovaným dodavatelem",
 You need to login as a Marketplace User before you can add any reviews.,"Než budete moci přidat recenze, musíte se přihlásit jako uživatel Marketplace.",
@@ -4280,7 +4183,6 @@
 Your Items,Vaše položky,
 Your Profile,Tvůj profil,
 Your rating:,Vase hodnoceni:,
-Zero qty of {0} pledged against loan {0},Nulové množství z {0} přislíbilo proti půjčce {0},
 and,a,
 e-Way Bill already exists for this document,Pro tento dokument již existuje e-Way Bill,
 woocommerce - {0},woocommerce - {0},
@@ -4295,7 +4197,6 @@
 {0} is not a group node. Please select a group node as parent cost center,{0} není skupinový uzel. Vyberte skupinový uzel jako nadřazené nákladové středisko,
 {0} is not the default supplier for any items.,{0} není výchozím dodavatelem pro žádné položky.,
 {0} is required,{0} je vyžadováno,
-{0} units of {1} is not available.,{0} jednotek {1} není k dispozici.,
 {0}: {1} must be less than {2},{0}: {1} musí být menší než {2},
 {} is an invalid Attendance Status.,{} je neplatný stav účasti.,
 {} is required to generate E-Way Bill JSON,{} je vyžadován pro vygenerování E-Way Bill JSON,
@@ -4306,10 +4207,12 @@
 Total Income,Celkový příjem,
 Total Income This Year,Celkový příjem v tomto roce,
 Barcode,čárový kód,
+Bold,tučně,
 Center,Střed,
 Clear,Průhledná,
 Comment,Komentář,
 Comments,Komentáře,
+DocType,DocType,
 Download,Stažení,
 Left,Zbývá,
 Link,Odkaz,
@@ -4376,7 +4279,6 @@
 Projected qty,Promítané množství,
 Sales person,Prodej Osoba,
 Serial No {0} Created,Pořadové číslo {0} vytvořil,
-Set as default,Nastavit jako výchozí,
 Source Location is required for the Asset {0},Místo zdroje je požadováno pro daný účet {0},
 Tax Id,DIČ,
 To Time,Chcete-li čas,
@@ -4387,7 +4289,6 @@
 Variance ,Odchylka,
 Variant of,Varianta,
 Write off,Odepsat,
-Write off Amount,Odepsat Částka,
 hours,Hodiny,
 received from,Přijaté Od,
 to,na,
@@ -4407,9 +4308,30 @@
 Supplier > Supplier Type,Dodavatel&gt; Typ dodavatele,
 Please setup Employee Naming System in Human Resource > HR Settings,Nastavte prosím systém názvů zaměstnanců v části Lidské zdroje&gt; Nastavení lidských zdrojů,
 Please setup numbering series for Attendance via Setup > Numbering Series,Nastavte číslovací řady pro Docházku prostřednictvím Nastavení&gt; Číslovací řady,
+The value of {0} differs between Items {1} and {2},Hodnota {0} se mezi položkami {1} a {2} liší.,
+Auto Fetch,Auto Fetch,
+Fetch Serial Numbers based on FIFO,Načíst sériová čísla na základě FIFO,
+"Outward taxable supplies(other than zero rated, nil rated and exempted)","Dodávky podléhající zdanění (jiné než nulové, nulové a osvobozené od daně)",
+"To allow different rates, disable the {0} checkbox in {1}.","Chcete-li povolit různé sazby, deaktivujte {0} zaškrtávací políčko v {1}.",
+Current Odometer Value should be greater than Last Odometer Value {0},Aktuální hodnota počítadla kilometrů by měla být větší než hodnota posledního počítadla kilometrů {0},
+No additional expenses has been added,Nebyly přidány žádné další výdaje,
+Asset{} {assets_link} created for {},Prostředek {} {assets_link} vytvořen pro {},
+Row {}: Asset Naming Series is mandatory for the auto creation for item {},Řádek {}: Série pojmenování děl je povinná pro automatické vytváření položky {},
+Assets not created for {0}. You will have to create asset manually.,Podklady nebyly vytvořeny pro {0}. Aktivitu budete muset vytvořit ručně.,
+{0} {1} has accounting entries in currency {2} for company {3}. Please select a receivable or payable account with currency {2}.,{0} {1} má účetní záznamy v měně {2} pro společnost {3}. Vyberte pohledávku nebo závazek s měnou {2}.,
+Invalid Account,Neplatný účet,
 Purchase Order Required,Vydaná objednávka je vyžadována,
 Purchase Receipt Required,Příjmka je vyžadována,
+Account Missing,Účet chybí,
 Requested,Požadované,
+Partially Paid,Částečně zaplaceno,
+Invalid Account Currency,Neplatná měna účtu,
+"Row {0}: The item {1}, quantity must be positive number","Řádek {0}: Položka {1}, množství musí být kladné číslo",
+"Please set {0} for Batched Item {1}, which is used to set {2} on Submit.","Nastavte {0} pro dávkovou položku {1}, která se používá k nastavení {2} při odeslání.",
+Expiry Date Mandatory,Datum ukončení platnosti je povinné,
+Variant Item,Varianta položky,
+BOM 1 {0} and BOM 2 {1} should not be same,Kusovník 1 {0} a kusovník 2 {1} by neměly být stejné,
+Note: Item {0} added multiple times,Poznámka: Položka {0} byla přidána několikrát,
 YouTube,Youtube,
 Vimeo,Vimeo,
 Publish Date,Datum publikování,
@@ -4418,19 +4340,170 @@
 Path,Cesta,
 Components,Komponenty,
 Verified By,Verified By,
+Invalid naming series (. missing) for {0},Neplatná pojmenovací řada (. Chybí) pro {0},
+Filter Based On,Filtr založený na,
+Reqd by date,Dotaz podle data,
+Manufacturer Part Number <b>{0}</b> is invalid,Číslo dílu výrobce <b>{0}</b> je neplatné,
+Invalid Part Number,Neplatné číslo dílu,
+Select atleast one Social Media from Share on.,Vyberte alespoň jedno sociální médium ze složky Sdílet na.,
+Invalid Scheduled Time,Neplatný naplánovaný čas,
+Length Must be less than 280.,Délka musí být menší než 280.,
+Error while POSTING {0},Chyba při odesílání {0},
+"Session not valid, Do you want to login?","Relace není platná, chcete se přihlásit?",
+Session Active,Aktivní relace,
+Session Not Active. Save doc to login.,Relace není aktivní. Uložit dokument pro přihlášení.,
+Error! Failed to get request token.,Chyba! Získání tokenu požadavku se nezdařilo.,
+Invalid {0} or {1},Neplatné {0} nebo {1},
+Error! Failed to get access token.,Chyba! Získání přístupového tokenu se nezdařilo.,
+Invalid Consumer Key or Consumer Secret Key,Neplatný klíč zákazníka nebo tajný klíč zákazníka,
+Your Session will be expire in ,Vaše relace vyprší za,
+ days.,dnů.,
+Session is expired. Save doc to login.,Platnost relace vypršela. Uložit dokument pro přihlášení.,
+Error While Uploading Image,Chyba při nahrávání obrázku,
+You Didn't have permission to access this API,Neměli jste oprávnění k přístupu k tomuto API,
+Valid Upto date cannot be before Valid From date,Platné aktuální datum nemůže být dříve než platné od data,
+Valid From date not in Fiscal Year {0},"Platné od data, které není ve fiskálním roce {0}",
+Valid Upto date not in Fiscal Year {0},Platné aktuální datum není ve fiskálním roce {0},
+Group Roll No,Skupinová role č,
 Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu,
+"Row {1}: Quantity ({0}) cannot be a fraction. To allow this, disable '{2}' in UOM {3}.","Řádek {1}: Množství ({0}) nemůže být zlomek. Chcete-li to povolit, deaktivujte „{2}“ v MOM {3}.",
 Must be Whole Number,Musí být celé číslo,
+Please setup Razorpay Plan ID,Nastavte ID plánu Razorpay,
+Contact Creation Failed,Vytvoření kontaktu se nezdařilo,
+{0} already exists for employee {1} and period {2},{0} již pro zaměstnance {1} a období {2} existuje,
+Leaves Allocated,Listy přidělené,
+Leaves Expired,Listy vypršely,
+Leave Without Pay does not match with approved {} records,Leave Without Pay neodpovídá schváleným {} záznamům,
+Income Tax Slab not set in Salary Structure Assignment: {0},V přiřazení struktury platu není nastavena deska daně z příjmu: {0},
+Income Tax Slab: {0} is disabled,Deska daně z příjmu: {0} je deaktivována,
+Income Tax Slab must be effective on or before Payroll Period Start Date: {0},Deska daně z příjmu musí být účinná k datu zahájení mezd: {0},
+No leave record found for employee {0} on {1},Nebyl nalezen záznam o dovolené zaměstnance {0} dne {1},
+Row {0}: {1} is required in the expenses table to book an expense claim.,Řádek {0}: {1} je v tabulce výdajů vyžadován k zaúčtování nároku na výdaj.,
+Set the default account for the {0} {1},Nastavit výchozí účet pro {0} {1},
+(Half Day),(Půldenní),
+Income Tax Slab,Deska daně z příjmu,
+Row #{0}: Cannot set amount or formula for Salary Component {1} with Variable Based On Taxable Salary,Řádek č. {0}: Nelze nastavit částku nebo vzorec pro složku mzdy {1} s proměnnou založenou na zdanitelném platu,
+Row #{}: {} of {} should be {}. Please modify the account or select a different account.,Řádek č. {}: {} Z {} by měl být {}. Upravte účet nebo vyberte jiný účet.,
+Row #{}: Please asign task to a member.,Řádek # {}: Přiřaďte úkol členovi.,
+Process Failed,Proces se nezdařil,
+Tally Migration Error,Chyba migrace Tally,
+Please set Warehouse in Woocommerce Settings,Nastavte Warehouse v nastavení Woocommerce,
+Row {0}: Delivery Warehouse ({1}) and Customer Warehouse ({2}) can not be same,Řádek {0}: Dodací sklad ({1}) a Zákaznický sklad ({2}) nemohou být stejné,
+Row {0}: Due Date in the Payment Terms table cannot be before Posting Date,Řádek {0}: Datum splatnosti v tabulce Platební podmínky nemůže být před datem zaúčtování,
+Cannot find {} for item {}. Please set the same in Item Master or Stock Settings.,Nelze najít {} pro položku {}. Totéž prosím nastavte v Předloze položky nebo Nastavení skladu.,
+Row #{0}: The batch {1} has already expired.,Řádek č. {0}: Dávce {1} již vypršela platnost.,
+Start Year and End Year are mandatory,Začátek a konec roku jsou povinné,
 GL Entry,Vstup GL,
+Cannot allocate more than {0} against payment term {1},Nelze přidělit více než {0} proti platebnímu termínu {1},
+The root account {0} must be a group,Kořenový účet {0} musí být skupina,
+Shipping rule not applicable for country {0} in Shipping Address,Pravidlo pro přepravu se nevztahuje na zemi {0} uvedenou v dodací adrese,
+Get Payments from,Získejte platby od,
+Set Shipping Address or Billing Address,Nastavte dodací adresu nebo fakturační adresu,
+Consultation Setup,Nastavení konzultace,
 Fee Validity,Platnost poplatku,
+Laboratory Setup,Laboratorní nastavení,
 Dosage Form,Dávkovací forma,
+Records and History,Záznamy a historie,
 Patient Medical Record,Záznam pacienta,
+Rehabilitation,Rehabilitace,
+Exercise Type,Typ cvičení,
+Exercise Difficulty Level,Úroveň obtížnosti cvičení,
+Therapy Type,Typ terapie,
+Therapy Plan,Terapeutický plán,
+Therapy Session,Terapeutické sezení,
+Motor Assessment Scale,Stupnice hodnocení motoru,
+[Important] [ERPNext] Auto Reorder Errors,[Důležité] [ERPNext] Chyby automatického řazení,
+"Regards,","Pozdravy,",
+The following {0} were created: {1},Byly vytvořeny následující {0}: {1},
+Work Orders,Pracovní příkazy,
+The {0} {1} created sucessfully,{0} {1} vytvořil úspěšně,
+Work Order cannot be created for following reason: <br> {0},Pracovní příkaz nelze vytvořit z následujícího důvodu:<br> {0},
+Add items in the Item Locations table,Přidejte položky do tabulky Umístění položek,
+Update Current Stock,Aktualizujte aktuální sklad,
+"{0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Ponechat vzorek je založen na dávce. Chcete-li uchovat vzorek položky, zaškrtněte políčko Má dávka č",
+Empty,Prázdný,
+Currently no stock available in any warehouse,Momentálně nejsou v žádném skladu k dispozici žádné zásoby,
+BOM Qty,Počet kusů,
+Time logs are required for {0} {1},Pro {0} {1} jsou vyžadovány časové protokoly,
 Total Completed Qty,Celkem dokončeno Množství,
 Qty to Manufacture,Množství K výrobě,
+Repay From Salary can be selected only for term loans,Výplatu z platu lze vybrat pouze u termínovaných půjček,
+No valid Loan Security Price found for {0},Nebyla nalezena platná cena zabezpečení půjčky pro {0},
+Loan Account and Payment Account cannot be same,Úvěrový účet a platební účet nemohou být stejné,
+Loan Security Pledge can only be created for secured loans,Slib zajištění půjčky lze vytvořit pouze pro zajištěné půjčky,
+Social Media Campaigns,Kampaně na sociálních médiích,
+From Date can not be greater than To Date,Od data nemůže být větší než od data,
+Please set a Customer linked to the Patient,Nastavte prosím zákazníka spojeného s pacientem,
+Customer Not Found,Zákazník nebyl nalezen,
+Please Configure Clinical Procedure Consumable Item in ,Nakonfigurujte prosím spotřební položku klinického postupu ve Windows,
+Missing Configuration,Chybějící konfigurace,
 Out Patient Consulting Charge Item,Položka pro poplatek za konzultaci s pacientem,
 Inpatient Visit Charge Item,Poplatek za návštěvu pacienta,
 OP Consulting Charge,Konzultační poplatek OP,
 Inpatient Visit Charge,Poplatek za návštěvu v nemocnici,
+Appointment Status,Stav schůzky,
+Test: ,Test:,
+Collection Details: ,Podrobnosti o kolekci:,
+{0} out of {1},{0} z {1},
+Select Therapy Type,Vyberte typ terapie,
+{0} sessions completed,Dokončené relace: {0},
+{0} session completed,{0} relace dokončena,
+ out of {0},z {0},
+Therapy Sessions,Terapeutická sezení,
+Add Exercise Step,Přidejte krok cvičení,
+Edit Exercise Step,Upravit krok cvičení,
+Patient Appointments,Jmenování pacientů,
+Item with Item Code {0} already exists,Položka s kódem položky {0} již existuje,
+Registration Fee cannot be negative or zero,Registrační poplatek nesmí být záporný ani nulový,
+Configure a service Item for {0},Nakonfigurujte položku služby pro {0},
+Temperature: ,Teplota:,
+Pulse: ,Puls:,
+Respiratory Rate: ,Dechová frekvence:,
+BP: ,BP:,
+BMI: ,BMI:,
+Note: ,Poznámka:,
 Check Availability,Zkontrolujte dostupnost,
+Please select Patient first,Nejprve vyberte pacienta,
+Please select a Mode of Payment first,Nejprve prosím vyberte způsob platby,
+Please set the Paid Amount first,Nejprve prosím nastavte zaplacenou částku,
+Not Therapies Prescribed,Nejsou předepsané terapie,
+There are no Therapies prescribed for Patient {0},Pacientovi nejsou předepsány žádné terapie {0},
+Appointment date and Healthcare Practitioner are Mandatory,Datum schůzky a lékař jsou povinní,
+No Prescribed Procedures found for the selected Patient,U vybraného pacienta nebyly nalezeny žádné předepsané postupy,
+Please select a Patient first,Nejprve vyberte pacienta,
+There are no procedure prescribed for ,Není stanoven žádný postup,
+Prescribed Therapies,Předepsané terapie,
+Appointment overlaps with ,Schůzka se překrývá s,
+{0} has appointment scheduled with {1} at {2} having {3} minute(s) duration.,{0} má naplánovanou schůzku s {1} na {2} s trváním {3} minut.,
+Appointments Overlapping,Překrývání schůzek,
+Consulting Charges: {0},Poplatky za konzultaci: {0},
+Appointment Cancelled. Please review and cancel the invoice {0},Schůzka byla zrušena. Zkontrolujte a zrušte fakturu {0},
+Appointment Cancelled.,Schůzka byla zrušena.,
+Fee Validity {0} updated.,Platnost poplatku {0} aktualizována.,
+Practitioner Schedule Not Found,Rozvrh lékaře nebyl nalezen,
+{0} is on a Half day Leave on {1},{0} je na půldenní dovolenou dne {1},
+{0} is on Leave on {1},{0} je na dovolené dne {1},
+{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner,{0} nemá harmonogram praktického lékaře. Přidejte jej do Healthcare Practitioner,
+Healthcare Service Units,Jednotky zdravotní péče,
+Complete and Consume,Vyplňte a spotřebujte,
+Complete {0} and Consume Stock?,Dokončit {0} a spotřebovat zásoby?,
+Complete {0}?,Dokončit {0}?,
+Stock quantity to start the Procedure is not available in the Warehouse {0}. Do you want to record a Stock Entry?,Skladové množství pro zahájení postupu není ve skladu k dispozici {0}. Chcete zaznamenat skladovou položku?,
+{0} as on {1},{0} jako dne {1},
+Clinical Procedure ({0}):,Klinický postup ({0}):,
+Please set Customer in Patient {0},Nastavte prosím zákazníka v pacientovi {0},
+Item {0} is not active,Položka {0} není aktivní,
+Therapy Plan {0} created successfully.,Terapeutický plán {0} byl úspěšně vytvořen.,
+Symptoms: ,Příznaky:,
+No Symptoms,Žádné příznaky,
+Diagnosis: ,Diagnóza:,
+No Diagnosis,Žádná diagnóza,
+Drug(s) Prescribed.,Předepsané léky.,
+Test(s) Prescribed.,Předepsané testy.,
+Procedure(s) Prescribed.,Předepsaný postup.,
+Counts Completed: {0},Počty dokončeny: {0},
+Patient Assessment,Hodnocení pacienta,
+Assessments,Hodnocení,
 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ázev účtu,
 Inter Company Account,Inter podnikový účet,
@@ -4441,6 +4514,8 @@
 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,Zůstatek musí být,
+Lft,Lft,
+Rgt,Rgt,
 Old Parent,Staré nadřazené,
 Include in gross,Zahrňte do hrubého,
 Auditor,Auditor,
@@ -4473,7 +4548,6 @@
 Unlink Payment on Cancellation of Invoice,Odpojit Platba o zrušení faktury,
 Unlink Advance Payment on Cancelation of Order,Odpojte zálohy na zrušení objednávky,
 Book Asset Depreciation Entry Automatically,Zúčtování odpisu majetku na účet automaticky,
-Allow Cost Center In Entry of Balance Sheet Account,Umožnit nákladovému středisku při zadávání účtu bilance,
 Automatically Add Taxes and Charges from Item Tax Template,Automaticky přidávat daně a poplatky ze šablony položky daně,
 Automatically Fetch Payment Terms,Automaticky načíst platební podmínky,
 Show Inclusive Tax In Print,Zobrazit inkluzivní daň v tisku,
@@ -4485,6 +4559,7 @@
 Use Custom Cash Flow Format,Použijte formát vlastní peněžní toky,
 Only select if you have setup Cash Flow Mapper documents,"Zvolte pouze, pokud máte nastavené dokumenty pro mapování cash flow",
 Allowed To Transact With,Povoleno k transakci s,
+SWIFT number,Číslo SWIFT,
 Branch Code,Kód pobočky,
 Address and Contact,Adresa a Kontakt,
 Address HTML,Adresa HTML,
@@ -4505,6 +4580,8 @@
 Last Integration Date,Datum poslední integrace,
 Change this date manually to setup the next synchronization start date,Toto datum změňte ručně a nastavte další datum zahájení synchronizace,
 Mask,Maska,
+Bank Account Subtype,Podtyp bankovního účtu,
+Bank Account Type,Typ bankovního účtu,
 Bank Guarantee,Bankovní záruka,
 Bank Guarantee Type,Typ bankovní záruky,
 Receiving,Příjem,
@@ -4513,6 +4590,7 @@
 Validity in Days,Platnost ve dnech,
 Bank Account Info,Informace o bankovním účtu,
 Clauses and Conditions,Doložky a podmínky,
+Other Details,Další detaily,
 Bank Guarantee Number,Číslo bankovní záruky,
 Name of Beneficiary,Název příjemce,
 Margin Money,Margin Money,
@@ -4546,6 +4624,7 @@
 Bank Statement Transaction Invoice Item,Položka faktury bankovního výpisu,
 Payment Description,Popis platby,
 Invoice Date,Datum Fakturace,
+invoice,faktura,
 Bank Statement Transaction Payment Item,Položka platební transakce bankovního účtu,
 outstanding_amount,nesplacená částka,
 Payment Reference,Odkaz na platby,
@@ -4609,6 +4688,7 @@
 Custody,Péče,
 Net Amount,Čistá částka,
 Cashier Closing Payments,Pokladní hotovostní platby,
+Chart of Accounts Importer,Dovozní tabulka účtů,
 Import Chart of Accounts from a csv file,Importujte graf účtů ze souboru csv,
 Attach custom Chart of Accounts file,Připojte vlastní soubor účtových účtů,
 Chart Preview,Náhled grafu,
@@ -4647,10 +4727,13 @@
 Gift Card,Dárková poukázka,
 unique e.g. SAVE20  To be used to get discount,jedinečný např. SAVE20 Slouží k získání slevy,
 Validity and Usage,Platnost a použití,
+Valid From,Platnost od,
+Valid Upto,Platí až,
 Maximum Use,Maximální využití,
 Used,Použitý,
 Coupon Description,Popis kupónu,
 Discounted Invoice,Zvýhodněná faktura,
+Debit to,Debet na,
 Exchange Rate Revaluation,Přehodnocení směnného kurzu,
 Get Entries,Získejte položky,
 Exchange Rate Revaluation Account,Účet z přecenění směnného kurzu,
@@ -4717,6 +4800,7 @@
 Inter Company Journal Entry Reference,Referenční položka Inter Company Journal Entry,
 Write Off Based On,Odepsat založené na,
 Get Outstanding Invoices,Získat neuhrazených faktur,
+Write Off Amount,Odepsaná částka,
 Printing Settings,Tisk Nastavení,
 Pay To / Recd From,Platit K / Recd Z,
 Payment Order,Platební příkaz,
@@ -4724,6 +4808,7 @@
 Journal Entry Account,Zápis do deníku Účet,
 Account Balance,Zůstatek na účtu,
 Party Balance,Balance Party,
+Accounting Dimensions,Účetní dimenze,
 If Income or Expense,Pokud je výnos nebo náklad,
 Exchange Rate,Exchange Rate,
 Debit in Company Currency,Debetní ve společnosti Měna,
@@ -4846,6 +4931,8 @@
 Month(s) after the end of the invoice month,Měsíc (měsíce) po skončení měsíce faktury,
 Credit Days,Úvěrové dny,
 Credit Months,Kreditní měsíce,
+Allocate Payment Based On Payment Terms,Přiřaďte platbu na základě platebních podmínek,
+"If this checkbox is checked, paid amount will be splitted and allocated as per the amounts in payment schedule against each payment term","Pokud je toto políčko zaškrtnuto, bude vyplacená částka rozdělena a přidělena podle částek v rozvrhu plateb proti každému platebnímu období",
 Payment Terms Template Detail,Platební podmínky,
 Closing Fiscal Year,Uzavření fiskálního roku,
 Closing Account Head,Závěrečný účet hlava,
@@ -4857,25 +4944,18 @@
 Company Address,adresa společnosti,
 Update Stock,Aktualizace skladem,
 Ignore Pricing Rule,Ignorovat Ceny pravidlo,
-Allow user to edit Rate,Umožnit uživateli upravovat Rate,
-Allow user to edit Discount,Umožnit uživateli upravit slevu,
-Allow Print Before Pay,Povolit tisk před zaplacením,
-Display Items In Stock,Zobrazit položky na skladě,
 Applicable for Users,Platí pro uživatele,
 Sales Invoice Payment,Prodejní faktury Platba,
 Item Groups,Položka Skupiny,
 Only show Items from these Item Groups,Zobrazovat pouze položky z těchto skupin položek,
 Customer Groups,Skupiny zákazníků,
 Only show Customer of these Customer Groups,Zobrazovat pouze Zákazníka těchto skupin zákazníků,
-Print Format for Online,Formát tisku pro online,
-Offline POS Settings,Nastavení offline offline,
 Write Off Account,Odepsat účet,
 Write Off Cost Center,Odepsat nákladové středisko,
 Account for Change Amount,Účet pro změnu Částka,
 Taxes and Charges,Daně a poplatky,
 Apply Discount On,Použít Sleva na,
 POS Profile User,Uživatel profilu POS,
-Use POS in Offline Mode,Používejte POS v režimu offline,
 Apply On,Naneste na,
 Price or Product Discount,Cena nebo sleva produktu,
 Apply Rule On Item Code,Použít pravidlo na kód položky,
@@ -4968,6 +5048,8 @@
 Additional Discount,Další slevy,
 Apply Additional Discount On,Použít dodatečné Sleva na,
 Additional Discount Amount (Company Currency),Dodatečná sleva Částka (Měna Company),
+Additional Discount Percentage,Další procento slevy,
+Additional Discount Amount,Dodatečná částka slevy,
 Grand Total (Company Currency),Celkový součet (Měna společnosti),
 Rounding Adjustment (Company Currency),Úprava zaokrouhlení (měna společnosti),
 Rounded Total (Company Currency),Celkem zaokrouhleno (měna solečnosti),
@@ -5048,6 +5130,7 @@
 "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,
+Item Wise Tax Detail ,Položka Wise Tax Detail,
 "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ýchozí banka / Peněžní účet budou automaticky aktualizovány v plat položka deníku je-li zvolen tento režim.,
@@ -5138,6 +5221,7 @@
 (including),(včetně),
 ACC-SH-.YYYY.-,ACC-SH-.YYYY.-,
 Folio no.,Číslo folia,
+Address and Contacts,Adresa a kontakty,
 Contact List,Seznam kontaktů,
 Hidden list maintaining the list of contacts linked to Shareholder,Skrytý seznam udržující seznam kontaktů spojených s Akcionářem,
 Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného,
@@ -5174,9 +5258,6 @@
 Additional DIscount Amount,Dodatečná sleva Částka,
 Subscription Invoice,Předplatné faktura,
 Subscription Plan,Plán předplatného,
-Price Determination,Stanovení ceny,
-Fixed rate,Fixní sazba,
-Based on price list,Na základě ceníku,
 Cost,Náklady,
 Billing Interval,Interval fakturace,
 Billing Interval Count,Počet fakturačních intervalů,
@@ -5187,7 +5268,6 @@
 Subscription Settings,Nastavení předplatného,
 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í data fakturace před zrušením předplatného nebo označením předplatného jako nezaplaceného,
-Cancel Invoice After Grace Period,Zrušit faktura po období odkladu,
 Prorate,Prorate,
 Tax Rule,Daňové Pravidlo,
 Tax Type,Daňové Type,
@@ -5219,6 +5299,7 @@
 Agriculture Manager,Zemědělský manažer,
 Agriculture User,Zemědělský uživatel,
 Agriculture Task,Zemědělské úkoly,
+Task Name,Jméno Task,
 Start Day,Den zahájení,
 End Day,Den konce,
 Holiday Management,Správa prázdnin,
@@ -5325,6 +5406,7 @@
 Next Depreciation Date,Vedle Odpisy Datum,
 Depreciation Schedule,Plán odpisy,
 Depreciation Schedules,odpisy Plány,
+Insurance details,Podrobnosti o pojištění,
 Policy number,Číslo politiky,
 Insurer,Pojišťovatel,
 Insured value,Pojistná hodnota,
@@ -5348,11 +5430,9 @@
 Capital Work In Progress Account,Pokročilý účet kapitálové práce,
 Asset Finance Book,Finanční kniha majetku,
 Written Down Value,Psaná hodnota dolů,
-Depreciation Start Date,Datum zahájení odpisování,
 Expected Value After Useful Life,Očekávaná hodnota po celou dobu životnosti,
 Rate of Depreciation,Míra odpisování,
 In Percentage,V procentech,
-Select Serial No,Zvolte pořadové číslo,
 Maintenance Team,Tým údržby,
 Maintenance Manager Name,Název správce údržby,
 Maintenance Tasks,Úkoly údržby,
@@ -5362,6 +5442,8 @@
 Maintenance Type,Typ Maintenance,
 Maintenance Status,Status Maintenance,
 Planned,Plánováno,
+Has Certificate ,Má certifikát,
+Certificate,Osvědčení,
 Actions performed,Akce byly provedeny,
 Asset Maintenance Task,Úloha údržby aktiv,
 Maintenance Task,Úloha údržby,
@@ -5369,6 +5451,7 @@
 Calibration,Kalibrace,
 2 Yearly,2 Každoročně,
 Certificate Required,Potřebný certifikát,
+Assign to Name,Přiřadit ke jménu,
 Next Due Date,Další datum splatnosti,
 Last Completion Date,Poslední datum dokončení,
 Asset Maintenance Team,Tým pro údržbu aktiv,
@@ -5420,17 +5503,20 @@
 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.,"Procento, které můžete převést více oproti objednanému množství. Například: Pokud jste si objednali 100 kusů. a vaše povolenka je 10%, pak můžete převést 110 jednotek.",
 PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-,
 Get Items from Open Material Requests,Položka získaná z žádostí Otevřít Materiál,
+Fetch items based on Default Supplier.,Načíst položky na základě výchozího dodavatele.,
 Required By,Vyžadováno,
 Order Confirmation No,Potvrzení objednávky č,
 Order Confirmation Date,Datum potvrzení objednávky,
 Customer Mobile No,Zákazník Mobile Žádné,
 Customer Contact Email,Zákazník Kontaktní e-mail,
 Set Target Warehouse,Nastavit cílový sklad,
+Sets 'Warehouse' in each row of the Items table.,Nastaví „Sklad“ v každém řádku tabulky Položky.,
 Supply Raw Materials,Dodávek surovin,
 Purchase Order Pricing Rule,Pravidlo pro stanovení ceny objednávky,
 Set Reserve Warehouse,Nastavit 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,
+Tracking,Sledování,
 % Billed,% Fakturováno,
 % Received,% Přijaté,
 Ref SQ,Ref SQ,
@@ -5455,6 +5541,7 @@
 PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-,
 For individual supplier,Pro jednotlivé dodavatele,
 Supplier Detail,dodavatel Detail,
+Link to Material Requests,Odkaz na materiálové požadavky,
 Message for Supplier,Zpráva pro dodavatele,
 Request for Quotation Item,Žádost o cenovou nabídku výtisku,
 Required Date,Požadovaná data,
@@ -5469,6 +5556,8 @@
 Is Transporter,Je Transporter,
 Represents Company,Zastupuje společnost,
 Supplier Type,Dodavatel Type,
+Allow Purchase Invoice Creation Without Purchase Order,Povolit vytvoření nákupní faktury bez nákupní objednávky,
+Allow Purchase Invoice Creation Without Purchase Receipt,Povolit vytvoření faktury za nákup bez dokladu o nákupu,
 Warn RFQs,Upozornění na RFQ,
 Warn POs,Varujte PO,
 Prevent RFQs,Zabraňte RFQ,
@@ -5524,6 +5613,9 @@
 Score,Skóre,
 Supplier Scorecard Scoring Standing,Hodnocení skóre dodavatele skóre,
 Standing Name,Stálé jméno,
+Purple,Nachový,
+Yellow,Žlutá,
+Orange,oranžový,
 Min Grade,Min Grade,
 Max Grade,Max stupeň,
 Warn Purchase Orders,Upozornění na nákupní objednávky,
@@ -5539,6 +5631,7 @@
 Received By,Přijato,
 Caller Information,Informace o volajícím,
 Contact Name,Kontakt Jméno,
+Lead ,Vést,
 Lead Name,Jméno leadu,
 Ringing,Zvoní,
 Missed,Zmeškal,
@@ -5576,6 +5669,7 @@
 Success Redirect URL,Adresa URL přesměrování úspěchu,
 "Leave blank for home.\nThis is relative to site URL, for example ""about"" will redirect to ""https://yoursitename.com/about""","Nechte prázdné pro domov. Toto je relativní k adrese URL webu, například „about“ přesměruje na „https://yoursitename.com/about“",
 Appointment Booking Slots,Výherní automaty pro jmenování,
+Day Of Week,Den v týdnu,
 From Time ,Času od,
 Campaign Email Schedule,Plán e-mailu kampaně,
 Send After (days),Odeslat po (dny),
@@ -5618,6 +5712,7 @@
 Follow Up,Následovat,
 Next Contact By,Další Kontakt By,
 Next Contact Date,Další Kontakt Datum,
+Ends On,Končí,
 Address & Contact,Adresa a kontakt,
 Mobile No.,Mobile No.,
 Lead Type,Typ leadu,
@@ -5630,6 +5725,14 @@
 Request for Information,Žádost o informace,
 Suggestions,Návrhy,
 Blog Subscriber,Blog Subscriber,
+LinkedIn Settings,Nastavení LinkedIn,
+Company ID,ID společnosti,
+OAuth Credentials,Pověření OAuth,
+Consumer Key,Klíč spotřebitele,
+Consumer Secret,Spotřebitelské tajemství,
+User Details,Detaily uživatele,
+Person URN,Osoba URN,
+Session Status,Stav relace,
 Lost Reason Detail,Detail ztraceného důvodu,
 Opportunity Lost Reason,Příležitost Ztracený důvod,
 Potential Sales Deal,Potenciální prodej,
@@ -5640,6 +5743,7 @@
 Converted By,Převedeno,
 Sales Stage,Prodejní fáze,
 Lost Reason,Důvod ztráty,
+Expected Closing Date,Očekávané datum uzávěrky,
 To Discuss,K projednání,
 With Items,S položkami,
 Probability (%),Pravděpodobnost (%),
@@ -5651,6 +5755,17 @@
 Opportunity Item,Položka Příležitosti,
 Basic Rate,Basic Rate,
 Stage Name,Pseudonym,
+Social Media Post,Sociální média příspěvek,
+Post Status,Post status,
+Posted,Vyslán,
+Share On,Sdílet na,
+Twitter,Cvrlikání,
+LinkedIn,LinkedIn,
+Twitter Post Id,ID příspěvku na Twitteru,
+LinkedIn Post Id,LinkedIn Post Id,
+Tweet,tweet,
+Twitter Settings,Nastavení Twitteru,
+API Secret Key,Tajný klíč API,
 Term Name,termín Name,
 Term Start Date,Termín Datum zahájení,
 Term End Date,Termín Datum ukončení,
@@ -5671,6 +5786,7 @@
 Maximum Assessment Score,Maximální skóre Assessment,
 Assessment Plan Criteria,Plan Assessment Criteria,
 Maximum Score,Maximální skóre,
+Result,Výsledek,
 Total Score,Celkové skóre,
 Grade,Školní známka,
 Assessment Result Detail,Posuzování Detail Výsledek,
@@ -5713,11 +5829,10 @@
 "For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pro kurzovou studentskou skupinu bude kurz pro každého studenta ověřen z přihlášených kurzů při zápisu do programu.,
 Make Academic Term Mandatory,Uveďte povinnost akademického termínu,
 "If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Je-li zapnuto, pole Akademický termín bude povinné v nástroji pro zápis programu.",
+Skip User creation for new Student,Přeskočit vytváření uživatelů pro nového studenta,
+"By default, a new User is created for every new Student. If enabled, no new User will be created when a new Student is created.","Ve výchozím nastavení je pro každého nového studenta vytvořen nový uživatel. Pokud je povoleno, při vytváření nového studenta nebude vytvořen žádný nový uživatel.",
 Instructor Records to be created by,"Záznamy instruktorů, které mají být vytvořeny",
 Employee Number,Počet zaměstnanců,
-LMS Settings,Nastavení LMS,
-Enable LMS,Povolit LMS,
-LMS Title,Název LMS,
 Fee Category,poplatek Kategorie,
 Fee Component,poplatek Component,
 Fees Category,Kategorie poplatky,
@@ -5840,8 +5955,8 @@
 Exit,Východ,
 Date of Leaving,Datem odchodu,
 Leaving Certificate Number,Vysvědčení číslo,
+Reason For Leaving,Důvod k odchodu,
 Student Admission,Student Vstupné,
-Application Form Route,Přihláška Trasa,
 Admission Start Date,Vstupné Datum zahájení,
 Admission End Date,Vstupné Datum ukončení,
 Publish on website,Publikovat na webových stránkách,
@@ -5856,6 +5971,7 @@
 Application Status,Stav aplikace,
 Application Date,aplikace Datum,
 Student Attendance Tool,Student Účast Tool,
+Group Based On,Skupina založená na,
 Students HTML,studenti HTML,
 Group Based on,Skupina založená na,
 Student Group Name,Jméno Student Group,
@@ -5879,7 +5995,6 @@
 Student Language,Student Language,
 Student Leave Application,Student nechat aplikaci,
 Mark as Present,Označit jako dárek,
-Will show the student as Present in Student Monthly Attendance Report,Ukáže studenta přítomnému v Student měsíční návštěvnost Zpráva,
 Student Log,Student Log,
 Academic,Akademický,
 Achievement,Úspěch,
@@ -5893,6 +6008,8 @@
 Assessment Terms,Podmínky hodnocení,
 Student Sibling,Student Sourozenec,
 Studying in Same Institute,Studium se ve stejném ústavu,
+NO,NE,
+YES,ANO,
 Student Siblings,Studentské Sourozenci,
 Topic Content,Obsah tématu,
 Amazon MWS Settings,Amazon MWS Nastavení,
@@ -5903,6 +6020,7 @@
 AWS Access Key ID,Identifikátor přístupového klíče AWS,
 MWS Auth Token,MWS Auth Token,
 Market Place ID,ID místa na trhu,
+AE,AE,
 AU,AU,
 BR,BR,
 CA,CA,
@@ -5910,16 +6028,23 @@
 DE,DE,
 ES,ES,
 FR,FR,
+IN,V,
 JP,JP,
 IT,TO,
+MX,MX,
 UK,Spojené království,
 US,NÁS,
 Customer Type,Typ zákazníka,
 Market Place Account Group,Skupina účtů na trhu,
 After Date,Po datu,
 Amazon will synch data updated after this date,Amazon bude synchronizovat data aktualizovaná po tomto datu,
+Sync Taxes and Charges,Synchronizujte daně a poplatky,
 Get financial breakup of Taxes and charges data by Amazon ,Získejte finanční rozdělení údajů o daních a poplatcích od společnosti Amazon,
+Sync Products,Synchronizovat produkty,
+Always sync your products from Amazon MWS before synching the Orders details,Před synchronizací podrobností objednávek vždy synchronizujte své produkty z Amazon MWS,
+Sync Orders,Synchronizovat objednávky,
 Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačítko vygenerujete údaje o prodejní objednávce z Amazon MWS.,
+Enable Scheduled Sync,Povolit naplánovanou synchronizaci,
 Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaškrtněte toto, chcete-li zapnout naplánovaný program Denní synchronizace prostřednictvím plánovače",
 Max Retry Limit,Maximální limit opakování,
 Exotel Settings,Nastavení Exotelu,
@@ -5934,10 +6059,10 @@
 Synchronize all accounts every hour,Synchronizujte všechny účty každou hodinu,
 Plaid Client ID,Plaid Client ID,
 Plaid Secret,Plaid Secret,
-Plaid Public Key,Plaid Public Key,
 Plaid Environment,Plaid Environment,
 sandbox,pískoviště,
 development,rozvoj,
+production,Výroba,
 QuickBooks Migrator,Migrace QuickBooks,
 Application Settings,Nastavení aplikace,
 Token Endpoint,Koncový bod tokenu,
@@ -5965,7 +6090,6 @@
 Webhooks,Webhooks,
 Customer Settings,Nastavení zákazníka,
 Default Customer,Výchozí zákazník,
-"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Pokud služba Shopify neobsahuje zákazníka v objednávce, pak při synchronizaci objednávek systém bude považovat výchozí zákazníka za objednávku",
 Customer Group will set to selected group while syncing customers from Shopify,Zákaznická skupina nastaví vybranou skupinu při synchronizaci zákazníků se službou Shopify,
 For Company,Pro Společnost,
 Cash Account will used for Sales Invoice creation,Hotovostní účet bude použit pro vytvoření faktury,
@@ -5983,18 +6107,26 @@
 Webhook ID,Webhook ID,
 Tally Migration,Tally Migration,
 Master Data,Hlavní data,
+"Data exported from Tally that consists of the Chart of Accounts, Customers, Suppliers, Addresses, Items and UOMs","Data exportovaná z Tally, která se skládá z účtové osnovy, zákazníků, dodavatelů, adres, položek a MJ",
 Is Master Data Processed,Zpracovává se kmenová data,
 Is Master Data Imported,Jsou importována kmenová data,
 Tally Creditors Account,Účet věřitelů,
+Creditors Account set in Tally,Účet věřitelů nastavený v Tally,
 Tally Debtors Account,Účet Tally dlužníků,
+Debtors Account set in Tally,Účet dlužníků nastavený v Tally,
 Tally Company,Společnost Tally,
+Company Name as per Imported Tally Data,Název společnosti podle importovaných údajů o shodě,
+Default UOM,Výchozí MOM,
+UOM in case unspecified in imported data,MJ v případě nespecifikovaných v importovaných datech,
 ERPNext Company,ERPDext Company,
+Your Company set in ERPNext,Vaše společnost nastavena v ERPNext,
 Processed Files,Zpracované soubory,
 Parties,Strany,
 UOMs,UOMs,
 Vouchers,Poukazy,
 Round Off Account,Zaokrouhlovací účet,
 Day Book Data,Údaje o denní knize,
+Day Book Data exported from Tally that consists of all historic transactions,"Data denní knihy exportovaná z Tally, která se skládají ze všech historických transakcí",
 Is Day Book Data Processed,Zpracovávají se údaje o denní knize,
 Is Day Book Data Imported,Jsou importována data denní knihy,
 Woocommerce Settings,Nastavení Woocommerce,
@@ -6019,12 +6151,19 @@
 Healthcare Administrator,Správce zdravotní péče,
 Laboratory User,Laboratorní uživatel,
 Is Inpatient,Je hospitalizován,
+Default Duration (In Minutes),Výchozí doba trvání (v minutách),
+Body Part,Část těla,
+Body Part Link,Odkaz na část těla,
 HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-,
 Procedure Template,Šablona postupu,
 Procedure Prescription,Předepsaný postup,
 Service Unit,Servisní jednotka,
 Consumables,Spotřební materiál,
 Consume Stock,Spotřeba zásob,
+Invoice Consumables Separately,Spotřební materiál na fakturu zvlášť,
+Consumption Invoiced,Spotřeba fakturována,
+Consumable Total Amount,Celková spotřební částka,
+Consumption Details,Údaje o spotřebě,
 Nursing User,Ošetřujícího uživatele,
 Clinical Procedure Item,Položka klinické procedury,
 Invoice Separately as Consumables,Faktury samostatně jako spotřební materiál,
@@ -6032,27 +6171,51 @@
 Actual Qty (at source/target),Skutečné množství (u zdroje/cíle),
 Is Billable,Je fakturován,
 Allow Stock Consumption,Povolit skladovou spotřebu,
+Sample UOM,Ukázka MOM,
 Collection Details,Podrobnosti o kolekci,
+Change In Item,Změna v položce,
 Codification Table,Kodifikační tabulka,
 Complaints,Stížnosti,
 Dosage Strength,Síla dávkování,
 Strength,Síla,
 Drug Prescription,Předepisování léků,
+Drug Name / Description,Název / popis léčiva,
 Dosage,Dávkování,
 Dosage by Time Interval,Dávkování podle časového intervalu,
 Interval,Interval,
 Interval UOM,Interval UOM,
 Hour,Hodina,
 Update Schedule,Aktualizovat plán,
+Exercise,Cvičení,
+Difficulty Level,Stupeň obtížnosti,
+Counts Target,Počítá cíl,
+Counts Completed,Počty byly dokončeny,
+Assistance Level,Úroveň pomoci,
+Active Assist,Aktivní asistence,
+Exercise Name,Název cvičení,
+Body Parts,Části těla,
+Exercise Instructions,Pokyny ke cvičení,
+Exercise Video,Cvičební video,
+Exercise Steps,Cvičení,
+Steps,Kroky,
+Steps Table,Tabulka kroků,
+Exercise Type Step,Krok typu cvičení,
 Max number of visit,Maximální počet návštěv,
 Visited yet,Ještě navštěvováno,
+Reference Appointments,Referenční schůzky,
+Valid till,Platný do,
+Fee Validity Reference,Odkaz na platnost poplatku,
+Basic Details,Základní podrobnosti,
+HLC-PRAC-.YYYY.-,HLC-PRAC-.RRRR.-,
 Mobile,"mobilní, pohybliví",
 Phone (R),Telefon (R),
 Phone (Office),Telefon (kancelář),
+Employee and User Details,Podrobnosti o zaměstnanci a uživateli,
 Hospital,NEMOCNICE,
 Appointments,Setkání,
 Practitioner Schedules,Pracovník plánuje,
 Charges,Poplatky,
+Out Patient Consulting Charge,Poplatek za konzultaci s pacientem,
 Default Currency,Výchozí měna,
 Healthcare Schedule Time Slot,Časový plán časového plánu pro zdravotní péči,
 Parent Service Unit,Rodičovská služba,
@@ -6070,14 +6233,25 @@
 Out Patient Settings,Out Nastavení pacienta,
 Patient Name By,Jméno pacienta,
 Patient Name,Jméno pacienta,
+Link Customer to Patient,Propojte zákazníka s pacientem,
 "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.","Pokud je zaškrtnuto, vytvoří se zákazník, mapovaný na pacienta. Faktury pacientů budou vytvořeny proti tomuto zákazníkovi. Při vytváření pacienta můžete také vybrat existujícího zákazníka.",
 Default Medical Code Standard,Výchozí standard zdravotnického kódu,
 Collect Fee for Patient Registration,Vybírat poplatek za registraci pacienta,
+Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.,Zaškrtnutí tohoto políčka ve výchozím nastavení vytvoří nové pacienty se zdravotním stavem a bude povoleno až po fakturaci registračního poplatku.,
 Registration Fee,Registrační poplatek,
+Automate Appointment Invoicing,Automatizujte fakturaci schůzky,
 Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Správa faktury při odeslání a automatické zrušení faktury pro setkání pacienta,
+Enable Free Follow-ups,Povolit bezplatná následná opatření,
+Number of Patient Encounters in Valid Days,Počet setkání pacientů v platné dny,
+The number of free follow ups (Patient Encounters in valid days) allowed,Počet povolených bezplatných následných sledování (setkání pacientů v platných dnech),
 Valid Number of Days,Platný počet dnů,
+Time period (Valid number of days) for free consultations,Časové období (platný počet dní) pro bezplatné konzultace,
+Default Healthcare Service Items,Výchozí položky zdravotní péče,
+"You can configure default Items for billing consultation charges, procedure consumption items and inpatient visits","Můžete nakonfigurovat výchozí položky pro poplatky za fakturaci za konzultace, položky spotřeby procedur a návštěvy hospitalizovaných pacientů",
 Clinical Procedure Consumable Item,Klinický postup Spotřební materiál,
+Default Accounts,Výchozí účty,
 Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Standardní účty příjmů, které se použijí, pokud nejsou stanoveny ve zdravotnickém lékaři ke vyúčtování poplatků za schůzku.",
+Default receivable accounts to be used to book Appointment charges.,"Výchozí účty pohledávek, které se mají použít k účtování poplatků za schůzku.",
 Out Patient SMS Alerts,Upozornění na upozornění pacienta,
 Patient Registration,Registrace pacienta,
 Registration Message,Registrační zpráva,
@@ -6088,9 +6262,18 @@
 Reminder Message,Připomenutí zprávy,
 Remind Before,Připomenout dříve,
 Laboratory Settings,Laboratorní nastavení,
+Create Lab Test(s) on Sales Invoice Submission,Vytvořte laboratorní testy pro odeslání prodejní faktury,
+Checking this will create Lab Test(s) specified in the Sales Invoice on submission.,Zaškrtnutím této položky se při odeslání vytvoří laboratorní testy uvedené v prodejní faktuře.,
+Create Sample Collection document for Lab Test,Vytvořte dokument Sample Collection pro laboratorní test,
+Checking this will create a Sample Collection document  every time you create a Lab Test,Zaškrtnutím této možnosti vytvoříte dokument Sample Collection při každém vytvoření laboratorního testu,
 Employee name and designation in print,Jméno a označení zaměstnance v tisku,
+Check this if you want the Name and Designation of the Employee associated with the User who submits the document to be printed in the Lab Test Report.,"Zaškrtněte toto, pokud chcete, aby se do protokolu o laboratorním testu vytisklo jméno a označení zaměstnance přidruženého k uživateli, který dokument odesílá.",
+Do not print or email Lab Tests without Approval,Netiskněte ani neposílejte laboratorní testy e-mailem bez schválení,
+Checking this will restrict printing and emailing of Lab Test documents unless they have the status as Approved.,"Toto zaškrtnutí omezí tisk a zasílání e-mailů laboratorních testovacích dokumentů, pokud nemají status Schváleno.",
 Custom Signature in Print,Vlastní podpis v tisku,
 Laboratory SMS Alerts,Laboratorní SMS upozornění,
+Result Printed Message,Výsledek Tištěná zpráva,
+Result Emailed Message,Výsledek e-mailem,
 Check In,Check In,
 Check Out,Překontrolovat,
 HLC-INP-.YYYY.-,HLC-INP-.RRRR.-,
@@ -6110,43 +6293,37 @@
 Admitted Datetime,Přidané datum,
 Expected Discharge,Předpokládané uvolnění,
 Discharge Date,Datum propuštění,
-Discharge Note,Poznámka k vybíjení,
 Lab Prescription,Lab Předpis,
+Lab Test Name,Název laboratorního testu,
 Test Created,Test byl vytvořen,
-LP-,LP-,
 Submitted Date,Datum odeslání,
 Approved Date,Datum schválení,
 Sample ID,ID vzorku,
 Lab Technician,Laboratorní technik,
-Technician Name,Jméno technika,
 Report Preference,Předvolba reportu,
 Test Name,Testovací jméno,
 Test Template,Testovací šablona,
 Test Group,Testovací skupina,
 Custom Result,Vlastní výsledek,
 LabTest Approver,Nástroj LabTest,
-Lab Test Groups,Laboratorní testovací skupiny,
 Add Test,Přidat test,
-Add new line,Přidat nový řádek,
 Normal Range,Normální vzdálenost,
 Result Format,Formát výsledků,
-"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 pro výsledky, které vyžadují pouze jeden vstup, výsledek UOM a normální hodnota <br> Sloučenina pro výsledky, které vyžadují více vstupních polí s odpovídajícími názvy událostí, výsledky UOM a normální hodnoty <br> Popisné pro testy, které mají více komponent výsledků a odpovídající pole pro vyplnění výsledků. <br> Seskupeny pro testovací šablony, které jsou skupinou dalších zkušebních šablon. <br> Žádný výsledek pro testy bez výsledků. Také není vytvořen žádný laboratorní test. např. Podtřídy pro seskupené výsledky.",
 Single,Jednolůžkový,
 Compound,Sloučenina,
 Descriptive,Popisný,
 Grouped,Skupinové,
 No Result,Žádný výsledek,
-"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Pokud není zaškrtnuto, bude položka zobrazena v faktuře prodeje, ale může být použita při vytváření skupinových testů.",
 This value is updated in the Default Sales Price List.,Tato hodnota je aktualizována v seznamu výchozích prodejních cen.,
 Lab Routine,Lab Rutine,
-Special,Speciální,
-Normal Test Items,Normální testovací položky,
 Result Value,Výsledek Hodnota,
 Require Result Value,Požadovat hodnotu výsledku,
 Normal Test Template,Normální šablona testu,
 Patient Demographics,Demografie pacientů,
 HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-,
+Middle Name (optional),Prostřední jméno (volitelné),
 Inpatient Status,Stavy hospitalizace,
+"If ""Link Customer to Patient"" is checked in Healthcare Settings and an existing Customer is not selected then, a Customer will be created for this Patient for recording transactions in Accounts module.","Pokud je v nastavení zdravotnictví zaškrtnuto &quot;Propojit zákazníka s pacientem&quot; a není vybrán stávající zákazník, bude pro tohoto pacienta vytvořen zákazník pro záznam transakcí v modulu Účty.",
 Personal and Social History,Osobní a sociální historie,
 Marital Status,Rodinný stav,
 Married,Ženatý,
@@ -6163,22 +6340,53 @@
 Other Risk Factors,Další rizikové faktory,
 Patient Details,Podrobnosti pacienta,
 Additional information regarding the patient,Další informace týkající se pacienta,
+HLC-APP-.YYYY.-,HLC-APP-.RRRR.-,
 Patient Age,Věk pacienta,
+Get Prescribed Clinical Procedures,Získejte předepsané klinické postupy,
+Therapy,Terapie,
+Get Prescribed Therapies,Získejte předepsané terapie,
+Appointment Datetime,Datum schůzky,
+Duration (In Minutes),Doba trvání (v minutách),
+Reference Sales Invoice,Referenční prodejní faktura,
 More Info,Více informací,
 Referring Practitioner,Odvolávající se praktikant,
 Reminded,Připomenuto,
+HLC-PA-.YYYY.-,HLC-PA-.RRRR.-,
+Assessment Template,Šablona pro hodnocení,
+Assessment Datetime,Datetime posouzení,
+Assessment Description,Popis posouzení,
+Assessment Sheet,Hodnotící list,
+Total Score Obtained,Celkové dosažené skóre,
+Scale Min,Měřítko min,
+Scale Max,Měřítko Max,
+Patient Assessment Detail,Podrobnosti o hodnocení pacienta,
+Assessment Parameter,Parametr hodnocení,
+Patient Assessment Parameter,Parametr hodnocení pacienta,
+Patient Assessment Sheet,List pro hodnocení pacientů,
+Patient Assessment Template,Šablona pro hodnocení pacientů,
+Assessment Parameters,Parametry hodnocení,
 Parameters,Parametry,
+Assessment Scale,Hodnotící stupnice,
+Scale Minimum,Minimální měřítko,
+Scale Maximum,Maximální měřítko,
 HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-,
 Encounter Date,Datum setkání,
 Encounter Time,Čas setkání,
 Encounter Impression,Setkání s impresi,
+Symptoms,Příznaky,
 In print,V tisku,
 Medical Coding,Lékařské kódování,
 Procedures,Postupy,
+Therapies,Terapie,
 Review Details,Podrobné informace,
+Patient Encounter Diagnosis,Diagnóza setkání pacientů,
+Patient Encounter Symptom,Příznak setkání pacienta,
 HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-,
+Attach Medical Record,Připojte lékařský záznam,
+Reference DocType,Referenční DocType,
 Spouse,Manželka,
 Family,Rodina,
+Schedule Details,Podrobnosti plánu,
 Schedule Name,Název plánu,
 Time Slots,Časové úseky,
 Practitioner Service Unit Schedule,Pracovní služba Servisní plán,
@@ -6187,13 +6395,19 @@
 Procedure Created,Postup byl vytvořen,
 HLC-SC-.YYYY.-,HLC-SC-.YYYY.-,
 Collected By,Shromážděno podle,
-Collected Time,Shromážděný čas,
-No. of print,Počet tisku,
-Sensitivity Test Items,Položky testu citlivosti,
-Special Test Items,Speciální zkušební položky,
 Particulars,Podrobnosti,
-Special Test Template,Speciální zkušební šablona,
 Result Component,Komponent výsledků,
+HLC-THP-.YYYY.-,HLC-THP-.RRRR.-,
+Therapy Plan Details,Podrobnosti o terapeutickém plánu,
+Total Sessions,Celkem relací,
+Total Sessions Completed,Celkový počet dokončených relací,
+Therapy Plan Detail,Detail terapeutického plánu,
+No of Sessions,Počet relací,
+Sessions Completed,Session Completed,
+Tele,Tele,
+Exercises,Cvičení,
+Therapy For,Terapie pro,
+Add Exercises,Přidejte cvičení,
 Body Temperature,Tělesná teplota,
 Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Přítomnost horečky (teplota&gt; 38,5 ° C nebo trvalá teplota&gt; 38 ° C / 100,4 ° F)",
 Heart Rate / Pulse,Srdeční frekvence / puls,
@@ -6295,19 +6509,17 @@
 Worked On Holiday,Pracoval na dovolené,
 Work From Date,Práce od data,
 Work End Date,Datum ukončení práce,
+Email Sent To,Email poslán,
 Select Users,Vyberte možnost Uživatelé,
 Send Emails At,Posílat e-maily At,
 Reminder,Připomínka,
 Daily Work Summary Group User,Denní uživatel shrnutí skupiny práce,
+email,e-mailem,
 Parent Department,Oddělení rodičů,
 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,Schvalovatelé dovolených,
 Leave Approver,Schvalovatel absenece,
-The first Leave Approver in the list will be set as the default Leave Approver.,Prvním schvalovacím přístupem v seznamu bude nastaven výchozí přístup.,
-Expense Approvers,Odpůrci výdajů,
 Expense Approver,Schvalovatel výdajů,
-The first Expense Approver in the list will be set as the default Expense Approver.,První Průvodce výdajů v seznamu bude nastaven jako výchozí schvalovatel výdajů.,
 Department Approver,Schválení oddělení,
 Approver,Schvalovatel,
 Required Skills,Požadované dovednosti,
@@ -6394,7 +6606,6 @@
 Health Concerns,Zdravotní Obavy,
 New Workplace,Nové pracoviště,
 HR-EAD-.YYYY.-,HR-EAD-.YYYY.-,
-Due Advance Amount,Splatná částka předem,
 Returned Amount,Vrácená částka,
 Claimed,Reklamace,
 Advance Account,Advance účet,
@@ -6457,6 +6668,7 @@
 Employee Onboarding Template,Šablona zaměstnanců na palubě,
 Activities,Aktivity,
 Employee Onboarding Activity,Činnost zaměstnanců na palubě,
+Employee Other Income,Jiný příjem zaměstnance,
 Employee Promotion,Propagace zaměstnanců,
 Promotion Date,Datum propagace,
 Employee Promotion Details,Podrobnosti o podpoře zaměstnanců,
@@ -6510,6 +6722,7 @@
 Total Amount Reimbursed,Celkové částky proplacené,
 Vehicle Log,jízd,
 Employees Email Id,Zaměstnanci Email Id,
+More Details,Více informací,
 Expense Claim Account,Náklady na pojistná Account,
 Expense Claim Advance,Nároky na úhradu nákladů,
 Unclaimed amount,Nevyžádaná částka,
@@ -6533,10 +6746,12 @@
 Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin,
 Expense Approver Mandatory In Expense Claim,Povinnost pojistitele výdajů v nárocích na výdaje,
 Payroll Settings,Nastavení Mzdové,
+Leave,Odejít,
 Max working hours against Timesheet,Maximální 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","Pokud je zaškrtnuto, skryje a zakáže pole Zaokrouhlený celkový počet v Salary Slips",
+The fraction of daily wages to be paid for half-day attendance,Zlomek denní mzdy vyplácené za poldenní docházku,
 Email Salary Slip to Employee,Email výplatní pásce pro zaměstnance,
 Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatní pásce, aby zaměstnanci na základě přednostního e-mailu vybraného v zaměstnaneckých",
 Encrypt Salary Slips in Emails,Zašifrujte výplatní pásky do e-mailů,
@@ -6554,8 +6769,16 @@
 Hiring Settings,Nastavení najímání,
 Check Vacancies On Job Offer Creation,Zkontrolujte volná místa při vytváření pracovních nabídek,
 Identification Document Type,Identifikační typ dokumentu,
+Effective from,Platí od,
+Allow Tax Exemption,Povolit osvobození od daně,
+"If enabled, Tax Exemption Declaration will be considered for income tax calculation.","Pokud je tato možnost povolena, při výpočtu daně z příjmu se zohlední prohlášení o osvobození od daně.",
 Standard Tax Exemption Amount,Standardní částka osvobození od daně,
 Taxable Salary Slabs,Zdanitelné platové desky,
+Taxes and Charges on Income Tax,Daně a poplatky z daně z příjmu,
+Other Taxes and Charges,Ostatní daně a poplatky,
+Income Tax Slab Other Charges,Deska daně z příjmu Další poplatky,
+Min Taxable Income,Minimální zdanitelný příjem,
+Max Taxable Income,Max. Zdanitelný příjem,
 Applicant for a Job,Žadatel o zaměstnání,
 Accepted,Přijato,
 Job Opening,Job Zahájení,
@@ -6673,9 +6896,11 @@
 Depends on Payment Days,Závisí na platebních dnech,
 Is Tax Applicable,Je daň platná,
 Variable Based On Taxable Salary,Proměnná založená na zdanitelném platu,
+Exempted from Income Tax,Osvobozeno od daně z příjmu,
 Round to the Nearest Integer,Zaokrouhlí na nejbližší celé číslo,
 Statistical Component,Statistická slož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. ","Pokud je vybrána, hodnota zadaná nebo vypočtená v této složce nepřispívá k výnosům nebo odpočtem. Nicméně, jeho hodnota může být odkazováno na jiné komponenty, které mohou být přidány nebo odečteny.",
+Do Not Include in Total,Nezahrnovat celkem,
 Flexible Benefits,Flexibilní výhody,
 Is Flexible Benefit,Je flexibilní přínos,
 Max Benefit Amount (Yearly),Maximální částka prospěchu (ročně),
@@ -6691,7 +6916,6 @@
 Additional Amount,Další částka,
 Tax on flexible benefit,Daň z flexibilní výhody,
 Tax on additional salary,Daň z příplatku,
-Condition and Formula Help,Stav a Formula nápovědy,
 Salary Structure,Plat struktura,
 Working Days,Pracovní dny,
 Salary Slip Timesheet,Plat Slip časový rozvrh,
@@ -6701,6 +6925,7 @@
 Earning & Deduction,Výdělek a dedukce,
 Earnings,Výdělek,
 Deductions,Odpočty,
+Loan repayment,Splácení půjčky,
 Employee Loan,zaměstnanec Loan,
 Total Principal Amount,Celková hlavní částka,
 Total Interest Amount,Celková částka úroků,
@@ -6913,18 +7138,25 @@
 Maximum Loan Amount,Maximální výše úvěru,
 Repayment Info,splácení Info,
 Total Payable Interest,Celkem Splatné úroky,
+Against Loan ,Proti půjčce,
 Loan Interest Accrual,Úvěrový úrok,
 Amounts,Množství,
 Pending Principal Amount,Čeká částka jistiny,
 Payable Principal Amount,Splatná jistina,
+Paid Principal Amount,Vyplacená jistina,
+Paid Interest Amount,Částka zaplaceného úroku,
 Process Loan Interest Accrual,Časově rozlišené úroky z procesu,
+Repayment Schedule Name,Název splátkového kalendáře,
 Regular Payment,Pravidelná platba,
 Loan Closure,Uznání úvěru,
 Payment Details,Platební údaje,
 Interest Payable,Úroky splatné,
 Amount Paid,Zaplacené částky,
 Principal Amount Paid,Hlavní zaplacená částka,
+Repayment Details,Podrobnosti splácení,
+Loan Repayment Detail,Podrobnosti o splácení půjčky,
 Loan Security Name,Název zabezpečení půjčky,
+Unit Of Measure,Měrná jednotka,
 Loan Security Code,Bezpečnostní kód půjčky,
 Loan Security Type,Typ zabezpečení půjčky,
 Haircut %,Střih%,
@@ -6943,14 +7175,15 @@
 Process Loan Security Shortfall,Nedostatek zabezpečení procesních půjček,
 Loan To Value Ratio,Poměr půjčky k hodnotě,
 Unpledge Time,Unpledge Time,
-Unpledge Type,Unpledge Type,
 Loan Name,půjčka Name,
 Rate of Interest (%) Yearly,Úroková sazba (%) Roční,
 Penalty Interest Rate (%) Per Day,Trestní úroková sazba (%) za den,
 Penalty Interest Rate is levied on the pending interest amount on a daily basis in case of delayed repayment ,V případě opožděného splacení se z nedočkané výše úroku vybírá penalizační úroková sazba denně,
 Grace Period in Days,Grace Období ve dnech,
+No. of days from due date until which penalty won't be charged in case of delay in loan repayment,"Počet dní od data splatnosti, do kterých nebude účtována pokuta v případě zpoždění splácení půjčky",
 Pledge,Slib,
 Post Haircut Amount,Částka za účes,
+Process Type,Typ procesu,
 Update Time,Čas aktualizace,
 Proposed Pledge,Navrhovaný slib,
 Total Payment,Celková platba,
@@ -6961,7 +7194,6 @@
 Sanctioned Loan Amount,Částka schváleného úvěru,
 Sanctioned Amount Limit,Povolený limit částky,
 Unpledge,Unpledge,
-Against Pledge,Proti zástavě,
 Haircut,Střih,
 MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-,
 Generate Schedule,Generování plán,
@@ -6970,6 +7202,7 @@
 Scheduled Date,Plánované datum,
 Actual Date,Skutečné datum,
 Maintenance Schedule Item,Plán údržby Item,
+Random,Náhodný,
 No of Visits,Počet návštěv,
 MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-,
 Maintenance Date,Datum údržby,
@@ -7015,6 +7248,7 @@
 Total Cost (Company Currency),Celkové náklady (měna společnosti),
 Materials Required (Exploded),Potřebný materiál (Rozložený),
 Exploded Items,Rozložené položky,
+Show in Website,Zobrazit na webu,
 Item Image (if not slideshow),Item Image (ne-li slideshow),
 Thumbnail,Thumbnail,
 Website Specifications,Webových stránek Specifikace,
@@ -7031,6 +7265,8 @@
 Scrap %,Scrap%,
 Original Item,Původní položka,
 BOM Operation,BOM Operation,
+Operation Time ,Provozní doba,
+In minutes,Za pár minut,
 Batch Size,Objem várky,
 Base Hour Rate(Company Currency),Základna hodinová sazba (Company měny),
 Operating Cost(Company Currency),Provozní náklady (Company měna),
@@ -7051,6 +7287,7 @@
 Timing Detail,Časový detail,
 Time Logs,Čas Záznamy,
 Total Time in Mins,Celkový čas v minách,
+Operation ID,ID operace,
 Transferred Qty,Přenesená Množství,
 Job Started,Úloha byla zahájena,
 Started Time,Čas zahájení,
@@ -7210,9 +7447,23 @@
 Email Notification Sent,Zasláno oznámení o e-mailu,
 NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-,
 Membership Expiry Date,Datum ukončení členství,
+Razorpay Details,Razorpay Podrobnosti,
+Subscription ID,ID předplatného,
+Customer ID,zákaznické identifikační číslo,
+Subscription Activated,Předplatné aktivováno,
+Subscription Start ,Začátek předplatného,
+Subscription End,Konec předplatného,
 Non Profit Member,Neziskový člen,
 Membership Status,Stav členství,
 Member Since,Členem od,
+Payment ID,ID platby,
+Membership Settings,Nastavení členství,
+Enable RazorPay For Memberships,Povolit RazorPay pro členství,
+RazorPay Settings,Nastavení RazorPay,
+Billing Cycle,Zúčtovací období,
+Billing Frequency,Fakturační frekvence,
+"The number of billing cycles for which the customer should be charged. For example, if a customer is buying a 1-year membership that should be billed on a monthly basis, this value should be 12.","Počet fakturačních cyklů, za které by měl být zákazníkovi účtován poplatek. Pokud si například zákazník kupuje roční členství, které by mělo být účtováno měsíčně, měla by tato hodnota činit 12.",
+Razorpay Plan ID,Razorpay plán ID,
 Volunteer Name,Jméno dobrovolníka,
 Volunteer Type,Typ dobrovolníka,
 Availability and Skills,Dostupnost a dovednosti,
@@ -7236,6 +7487,7 @@
 "URL for ""All Products""",URL pro &quot;všechny produkty&quot;,
 Products to be shown on website homepage,"Produkty, které mají být uvedeny na internetových stránkách domovské",
 Homepage Featured Product,Úvodní Doporučené zboží,
+route,trasa,
 Section Based On,Sekce založená na,
 Section Cards,Karty sekce,
 Number of Columns,Počet sloupců,
@@ -7263,6 +7515,7 @@
 Activity Cost,Náklady Aktivita,
 Billing Rate,Fakturace Rate,
 Costing Rate,Kalkulace Rate,
+title,titul,
 Projects User,Projekty uživatele,
 Default Costing Rate,Výchozí kalkulace Rate,
 Default Billing Rate,Výchozí fakturace Rate,
@@ -7276,6 +7529,7 @@
 Project will be accessible on the website to these users,Projekt bude k dispozici na webových stránkách k těmto uživatelům,
 Copied From,Zkopírován z,
 Start and End Dates,Datum zahájení a ukončení,
+Actual Time (in Hours),Skutečný čas (v hodinách),
 Costing and Billing,Kalkulace a fakturace,
 Total Costing Amount (via Timesheets),Celková částka kalkulování (prostřednictvím časových lístků),
 Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků),
@@ -7294,6 +7548,7 @@
 Second Email,Druhý e-mail,
 Time to send,Čas odeslání,
 Day to Send,Den odeslání,
+Message will be sent to the users to get their status on the Project,"Zpráva bude odeslána uživatelům, aby získali jejich stav v projektu",
 Projects Manager,Správce projektů,
 Project Template,Šablona projektu,
 Project Template Task,Úloha šablony projektu,
@@ -7326,6 +7581,7 @@
 Closing Date,Uzávěrka Datum,
 Task Depends On,Úkol je závislá na,
 Task Type,Typ úlohy,
+TS-.YYYY.-,TS-.RRRR.-,
 Employee Detail,Detail zaměstnanec,
 Billing Details,fakturační údaje,
 Total Billable Hours,Celkem zúčtovatelné hodiny,
@@ -7363,6 +7619,7 @@
 Processes,Procesy,
 Quality Procedure Process,Proces řízení kvality,
 Process Description,Popis procesu,
+Child Procedure,Postup dítěte,
 Link existing Quality Procedure.,Propojte stávající postup kvality.,
 Additional Information,dodatečné informace,
 Quality Review Objective,Cíl kontroly kvality,
@@ -7398,6 +7655,23 @@
 Zip File,Soubor ZIP,
 Import Invoices,Importovat faktury,
 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 připojení zip souboru k dokumentu klikněte na tlačítko Importovat faktury. Veškeré chyby související se zpracováním se zobrazí v protokolu chyb.,
+Lower Deduction Certificate,Osvědčení o nižší srážce,
+Certificate Details,Podrobnosti o certifikátu,
+194A,194A,
+194C,194C,
+194D,194D,
+194H,194H,
+194I,194I,
+194J,194J,
+194LA,194LA,
+194LBB,194 LBB,
+194LBC,194LBC,
+Certificate No,Certifikát č,
+Deductee Details,Podrobnosti odvedeného,
+PAN No,PAN č,
+Validity Details,Podrobnosti o platnosti,
+Rate Of TDS As Per Certificate,Sazba TDS podle certifikátu,
+Certificate Limit,Limit certifikátu,
 Invoice Series Prefix,Předvolba série faktur,
 Active Menu,Aktivní nabídka,
 Restaurant Menu,Nabídka restaurací,
@@ -7427,6 +7701,8 @@
 Default Company Bank Account,Výchozí firemní bankovní účet,
 From Lead,Od Leadu,
 Account Manager,Správce účtu,
+Allow Sales Invoice Creation Without Sales Order,Povolit vytváření prodejní faktury bez prodejní objednávky,
+Allow Sales Invoice Creation Without Delivery Note,Povolit vytváření prodejní faktury bez dodacího listu,
 Default Price List,Výchozí Ceník,
 Primary Address and Contact Detail,Primární adresa a podrobnosti kontaktu,
 "Select, to make the customer searchable with these fields","Zvolte, chcete-li, aby se zákazník prohledal s těmito poli",
@@ -7441,6 +7717,7 @@
 Sales Partner and Commission,Prodej Partner a Komise,
 Commission Rate,Výše provize,
 Sales Team Details,Podrobnosti prodejní tým,
+Customer POS id,ID zákazníka,
 Customer Credit Limit,Úvěrový limit zákazníka,
 Bypass Credit Limit Check at Sales Order,Zablokujte kontrolu úvěrového limitu na objednávce,
 Industry Type,Typ Průmyslu,
@@ -7450,24 +7727,17 @@
 Installation Note Item,Poznámka k instalaci bod,
 Installed Qty,Instalované množství,
 Lead Source,Olovo Source,
-POS Closing Voucher,POS uzávěrka,
 Period Start Date,Datum zahájení období,
 Period End Date,Datum konce období,
 Cashier,Pokladní,
-Expense Details,Podrobnosti výdaje,
-Expense Amount,Výdaje,
-Amount in Custody,Částka ve vazbě,
-Total Collected Amount,Celková shromážděná částka,
 Difference,Rozdíl,
 Modes of Payment,Způsoby platby,
 Linked Invoices,Linkované faktury,
-Sales Invoices Summary,Souhrn prodejních faktur,
 POS Closing Voucher Details,Podrobnosti závěrečného poukazu POS,
 Collected Amount,Sběrná částka,
 Expected Amount,Očekávaná částka,
 POS Closing Voucher Invoices,Pokladní doklady POS,
 Quantity of Items,Množství položek,
-POS Closing Voucher Taxes,Závěrečné dluhopisy 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","Souhrnný skupina ** položek ** do jiného ** Položka **. To je užitečné, pokud se svazování některé položky ** ** do balíku a budete udržovat zásoby balených ** Položky ** a ne agregát ** položky **. Balíček ** Položka ** bude mít &quot;Je skladem,&quot; jako &quot;Ne&quot; a &quot;Je prodeje Item&quot; jako &quot;Yes&quot;. Například: Pokud prodáváte notebooky a batohy odděleně a mají speciální cenu, pokud zákazník koupí oba, pak Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Kusovník",
 Parent Item,Nadřazená položka,
 List items that form the package.,"Seznam položek, které tvoří balíček.",
@@ -7519,8 +7789,6 @@
 Close Opportunity After Days,V blízkosti Příležitost po několika dnech,
 Auto close Opportunity after 15 days,Auto v blízkosti Příležitost po 15 dnech,
 Default Quotation Validity Days,Výchozí dny platnosti kotací,
-Sales Order Required,Prodejní objednávky Povinné,
-Delivery Note Required,Delivery Note Povinné,
 Sales Update Frequency,Frekvence aktualizace prodeje,
 How often should project and company be updated based on Sales Transactions.,Jak často by měl být projekt a společnost aktualizovány na základě prodejních transakcí.,
 Each Transaction,Každé Transakce,
@@ -7562,12 +7830,11 @@
 Parent Company,Mateřská společnost,
 Default Values,Výchozí hodnoty,
 Default Holiday List,Výchozí Holiday Seznam,
-Standard Working Hours,Standardní pracovní doba,
 Default Selling Terms,Výchozí prodejní podmínky,
 Default Buying Terms,Výchozí nákupní podmínky,
-Default warehouse for Sales Return,Výchozí sklad pro vrácení prodeje,
 Create Chart Of Accounts Based On,Vytvořte účtový rozvrh založený na,
 Standard Template,standardní šablona,
+Existing Company,Stávající společnost,
 Chart Of Accounts Template,Účtový rozvrh šablony,
 Existing Company ,stávající Company,
 Date of Establishment,Datum založení,
@@ -7647,7 +7914,11 @@
 New Purchase Invoice,Nová nákupní faktura,
 New Quotations,Nové Citace,
 Open Quotations,Otevřené nabídky,
+Open Issues,Otevřené problémy,
+Open Projects,Otevřené projekty,
 Purchase Orders Items Overdue,Položky nákupních příkazů po splatnosti,
+Upcoming Calendar Events,Nadcházející události kalendáře,
+Open To Do,Otevřít úkol,
 Add Quote,Přidat nabídku,
 Global Defaults,Globální Výchozí,
 Default Company,Výchozí Company,
@@ -7727,7 +7998,6 @@
 Show Public Attachments,Zobrazit veřejné přílohy,
 Show Price,Zobrazit cenu,
 Show Stock Availability,Zobrazit dostupnost skladem,
-Show Configure Button,Zobrazit tlačítko Konfigurovat,
 Show Contact Us Button,Tlačítko Zobrazit kontakt,
 Show Stock Quantity,Zobrazit množství zásob,
 Show Apply Coupon Code,Zobrazit Použít kód kupónu,
@@ -7738,9 +8008,13 @@
 Enable Checkout,Aktivovat Checkout,
 Payment Success Url,Platba Úspěch URL,
 After payment completion redirect user to selected page.,Po dokončení platby přesměrovat uživatele na vybrané stránky.,
+Batch Details,Podrobnosti o dávce,
 Batch ID,Šarže ID,
+image,obraz,
 Parent Batch,Nadřazená dávka,
 Manufacturing Date,Datum výroby,
+Batch Quantity,Množství dávky,
+Batch UOM,Hromadná MOM,
 Source Document Type,Zdrojový typ dokumentu,
 Source Document Name,Název zdrojového dokumentu,
 Batch Description,Popis Šarže,
@@ -7789,6 +8063,7 @@
 Send with Attachment,Odeslat s přílohou,
 Delay between Delivery Stops,Zpoždění mezi doručením,
 Delivery Stop,Zastávka doručení,
+Lock,Zámek,
 Visited,Navštíveno,
 Order Information,Informace o objednávce,
 Contact Information,Kontaktní informace,
@@ -7812,6 +8087,7 @@
 Fulfillment User,Uživatel splnění požadavků,
 "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.-,
+Variant Of,Varianta,
 "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,Výchozí Měrná jednotka,
@@ -7876,6 +8152,8 @@
 Supply Raw Materials for Purchase,Dodávky suroviny pro nákup,
 If subcontracted to a vendor,Pokud se subdodávky na dodavatele,
 Customer Code,Code zákazníků,
+Default Item Manufacturer,Výchozí výrobce položky,
+Default Manufacturer Part No,Výchozí číslo dílu výrobce,
 Show in Website (Variant),Show do webových stránek (Variant),
 Items with higher weightage will be shown higher,Položky s vyšším weightage budou zobrazeny vyšší,
 Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky,
@@ -7927,8 +8205,6 @@
 Item Price,Položka Cena,
 Packing Unit,Balení,
 Quantity  that must be bought or sold per UOM,"Množství, které musí být zakoupeno nebo prodané podle 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,
@@ -7963,7 +8239,10 @@
 Manufacturers used in Items,Výrobci používané v bodech,
 Limited to 12 characters,Omezeno na 12 znaků,
 MAT-MR-.YYYY.-,MAT-MR-.YYYY.-,
+Set Warehouse,Nastavit sklad,
+Sets 'For Warehouse' in each row of the Items table.,Nastaví v každém řádku tabulky „For Warehouse“.,
 Requested For,Požadovaných pro,
+Partially Ordered,Částečně objednáno,
 Transferred,Přestoupil,
 % Ordered,% objednáno,
 Terms and Conditions Content,Podmínky Content,
@@ -8009,7 +8288,11 @@
 Time at which materials were received,"Čas, kdy bylo přijato materiály",
 Return Against Purchase Receipt,Návrat Proti doklad o koupi,
 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",
+Sets 'Accepted Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Přijatý sklad“.,
+Sets 'Rejected Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Odmítnutý sklad“.,
+Raw Materials Consumed,Spotřebované suroviny,
 Get Current Stock,Získejte aktuální stav,
+Consumed Items,Spotřebované položky,
 Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků,
 Auto Repeat Detail,Auto opakovat detail,
 Transporter Details,Transporter Podrobnosti,
@@ -8018,6 +8301,7 @@
 Received and Accepted,Obdrženo a přijato,
 Accepted Quantity,Schválené Množství,
 Rejected Quantity,Odmíntnuté množství,
+Accepted Qty as per Stock UOM,Přijaté množství podle MJ skladu,
 Sample Quantity,Množství vzorku,
 Rate and Amount,Cena a částka,
 MAT-QA-.YYYY.-,MAT-QA-.YYYY.-,
@@ -8069,8 +8353,6 @@
 Material Consumption for Manufacture,Spotřeba materiálu pro výrobu,
 Repack,Přebalit,
 Send to Subcontractor,Odeslat subdodavateli,
-Send to Warehouse,Odeslat do skladu,
-Receive at Warehouse,Přijmout ve skladu,
 Delivery Note No,Dodacího listu,
 Sales Invoice No,Prodejní faktuře č,
 Purchase Receipt No,Číslo příjmky,
@@ -8136,6 +8418,9 @@
 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,
+Inter Warehouse Transfer Settings,Nastavení přenosu Inter Warehouse,
+Allow Material Transfer From Delivery Note and Sales Invoice,Povolit přenos materiálu z dodacího listu a prodejní faktury,
+Allow Material Transfer From Purchase Receipt and Purchase Invoice,Povolit převod materiálu z dokladu o nákupu a faktury za nákup,
 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],
@@ -8149,21 +8434,19 @@
 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ázev Skladu,
-"If blank, parent Warehouse Account or company default will be considered","Pokud je prázdné, bude se brát v úvahu výchozí rodičovský účet nebo výchozí společnost",
 Warehouse Contact Info,Sklad Kontaktní informace,
 PIN,KOLÍK,
+ISS-.YYYY.-,ISS-.RRRR.-,
 Raised By (Email),Vznesené (e-mail),
 Issue Type,Typ vydání,
 Issue Split From,Vydání Rozdělit od,
 Service Level,Úroveň služby,
 Response By,Odpověď od,
 Response By Variance,Reakce podle variace,
-Service Level Agreement Fulfilled,Splněna dohoda o úrovni služeb,
 Ongoing,Pokračující,
 Resolution By,Rozlišení podle,
 Resolution By Variance,Rozlišení podle variace,
 Service Level Agreement Creation,Vytvoření dohody o úrovni služeb,
-Mins to First Response,Min First Response,
 First Responded On,Prvně odpovězeno dne,
 Resolution Details,Rozlišení Podrobnosti,
 Opening Date,Datum otevření,
@@ -8174,9 +8457,7 @@
 Issue Priority,Priorita vydání,
 Service Day,Servisní den,
 Workday,Pracovní den,
-Holiday List (ignored during SLA calculation),Seznam svátků (ignorován během výpočtu SLA),
 Default Priority,Výchozí priorita,
-Response and Resoution Time,Doba odezvy a resoution,
 Priorities,Priority,
 Support Hours,Hodiny podpory,
 Support and Resolution,Podpora a rozlišení,
@@ -8185,10 +8466,7 @@
 Agreement Details,Podrobnosti dohody,
 Response and Resolution Time,Doba odezvy a rozlišení,
 Service Level Priority,Priorita úrovně služeb,
-Response Time,Doba odezvy,
-Response Time Period,Doba odezvy,
 Resolution Time,Čas rozlišení,
-Resolution Time Period,Časové rozlišení řešení,
 Support Search Source,Podporovaný vyhledávací zdroj,
 Source Type,Typ zdroje,
 Query Route String,Dotaz řetězce trasy,
@@ -8272,7 +8550,6 @@
 Delayed Order Report,Zpoždění objednávky,
 Delivered Items To Be Billed,Dodávaných výrobků fakturovaných,
 Delivery Note Trends,Dodací list Trendy,
-Department Analytics,Oddělení Analytics,
 Electronic Invoice Register,Elektronický fakturační registr,
 Employee Advance Summary,Zaměstnanecké předběžné shrnutí,
 Employee Billing Summary,Přehled fakturace zaměstnanců,
@@ -8304,7 +8581,6 @@
 Item Price Stock,Položka Cena Sklad,
 Item Prices,Ceny Položek,
 Item Shortage Report,Položka Nedostatek Report,
-Project Quantity,projekt Množství,
 Item Variant Details,Podrobnosti o variantě položky,
 Item-wise Price List Rate,Item-moudrý Ceník Rate,
 Item-wise Purchase History,Item-moudrý Historie nákupů,
@@ -8315,23 +8591,16 @@
 Reserved,Rezervováno,
 Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level,
 Lead Details,Detaily leadu,
-Lead Id,Id leadu,
 Lead Owner Efficiency,Vedoucí účinnost vlastníka,
 Loan Repayment and Closure,Splácení a uzavření úvěru,
 Loan Security Status,Stav zabezpečení úvěru,
 Lost Opportunity,Ztracená příležitost,
 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 první reakce na otázky,
-Minutes to First Response for Opportunity,Zápisy do první reakce na příležitost,
 Monthly Attendance Sheet,Měsíční Účast Sheet,
 Open Work Orders,Otevřete pracovní objednávky,
-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,"Částka, která má dodávat",
-Item Delivery Date,Datum dodání položky,
-Delay Days,Delay Dny,
+Patient Appointment Analytics,Analýza jmenování pacienta,
 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,Sledování nákupu,
@@ -8340,27 +8609,20 @@
 Profit and Loss Statement,Výkaz zisků a ztrát,
 Profitability Analysis,Analýza ziskovost,
 Project Billing Summary,Přehled fakturace projektu,
+Project wise Stock Tracking,Promyšlené sledování zásob,
 Project wise Stock Tracking ,Sledování zboží dle projektu,
 Prospects Engaged But Not Converted,"Perspektivy zapojení, ale nekonverze",
 Purchase Analytics,Nákup Analytika,
 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,Položky vydané objednávky k přijetí,
 Qty to Receive,Množství pro příjem,
-Purchase Order Items To Be Received or Billed,Položky objednávek k přijetí nebo vyúčtování,
-Base Amount,Základní částka,
 Received Qty Amount,Přijatá částka Množství,
-Amount to Receive,Částka k přijetí,
-Amount To Be Billed,Částka k vyúčtování,
 Billed Qty,Účtované množství,
-Qty To Be Billed,Množství k vyúčtování,
 Purchase Order Trends,Nákupní objednávka trendy,
 Purchase Receipt Trends,Doklad o koupi Trendy,
 Purchase Register,Nákup Register,
 Quotation Trends,Uvozovky Trendy,
 Quoted Item Comparison,Citoval Položka Porovnání,
 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,
@@ -8372,6 +8634,7 @@
 Sales Partner Target Variance based on Item Group,Cílová odchylka prodejního partnera na základě skupiny položek,
 Sales Partner Transaction Summary,Souhrn transakcí obchodního partnera,
 Sales Partners Commission,Obchodní partneři Komise,
+Invoiced Amount (Exclusive Tax),Fakturovaná částka (bez daně),
 Average Commission Rate,Průměrná cena Komise,
 Sales Payment Summary,Přehled plateb prodeje,
 Sales Person Commission Summary,Souhrnné informace Komise pro prodejce,
@@ -8405,3 +8668,938 @@
 Warehouse wise Item Balance Age and Value,Warehouse wise Item Balance věk a hodnota,
 Work Order Stock Report,Zpráva o stavu pracovní smlouvy,
 Work Orders in Progress,Pracovní příkazy v procesu,
+Validation Error,Chyba ověření,
+Automatically Process Deferred Accounting Entry,Automaticky zpracovat odložený účetní záznam,
+Bank Clearance,Bankovní odbavení,
+Bank Clearance Detail,Podrobnosti o bankovním odbavení,
+Update Cost Center Name / Number,Aktualizujte název / číslo nákladového střediska,
+Journal Entry Template,Šablona zápisu do deníku,
+Template Title,Název šablony,
+Journal Entry Type,Typ položky deníku,
+Journal Entry Template Account,Účet šablony zápisu do deníku,
+Process Deferred Accounting,Zpracovat odložené účetnictví,
+Manual entry cannot be created! Disable automatic entry for deferred accounting in accounts settings and try again,Ruční zadání nelze vytvořit! V nastavení účtů zakažte automatické zadávání odloženého účetnictví a zkuste to znovu,
+End date cannot be before start date,Datum ukončení nemůže být před datem zahájení,
+Total Counts Targeted,Celkový počet zacílených,
+Total Counts Completed,Celkový počet dokončen,
+Counts Targeted: {0},Počet zacílených: {0},
+Payment Account is mandatory,Platební účet je povinný,
+"If checked, the full amount will be deducted from taxable income before calculating income tax without any declaration or proof submission.","Pokud je zaškrtnuto, bude odečtena celá částka ze zdanitelného příjmu před výpočtem daně z příjmu bez jakéhokoli prohlášení nebo předložení dokladu.",
+Disbursement Details,Podrobnosti o výplatě,
+Material Request Warehouse,Sklad požadavku na materiál,
+Select warehouse for material requests,Vyberte sklad pro požadavky na materiál,
+Transfer Materials For Warehouse {0},Přenos materiálů do skladu {0},
+Production Plan Material Request Warehouse,Sklad požadavku na materiál výrobního plánu,
+Set From Warehouse,Nastaveno ze skladu,
+Source Warehouse (Material Transfer),Zdrojový sklad (přenos materiálu),
+Sets 'Source Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Zdrojový sklad“.,
+Sets 'Target Warehouse' in each row of the items table.,Nastaví v každém řádku tabulky položek „Target Warehouse“.,
+Show Cancelled Entries,Zobrazit zrušené položky,
+Backdated Stock Entry,Zpětný vstup akcií,
+Row #{}: Currency of {} - {} doesn't matches company currency.,Řádek # {}: Měna {} - {} neodpovídá měně společnosti.,
+{} Assets created for {},{} Díla vytvořená pro {},
+{0} Number {1} is already used in {2} {3},{0} Číslo {1} je již použito v {2} {3},
+Update Bank Clearance Dates,Aktualizujte data zúčtování banky,
+Healthcare Practitioner: ,Praktický lékař:,
+Lab Test Conducted: ,Provedený laboratorní test:,
+Lab Test Event: ,Laboratorní testovací událost:,
+Lab Test Result: ,Výsledek laboratorního testu:,
+Clinical Procedure conducted: ,Provedený klinický postup:,
+Therapy Session Charges: {0},Poplatky za terapeutické sezení: {0},
+Therapy: ,Terapie:,
+Therapy Plan: ,Terapeutický plán:,
+Total Counts Targeted: ,Celkový počet zacílených:,
+Total Counts Completed: ,Celkový počet dokončených:,
+Andaman and Nicobar Islands,Andamanské a Nikobarské ostrovy,
+Andhra Pradesh,Andhra Pradesh,
+Arunachal Pradesh,Arunáčalpradéš,
+Assam,Assam,
+Bihar,Bihar,
+Chandigarh,Chandigarh,
+Chhattisgarh,Chhattisgarh,
+Dadra and Nagar Haveli,Dadra a Nagar Haveli,
+Daman and Diu,Daman a Diu,
+Delhi,Dillí,
+Goa,Goa,
+Gujarat,Gudžarát,
+Haryana,Haryana,
+Himachal Pradesh,Himáčalpradéš,
+Jammu and Kashmir,Džammú a Kašmír,
+Jharkhand,Jharkhand,
+Karnataka,Karnataka,
+Kerala,Kerala,
+Lakshadweep Islands,Ostrovy Lakshadweep,
+Madhya Pradesh,Madhya Pradesh,
+Maharashtra,Maharashtra,
+Manipur,Manipur,
+Meghalaya,Meghalaya,
+Mizoram,Mizoram,
+Nagaland,Nagaland,
+Odisha,Urísa,
+Other Territory,Jiné území,
+Pondicherry,Pondicherry,
+Punjab,Paňdžáb,
+Rajasthan,Rádžasthán,
+Sikkim,Sikkim,
+Tamil Nadu,Tamil Nadu,
+Telangana,Telangana,
+Tripura,Tripura,
+Uttar Pradesh,Uttarpradéš,
+Uttarakhand,Uttarakhand,
+West Bengal,Západní Bengálsko,
+Is Mandatory,Je povinná,
+Published on,Publikováno dne,
+Service Received But Not Billed,"Služba přijata, ale není účtována",
+Deferred Accounting Settings,Nastavení odloženého účetnictví,
+Book Deferred Entries Based On,Zarezervujte odložené položky na základě,
+"If ""Months"" is selected then fixed amount will be booked as deferred revenue or expense for each month irrespective of number of days in a month. Will be prorated if deferred revenue or expense is not booked for an entire month.","Pokud je vybrána možnost „Měsíce“, bude pevná částka zaúčtována jako odložený výnos nebo výdaj za každý měsíc bez ohledu na počet dní v měsíci. Pokud nebudou odložené výnosy nebo výdaje rezervovány na celý měsíc, budou rozděleny podle nákladů.",
+Days,Dny,
+Months,Měsíce,
+Book Deferred Entries Via Journal Entry,Zarezervujte si odložené položky prostřednictvím záznamu v deníku,
+If this is unchecked direct GL Entries will be created to book Deferred Revenue/Expense,"Pokud toto políčko nezaškrtnete, budou vytvořeny přímé položky GL k zaúčtování odložených výnosů / výdajů",
+Submit Journal Entries,Odeslat položky deníku,
+If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually,"Pokud není zaškrtnuto, budou se deníkové záznamy ukládat ve stavu konceptu a budou muset být odeslány ručně",
+Enable Distributed Cost Center,Povolit distribuované nákladové středisko,
+Distributed Cost Center,Distribuované nákladové středisko,
+Dunning,Upomínání,
+DUNN-.MM.-.YY.-,DUNN-.MM .-. YY.-,
+Overdue Days,Dny po splatnosti,
+Dunning Type,Typ upomínání,
+Dunning Fee,Poplatek za upomínání,
+Dunning Amount,Částka upuštění,
+Resolved,Vyřešeno,
+Unresolved,Nevyřešené,
+Printing Setting,Nastavení tisku,
+Body Text,Text těla,
+Closing Text,Závěrečný text,
+Resolve,Odhodlání,
+Dunning Letter Text,Upuštění od dopisu Text,
+Is Default Language,Je výchozí jazyk,
+Letter or Email Body Text,Text v dopise nebo e-mailu,
+Letter or Email Closing Text,Dopis nebo e-mail závěrečný text,
+Body and Closing Text Help,Text a nápověda pro závěrečný text,
+Overdue Interval,Interval po splatnosti,
+Dunning Letter,Upomínka,
+"This section allows the user to set the Body and Closing text of the Dunning Letter for the Dunning Type based on language, which can be used in Print.","Tato část umožňuje uživateli nastavit text a závěrečný text upomínkového dopisu pro typ upomínání na základě jazyka, který lze použít v tisku.",
+Reference Detail No,Referenční číslo č,
+Custom Remarks,Vlastní poznámky,
+Please select a Company first.,Nejprve vyberte společnost.,
+"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice, Journal Entry or Dunning","Řádek # {0}: Typ referenčního dokumentu musí být jeden z prodejní objednávky, prodejní faktury, zápisu do deníku nebo upomínání",
+POS Closing Entry,Uzávěrka vstupu POS,
+POS Opening Entry,Otevírací vstup POS,
+POS Transactions,POS transakce,
+POS Closing Entry Detail,Detail uzávěrky vstupu POS,
+Opening Amount,Počáteční částka,
+Closing Amount,Konečná částka,
+POS Closing Entry Taxes,POS uzavírání vstupních daní,
+POS Invoice,POS faktura,
+ACC-PSINV-.YYYY.-,ACC-PSINV-.RRRR.-,
+Consolidated Sales Invoice,Konsolidovaná prodejní faktura,
+Return Against POS Invoice,Vraťte se proti POS faktuře,
+Consolidated,Konsolidované,
+POS Invoice Item,Položka faktury POS,
+POS Invoice Merge Log,Protokol sloučení faktury POS,
+POS Invoices,POS faktury,
+Consolidated Credit Note,Konsolidovaný dobropis,
+POS Invoice Reference,Odkaz na fakturu POS,
+Set Posting Date,Nastavte datum zaúčtování,
+Opening Balance Details,Počáteční zůstatek Podrobnosti,
+POS Opening Entry Detail,Detail otevření vstupenky POS,
+POS Payment Method,Způsob platby POS,
+Payment Methods,platební metody,
+Process Statement Of Accounts,Zpracování výpisu z účtů,
+General Ledger Filters,Filtry hlavní knihy,
+Customers,Zákazníci,
+Select Customers By,Vyberte Zákazníci podle,
+Fetch Customers,Načíst zákazníky,
+Send To Primary Contact,Odeslat primárnímu kontaktu,
+Print Preferences,Předvolby tisku,
+Include Ageing Summary,Zahrnout shrnutí stárnutí,
+Enable Auto Email,Povolit automatický e-mail,
+Filter Duration (Months),Délka filtru (měsíce),
+CC To,CC To,
+Help Text,Pomocný text,
+Emails Queued,E-maily ve frontě,
+Process Statement Of Accounts Customer,Zpracování výpisu z účtu zákazníka,
+Billing Email,Fakturační e-mail,
+Primary Contact Email,Primární kontaktní e-mail,
+PSOA Cost Center,Nákladové středisko PSOA,
+PSOA Project,Projekt PSOA,
+ACC-PINV-RET-.YYYY.-,ACC-PINV-RET-.RRRR.-,
+Supplier GSTIN,Dodavatel GSTIN,
+Place of Supply,Místo dodání,
+Select Billing Address,Vyberte fakturační adresu,
+GST Details,Podrobnosti GST,
+GST Category,Kategorie GST,
+Registered Regular,Registrováno pravidelně,
+Registered Composition,Registrovaná kompozice,
+Unregistered,Neregistrovaný,
+SEZ,SEZ,
+Overseas,Zámoří,
+UIN Holders,Držitelé UIN,
+With Payment of Tax,S platbou daně,
+Without Payment of Tax,Bez platby daně,
+Invoice Copy,Kopie faktury,
+Original for Recipient,Originál pro příjemce,
+Duplicate for Transporter,Duplikát pro Transporter,
+Duplicate for Supplier,Duplikát pro dodavatele,
+Triplicate for Supplier,Třikrát pro dodavatele,
+Reverse Charge,Zpětný poplatek,
+Y,Y,
+N,N,
+E-commerce GSTIN,Elektronický obchod GSTIN,
+Reason For Issuing document,Důvod vystavení dokladu,
+01-Sales Return,01-Návratnost prodeje,
+02-Post Sale Discount,Sleva 02-post prodej,
+03-Deficiency in services,03-Nedostatek služeb,
+04-Correction in Invoice,04 - Oprava na faktuře,
+05-Change in POS,05 - Změna v POS,
+06-Finalization of Provisional assessment,06-Dokončení prozatímního posouzení,
+07-Others,07-Ostatní,
+Eligibility For ITC,Způsobilost pro ITC,
+Input Service Distributor,Distributor vstupních služeb,
+Import Of Service,Import služby,
+Import Of Capital Goods,Dovoz investičního zboží,
+Ineligible,Neoprávněné,
+All Other ITC,Všechny ostatní ITC,
+Availed ITC Integrated Tax,Využíval integrovanou daň ITC,
+Availed ITC Central Tax,Využíval centrální daň ITC,
+Availed ITC State/UT Tax,Využil stát ITC / daň UT,
+Availed ITC Cess,Využil ITC Cess,
+Is Nil Rated or Exempted,Je nulová nebo je osvobozena,
+Is Non GST,Není GST,
+ACC-SINV-RET-.YYYY.-,ACC-SINV-RET-.YYYY.-,
+E-Way Bill No.,E-Way Bill č.,
+Is Consolidated,Je konsolidováno,
+Billing Address GSTIN,Fakturační adresa GSTIN,
+Customer GSTIN,Zákazník GSTIN,
+GST Transporter ID,ID přepravce GST,
+Distance (in km),Vzdálenost (v km),
+Road,Silnice,
+Air,Vzduch,
+Rail,Železnice,
+Ship,Loď,
+GST Vehicle Type,Typ vozidla GST,
+Over Dimensional Cargo (ODC),Over Dimensional Cargo (ODC),
+Consumer,Spotřebitel,
+Deemed Export,Považován za export,
+Port Code,Kód přístavu,
+ Shipping Bill Number,Číslo faktury za přepravu,
+Shipping Bill Date,Datum faktury za přepravu,
+Subscription End Date,Datum ukončení předplatného,
+Follow Calendar Months,Sledujte kalendářní měsíce,
+If this is checked subsequent new invoices will be created on calendar  month and quarter start dates irrespective of current invoice start date,"Pokud je toto zaškrtnuto, budou se v den zahájení kalendářního měsíce a čtvrtletí vytvářet nové nové faktury bez ohledu na aktuální datum zahájení faktury",
+Generate New Invoices Past Due Date,Generování nových faktur po splatnosti,
+New invoices will be generated as per schedule even if current invoices are unpaid or past due date,"Nové faktury budou generovány podle plánu, i když jsou aktuální faktury nezaplacené nebo po splatnosti",
+Document Type ,Typ dokumentu,
+Subscription Price Based On,Cena předplatného na základě,
+Fixed Rate,Pevná sazba,
+Based On Price List,Na základě ceníku,
+Monthly Rate,Měsíční sazba,
+Cancel Subscription After Grace Period,Zrušte předplatné po uplynutí odkladné lhůty,
+Source State,Stav zdroje,
+Is Inter State,Je Inter State,
+Purchase Details,Podrobnosti o nákupu,
+Depreciation Posting Date,Datum zaúčtování odpisů,
+Purchase Order Required for Purchase Invoice & Receipt Creation,Nákupní objednávka požadovaná pro vytvoření nákupní faktury a vytvoření účtenky,
+Purchase Receipt Required for Purchase Invoice Creation,Potvrzení o nákupu požadované pro vytvoření faktury za nákup,
+"By default, the Supplier Name is set as per the Supplier Name entered. If you want Suppliers to be named by a  ","Ve výchozím nastavení je název dodavatele nastaven podle zadaného názvu dodavatele. Pokud chcete, aby Dodavatelé byli pojmenováni a",
+ choose the 'Naming Series' option.,vyberte možnost „Pojmenování série“.,
+Configure the default Price List when creating a new Purchase transaction. Item prices will be fetched from this Price List.,Při vytváření nové nákupní transakce nakonfigurujte výchozí ceník. Ceny položek budou načteny z tohoto ceníku.,
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice or Receipt without creating a Purchase Order first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Order' checkbox in the Supplier master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření nákupní faktury nebo účtenky, aniž byste nejprve vytvořili nákupní objednávku. Tuto konfiguraci lze přepsat pro konkrétního dodavatele povolením zaškrtávacího políčka „Povolit vytvoření faktury za nákup bez objednávky“ v hlavním okně dodavatele.",
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Purchase Invoice without creating a Purchase Receipt first. This configuration can be overridden for a particular supplier by enabling the 'Allow Purchase Invoice Creation Without Purchase Receipt' checkbox in the Supplier master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření nákupní faktury, aniž byste nejprve vytvořili nákupní doklad. Tuto konfiguraci lze pro konkrétního dodavatele přepsat povolením zaškrtávacího políčka „Povolit vytvoření faktury za nákup bez dokladu o nákupu“ v hlavním okně dodavatele.",
+Quantity & Stock,Množství a sklad,
+Call Details,Detaily hovoru,
+Authorised By,Schváleno,
+Signee (Company),Signee (společnost),
+Signed By (Company),Podepsáno (společností),
+First Response Time,Čas první reakce,
+Request For Quotation,Žádost o nabídku,
+Opportunity Lost Reason Detail,Detail ztraceného důvodu příležitosti,
+Access Token Secret,Přístup k tajnému tokenu,
+Add to Topics,Přidat do témat,
+...Adding Article to Topics,... Přidávání článku k tématům,
+Add Article to Topics,Přidat článek do témat,
+This article is already added to the existing topics,Tento článek je již přidán k existujícím tématům,
+Add to Programs,Přidat do programů,
+Programs,Programy,
+...Adding Course to Programs,... Přidání kurzu k programům,
+Add Course to Programs,Přidejte kurz do programů,
+This course is already added to the existing programs,Tento kurz je již přidán k existujícím programům,
+Learning Management System Settings,Nastavení systému pro správu učení,
+Enable Learning Management System,Povolit systém pro správu učení,
+Learning Management System Title,Název systému řízení učení,
+...Adding Quiz to Topics,... Přidání kvízu k tématům,
+Add Quiz to Topics,Přidejte kvíz k tématům,
+This quiz is already added to the existing topics,Tento kvíz je již přidán k existujícím tématům,
+Enable Admission Application,Povolit žádost o přijetí,
+EDU-ATT-.YYYY.-,EDU-ATT-.RRRR.-,
+Marking attendance,Značení docházky,
+Add Guardians to Email Group,Přidejte do skupiny e-mailů strážce,
+Attendance Based On,Docházka na základě,
+Check this to mark the student as present in case the student is not attending the institute to participate or represent the institute in any event.\n\n,"Zaškrtnutím tohoto políčka označíte studenta jako přítomného v případě, že se student v žádném případě neúčastní ústavu, aby se ho účastnil nebo zastupoval.",
+Add to Courses,Přidat do kurzů,
+...Adding Topic to Courses,... Přidání tématu do kurzů,
+Add Topic to Courses,Přidejte téma do kurzů,
+This topic is already added to the existing courses,Toto téma je již přidáno do stávajících kurzů,
+"If Shopify does not have a customer in the order, then while syncing the orders, the system will consider the default customer for the order","Pokud Shopify nemá v objednávce zákazníka, bude systém při synchronizaci objednávek považovat výchozího zákazníka pro objednávku",
+The accounts are set by the system automatically but do confirm these defaults,"Účty nastavuje systém automaticky, ale tyto výchozí hodnoty potvrzují",
+Default Round Off Account,Výchozí zaokrouhlovací účet,
+Failed Import Log,Neúspěšný import protokolu,
+Fixed Error Log,Opravený protokol chyb,
+Company {0} already exists. Continuing will overwrite the Company and Chart of Accounts,Společnost {0} již existuje. Pokračováním přepíšete společnost a účtovou osnovu,
+Meta Data,Meta data,
+Unresolve,Nevyřešit,
+Create Document,Vytvořit dokument,
+Mark as unresolved,Označit jako nevyřešené,
+TaxJar Settings,Nastavení TaxJar,
+Sandbox Mode,Sandbox Mode,
+Enable Tax Calculation,Povolit výpočet daně,
+Create TaxJar Transaction,Vytvořte transakci TaxJar,
+Credentials,Pověření,
+Live API Key,Živý klíč API,
+Sandbox API Key,Klíč Sandbox API,
+Configuration,Konfigurace,
+Tax Account Head,Vedoucí daňového účtu,
+Shipping Account Head,Vedoucí přepravního účtu,
+Practitioner Name,Jméno praktického lékaře,
+Enter a name for the Clinical Procedure Template,Zadejte název šablony klinické procedury,
+Set the Item Code which will be used for billing the Clinical Procedure.,"Nastavte kód položky, který bude použit pro fakturaci klinického postupu.",
+Select an Item Group for the Clinical Procedure Item.,Vyberte skupinu položek pro položku klinického postupu.,
+Clinical Procedure Rate,Míra klinického postupu,
+Check this if the Clinical Procedure is billable and also set the rate.,"Zaškrtněte toto políčko, pokud je klinický postup fakturovatelný, a také nastavte rychlost.",
+Check this if the Clinical Procedure utilises consumables. Click ,"Toto zkontrolujte, pokud klinický postup využívá spotřební materiál. Klepněte na",
+ to know more,vědět více,
+"You can also set the Medical Department for the template. After saving the document, an Item will automatically be created for billing this Clinical Procedure. You can then use this template while creating Clinical Procedures for Patients. Templates save you from filling up redundant data every single time. You can also create templates for other operations like Lab Tests, Therapy Sessions, etc.","Pro šablonu můžete také nastavit lékařské oddělení. Po uložení dokumentu se automaticky vytvoří položka pro fakturaci tohoto klinického postupu. Tuto šablonu pak můžete použít při vytváření Klinických postupů pro pacienty. Šablony vám pomohou pokaždé zaplnit nadbytečná data. Můžete také vytvořit šablony pro další operace, jako jsou laboratorní testy, terapeutické relace atd.",
+Descriptive Test Result,Výsledek popisného testu,
+Allow Blank,Povolit prázdné,
+Descriptive Test Template,Popisná testovací šablona,
+"If you want to track Payroll and other HRMS operations for a Practitoner, create an Employee and link it here.","Pokud chcete sledovat mzdy a další operace HRMS pro praktického lékaře, vytvořte zaměstnance a propojte jej zde.",
+Set the Practitioner Schedule you just created. This will be used while booking appointments.,"Nastavte si plán praktiků, který jste právě vytvořili. To bude použito při rezervaci schůzek.",
+Create a service item for Out Patient Consulting.,Vytvořte položku služby pro Out Patient Consulting.,
+"If this Healthcare Practitioner works for the In-Patient Department, create a service item for Inpatient Visits.","Pokud tento zdravotnický pracovník pracuje pro interní oddělení, vytvořte položku služby pro hospitalizované návštěvy.",
+Set the Out Patient Consulting Charge for this Practitioner.,U tohoto praktického lékaře stanovte poplatek za konzultaci s pacientem.,
+"If this Healthcare Practitioner also works for the In-Patient Department, set the inpatient visit charge for this Practitioner.","Pokud tento zdravotnický pracovník pracuje také pro interní oddělení, stanovte poplatek za návštěvu lůžkového lékaře pro tohoto praktického lékaře.",
+"If checked, a customer will be created for every Patient. Patient Invoices will be created against this Customer. You can also select existing Customer while creating a Patient. This field is checked by default.","Pokud je zaškrtnuto, vytvoří se zákazník pro každého pacienta. Proti tomuto zákazníkovi budou vytvořeny pacientské faktury. Při vytváření pacienta můžete také vybrat stávajícího zákazníka. Toto pole je ve výchozím nastavení zaškrtnuto.",
+Collect Registration Fee,Vybírat registrační poplatek,
+"If your Healthcare facility bills registrations of Patients, you can check this and set the Registration Fee in the field below. Checking this will create new Patients with a Disabled status by default and will only be enabled after invoicing the Registration Fee.","Pokud vaše zdravotnické zařízení účtuje registrace pacientů, můžete to zkontrolovat a nastavit registrační poplatek v poli níže. Zaškrtnutí tohoto políčka ve výchozím nastavení vytvoří nové pacienty se zdravotním stavem a bude povoleno až po fakturaci registračního poplatku.",
+Checking this will automatically create a Sales Invoice whenever an appointment is booked for a Patient.,"Zaškrtnutím tohoto políčka se automaticky vytvoří prodejní faktura vždy, když je pacientovi rezervována schůzka.",
+Healthcare Service Items,Položky zdravotní péče,
+"You can create a service item for Inpatient Visit Charge and set it here. Similarly, you can set up other Healthcare Service Items for billing in this section. Click ",Můžete vytvořit položku služby pro poplatek za hospitalizaci a nastavit ji zde. Podobně můžete v této části nastavit další položky služeb zdravotní péče pro fakturaci. Klepněte na,
+Set up default Accounts for the Healthcare Facility,Nastavte výchozí účty pro zdravotnické zařízení,
+"If you wish to override default accounts settings and configure the Income and Receivable accounts for Healthcare, you can do so here.","Pokud chcete přepsat výchozí nastavení účtů a nakonfigurovat účty příjmů a pohledávek pro Healthcare, můžete tak učinit zde.",
+Out Patient SMS alerts,Upozornění na SMS mimo pacienta,
+"If you want to send SMS alert on Patient Registration, you can enable this option. Similary, you can set up Out Patient SMS alerts for other functionalities in this section. Click ","Chcete-li odeslat upozornění SMS na registraci pacienta, můžete tuto možnost povolit. Podobně můžete v této části nastavit výstrahy SMS pro pacienta pro další funkce. Klepněte na",
+Admission Order Details,Podrobnosti objednávky,
+Admission Ordered For,Objednáno vstupné,
+Expected Length of Stay,Očekávaná délka pobytu,
+Admission Service Unit Type,Typ jednotky přijímacího servisu,
+Healthcare Practitioner (Primary),Praktický lékař (primární),
+Healthcare Practitioner (Secondary),Praktický lékař (sekundární),
+Admission Instruction,Pokyny k přijetí,
+Chief Complaint,Hlavní stížnost,
+Medications,Léky,
+Investigations,Vyšetřování,
+Discharge Detials,Vybíjení Detials,
+Discharge Ordered Date,Datum objednání vyložení,
+Discharge Instructions,Pokyny k vybíjení,
+Follow Up Date,Následné datum,
+Discharge Notes,Poznámky k vybíjení,
+Processing Inpatient Discharge,Zpracování propuštění pacientů,
+Processing Patient Admission,Zpracování přijetí pacienta,
+Check-in time cannot be greater than the current time,Čas příjezdu nesmí být větší než aktuální čas,
+Process Transfer,Přenos procesu,
+HLC-LAB-.YYYY.-,HLC-LAB-.RRRR.-,
+Expected Result Date,Očekávané datum výsledku,
+Expected Result Time,Očekávaný čas výsledku,
+Printed on,Vytištěno na,
+Requesting Practitioner,Žádající odborník,
+Requesting Department,Žádající oddělení,
+Employee (Lab Technician),Zaměstnanec (laboratorní technik),
+Lab Technician Name,Jméno laboranta,
+Lab Technician Designation,Označení laboratorního technika,
+Compound Test Result,Výsledek složené zkoušky,
+Organism Test Result,Výsledek testu organismu,
+Sensitivity Test Result,Výsledek testu citlivosti,
+Worksheet Print,Tisk listu,
+Worksheet Instructions,Pokyny k listu,
+Result Legend Print,Výsledek Tisk legendy,
+Print Position,Pozice tisku,
+Bottom,Dno,
+Top,Horní,
+Both,Oba,
+Result Legend,Legenda výsledku,
+Lab Tests,Laboratorní testy,
+No Lab Tests found for the Patient {0},Nebyly nalezeny žádné laboratorní testy pro pacienta {0},
+"Did not send SMS, missing patient mobile number or message content.","Neposlal SMS, chybějící číslo mobilního telefonu pacienta nebo obsah zprávy.",
+No Lab Tests created,Nebyly vytvořeny žádné laboratorní testy,
+Creating Lab Tests...,Vytváření laboratorních testů ...,
+Lab Test Group Template,Šablona laboratorní skupiny,
+Add New Line,Přidat nový řádek,
+Secondary UOM,Sekundární UOM,
+"<b>Single</b>: Results which require only a single input.\n<br>\n<b>Compound</b>: Results which require multiple event inputs.\n<br>\n<b>Descriptive</b>: Tests which have multiple result components with manual result entry.\n<br>\n<b>Grouped</b>: Test templates which are a group of other test templates.\n<br>\n<b>No Result</b>: Tests with no results, can be ordered and billed but no Lab Test will be created. e.g.. Sub Tests for Grouped results","<b>Single</b> : Výsledky, které vyžadují pouze jeden vstup.<br> <b>Sloučenina</b> : Výsledky, které vyžadují více vstupů událostí.<br> <b>Popisné</b> : Testy, které mají více složek výsledků s ručním zadáváním výsledků.<br> <b>Seskupeno</b> : Testovací šablony, které jsou skupinou dalších testovacích šablon.<br> <b>Žádný výsledek</b> : Testy bez výsledků, lze objednat a účtovat, ale nebude vytvořen žádný laboratorní test. např. Dílčí testy pro seskupené výsledky",
+"If unchecked, the item will not be available in Sales Invoices for billing but can be used in group test creation. ","Pokud není zaškrtnuto, položka nebude k dispozici v prodejních fakturách pro fakturaci, ale lze ji použít při vytváření skupinových testů.",
+Description ,Popis,
+Descriptive Test,Popisný test,
+Group Tests,Skupinové testy,
+Instructions to be printed on the worksheet,"Pokyny, které mají být vytištěny na listu",
+"Information to help easily interpret the test report, will be printed as part of the Lab Test result.","Informace, které usnadní interpretaci protokolu o testu, budou vytištěny jako součást výsledku laboratorního testu.",
+Normal Test Result,Normální výsledek testu,
+Secondary UOM Result,Výsledek sekundárního UOM,
+Italic,Kurzíva,
+Underline,Zdůraznit,
+Organism,Organismus,
+Organism Test Item,Testovací položka organismu,
+Colony Population,Populace kolonií,
+Colony UOM,Colony UOM,
+Tobacco Consumption (Past),Spotřeba tabáku (minulá),
+Tobacco Consumption (Present),Spotřeba tabáku (současnost),
+Alcohol Consumption (Past),Spotřeba alkoholu (minulá),
+Alcohol Consumption (Present),Spotřeba alkoholu (současnost),
+Billing Item,Fakturační položka,
+Medical Codes,Lékařské kódy,
+Clinical Procedures,Klinické postupy,
+Order Admission,Objednávka Vstupné,
+Scheduling Patient Admission,Plánování přijetí pacienta,
+Order Discharge,Vybití objednávky,
+Sample Details,Ukázkové podrobnosti,
+Collected On,Shromážděno dne,
+No. of prints,Počet výtisků,
+Number of prints required for labelling the samples,Počet výtisků požadovaných pro označení vzorků,
+HLC-VTS-.YYYY.-,HLC-VTS-.RRRR.-,
+In Time,Včas,
+Out Time,Out Time,
+Payroll Cost Center,Mzdové náklady,
+Approvers,Schvalovatelé,
+The first Approver in the list will be set as the default Approver.,První schvalovatel v seznamu bude nastaven jako výchozí schvalovatel.,
+Shift Request Approver,Schvalovatel žádosti o změnu,
+PAN Number,PAN číslo,
+Provident Fund Account,Účet fondu Provident,
+MICR Code,Kód MICR,
+Repay unclaimed amount from salary,Vrátit nevyzvednutou částku z platu,
+Deduction from salary,Srážka z platu,
+Expired Leaves,Vypršela platnost listů,
+Reference No,Referenční číslo,
+Haircut percentage is the percentage difference between market value of the Loan Security and the value ascribed to that Loan Security when used as collateral for that loan.,"Procento srážky je procentní rozdíl mezi tržní hodnotou zajištění úvěru a hodnotou připisovanou tomuto zajištění úvěru, pokud je použit jako kolaterál pro danou půjčku.",
+Loan To Value Ratio expresses the ratio of the loan amount to the value of the security pledged. A loan security shortfall will be triggered if this falls below the specified value for any loan ,"Poměr půjčky k hodnotě vyjadřuje poměr výše půjčky k hodnotě zastaveného cenného papíru. Nedostatek zabezpečení půjčky se spustí, pokud poklesne pod stanovenou hodnotu jakékoli půjčky",
+If this is not checked the loan by default will be considered as a Demand Loan,"Pokud to není zaškrtnuto, bude se úvěr ve výchozím nastavení považovat za půjčku na vyžádání",
+This account is used for booking loan repayments from the borrower and also disbursing loans to the borrower,Tento účet slouží k rezervaci splátek půjčky od dlužníka a také k vyplácení půjček dlužníkovi,
+This account is capital account which is used to allocate capital for loan disbursal account ,"Tento účet je kapitálovým účtem, který se používá k přidělení kapitálu pro účet vyplácení půjček",
+This account will be used for booking loan interest accruals,Tento účet bude použit pro rezervaci časového rozlišení úroků z půjčky,
+This account will be used for booking penalties levied due to delayed repayments,Tento účet bude použit k rezervaci pokut uložených v důsledku zpožděných splátek,
+Variant BOM,Varianta kusovníku,
+Template Item,Položka šablony,
+Select template item,Vyberte položku šablony,
+Select variant item code for the template item {0},Vyberte kód varianty položky pro položku šablony {0},
+Downtime Entry,Vstup do odstávky,
+DT-,DT-,
+Workstation / Machine,Pracovní stanice / stroj,
+Operator,Operátor,
+In Mins,In Mins,
+Downtime Reason,Důvod prostoje,
+Stop Reason,Přestat Důvod,
+Excessive machine set up time,Nadměrný čas pro nastavení stroje,
+Unplanned machine maintenance,Neplánovaná údržba stroje,
+On-machine press checks,Kontroly lisu na stroji,
+Machine operator errors,Chyby obsluhy stroje,
+Machine malfunction,Porucha stroje,
+Electricity down,Elektřina dole,
+Operation Row Number,Číslo řádku operace,
+Operation {0} added multiple times in the work order {1},Operace {0} přidána několikrát v pracovní objednávce {1},
+"If ticked, multiple materials can be used for a single Work Order. This is useful if one or more time consuming products are being manufactured.","Pokud je zaškrtnuto, lze pro jednu pracovní objednávku použít více materiálů. To je užitečné, pokud se vyrábí jeden nebo více časově náročných produktů.",
+Backflush Raw Materials,Backflush suroviny,
+"The Stock Entry of type 'Manufacture' is known as backflush. Raw materials being consumed to manufacture finished goods is known as backflushing. <br><br> When creating Manufacture Entry, raw-material items are backflushed based on BOM of production item. If you want raw-material items to be backflushed based on Material Transfer entry made against that Work Order instead, then you can set it under this field.","Skladová položka typu „Výroba“ je známá jako backflush. Suroviny, které se spotřebovávají k výrobě hotových výrobků, se nazývají zpětné proplachování.<br><br> Při vytváření položky výroby jsou položky surovin zpětně vyplaceny na základě kusovníku výrobní položky. Pokud chcete, aby položky surovin byly zpětně proplaceny na základě vstupu převodu materiálu provedeného namísto této pracovní objednávky, můžete jej nastavit v tomto poli.",
+Work In Progress Warehouse,Work In Progress Warehouse,
+This Warehouse will be auto-updated in the Work In Progress Warehouse field of Work Orders.,Tento sklad se automaticky aktualizuje v poli Work In Progress Warehouse v pracovních objednávkách.,
+Finished Goods Warehouse,Sklad hotových výrobků,
+This Warehouse will be auto-updated in the Target Warehouse field of Work Order.,Tento sklad se automaticky aktualizuje v poli Cílový sklad pracovního příkazu.,
+"If ticked, the BOM cost will be automatically updated based on Valuation Rate / Price List Rate / last purchase rate of raw materials.","Pokud je zatrženo, náklady na kusovníku se automaticky aktualizují na základě míry ocenění / ceny ceníku / míry posledního nákupu surovin.",
+Source Warehouses (Optional),Zdrojové sklady (volitelné),
+"System will pickup the materials from the selected warehouses. If not specified, system will create material request for purchase.","Systém vyzvedne materiály z vybraných skladů. Pokud není zadáno, systém vytvoří materiální požadavek na nákup.",
+Lead Time,Dodací lhůta,
+PAN Details,PAN Podrobnosti,
+Create Customer,Vytvořit zákazníka,
+Invoicing,Fakturace,
+Enable Auto Invoicing,Povolit automatickou fakturaci,
+Send Membership Acknowledgement,Odeslat potvrzení členství,
+Send Invoice with Email,Odeslat fakturu e-mailem,
+Membership Print Format,Formát tisku členství,
+Invoice Print Format,Formát tisku faktury,
+Revoke <Key></Key>,Zrušit&lt;Key&gt;&lt;/Key&gt;,
+You can learn more about memberships in the manual. ,Další informace o členství najdete v příručce.,
+ERPNext Docs,ERPNext Docs,
+Regenerate Webhook Secret,Znovu vygenerujte tajemství Webhook,
+Generate Webhook Secret,Generovat Webhook Secret,
+Copy Webhook URL,Zkopírujte adresu URL Webhooku,
+Linked Item,Propojená položka,
+Is Recurring,Opakuje se,
+HRA Exemption,Výjimka HRA,
+Monthly House Rent,Měsíční nájem domu,
+Rented in Metro City,Pronajato v Metro City,
+HRA as per Salary Structure,HRA podle struktury platů,
+Annual HRA Exemption,Roční výjimka HRA,
+Monthly HRA Exemption,Měsíční výjimka HRA,
+House Rent Payment Amount,Částka platby za pronájem domu,
+Rented From Date,Pronajato od data,
+Rented To Date,Pronajato k dnešnímu dni,
+Monthly Eligible Amount,Způsobilá částka za měsíc,
+Total Eligible HRA Exemption,Celková způsobilá výjimka HRA,
+Validating Employee Attendance...,Ověření docházky zaměstnanců ...,
+Submitting Salary Slips and creating Journal Entry...,Odeslání výplatních pásek a vytvoření zápisu do deníku ...,
+Calculate Payroll Working Days Based On,Vypočítejte mzdové pracovní dny na základě,
+Consider Unmarked Attendance As,Zvažte neoznačenou účast jako,
+Fraction of Daily Salary for Half Day,Frakce denního platu za půl dne,
+Component Type,Typ součásti,
+Provident Fund,Podpůrný fond,
+Additional Provident Fund,Dodatečný zajišťovací fond,
+Provident Fund Loan,Půjčka na penzijní fond,
+Professional Tax,Profesionální daň,
+Is Income Tax Component,Je složkou daně z příjmu,
+Component properties and references ,Vlastnosti komponent a odkazy,
+Additional Salary ,Dodatečný plat,
+Condtion and formula,Podmínky a vzorec,
+Unmarked days,Neoznačené dny,
+Absent Days,Chybějící dny,
+Conditions and Formula variable and example,Podmínky a proměnná vzorce a příklad,
+Feedback By,Zpětná vazba od,
+MTNG-.YYYY.-.MM.-.DD.-,MTNG-.RRRR .-. MM .-. DD.-,
+Manufacturing Section,Sekce výroby,
+Sales Order Required for Sales Invoice & Delivery Note Creation,Pro vytvoření prodejní faktury a dodacího listu je vyžadována prodejní objednávka,
+Delivery Note Required for Sales Invoice Creation,Pro vytvoření prodejní faktury je nutný dodací list,
+"By default, the Customer Name is set as per the Full Name entered. If you want Customers to be named by a ","Ve výchozím nastavení je jméno zákazníka nastaveno podle zadaného celého jména. Pokud chcete, aby zákazníci byli pojmenováni a",
+Configure the default Price List when creating a new Sales transaction. Item prices will be fetched from this Price List.,Při vytváření nové prodejní transakce nakonfigurujte výchozí ceník. Ceny položek budou načteny z tohoto ceníku.,
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice or Delivery Note without creating a Sales Order first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Sales Order' checkbox in the Customer master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření prodejní faktury nebo dodacího listu, aniž byste nejprve vytvořili prodejní objednávku. Tuto konfiguraci lze pro konkrétního zákazníka přepsat povolením zaškrtávacího políčka „Povolit vytvoření prodejní faktury bez prodejní objednávky“ v hlavním okně zákazníka.",
+"If this option is configured 'Yes', ERPNext will prevent you from creating a Sales Invoice without creating a Delivery Note first. This configuration can be overridden for a particular Customer by enabling the 'Allow Sales Invoice Creation Without Delivery Note' checkbox in the Customer master.","Pokud je tato možnost nakonfigurována na „Ano“, ERPNext vám zabrání ve vytvoření prodejní faktury, aniž byste nejprve vytvořili dodací list. Tuto konfiguraci lze pro konkrétního zákazníka přepsat povolením zaškrtávacího políčka „Povolit vytvoření prodejní faktury bez dodacího listu“ v hlavním okně zákazníka.",
+Default Warehouse for Sales Return,Výchozí sklad pro vrácení prodeje,
+Default In Transit Warehouse,Výchozí v tranzitním skladu,
+Enable Perpetual Inventory For Non Stock Items,"Povolit trvalou inventuru pro položky, které nejsou skladem",
+HRA Settings,Nastavení HRA,
+Basic Component,Základní komponenta,
+HRA Component,Součást HRA,
+Arrear Component,Arrear Component,
+Please enter the company name to confirm,Pro potvrzení zadejte název společnosti,
+Quotation Lost Reason Detail,Nabídka ztraceného důvodu - detail,
+Enable Variants,Povolit varianty,
+Save Quotations as Draft,Uložit nabídky jako koncept,
+MAT-DN-RET-.YYYY.-,MAT-DN-RET-.YYYY.-,
+Please Select a Customer,Vyberte prosím zákazníka,
+Against Delivery Note Item,Proti položce dodacího listu,
+Is Non GST ,Není GST,
+Image Description,Popis obrázku,
+Transfer Status,Stav přenosu,
+MAT-PR-RET-.YYYY.-,MAT-PR-RET-.RRRR.-,
+Track this Purchase Receipt against any Project,Sledujte toto potvrzení o nákupu vůči jakémukoli projektu,
+Please Select a Supplier,Vyberte prosím dodavatele,
+Add to Transit,Přidat do veřejné dopravy,
+Set Basic Rate Manually,Nastavte základní sazbu ručně,
+"By default, the Item Name is set as per the Item Code entered. If you want Items to be named by a ","Ve výchozím nastavení je název položky nastaven podle zadaného kódu položky. Pokud chcete, aby položky byly pojmenovány a",
+Set a Default Warehouse for Inventory Transactions. This will be fetched into the Default Warehouse in the Item master.,Nastavit výchozí sklad pro transakce zásob. Toto bude načteno do výchozího skladu v hlavní položce.,
+"This will allow stock items to be displayed in negative values. Using this option depends on your use case. With this option unchecked, the system warns before obstructing a transaction that is causing negative stock.","To umožní, aby se skladové položky zobrazovaly v záporných hodnotách. Použití této možnosti závisí na vašem případu použití. Pokud není tato možnost zaškrtnuta, systém varuje před překážením transakce, která způsobuje záporné zásoby.",
+Choose between FIFO and Moving Average Valuation Methods. Click ,Vyberte si mezi metodami ocenění FIFO a klouzavým průměrem. Klepněte na,
+ to know more about them.,vědět o nich více.,
+Show 'Scan Barcode' field above every child table to insert Items with ease.,"Chcete-li snadno vkládat položky, zobrazte nad každou podřízenou tabulkou pole „Skenovat čárový kód“.",
+"Serial numbers for stock will be set automatically based on the Items entered based on first in first out in transactions like Purchase/Sales Invoices, Delivery Notes, etc.","Sériová čísla pro akcie budou nastavena automaticky na základě položek zadaných na základě prvního do prvního v transakcích, jako jsou nákupní / prodejní faktury, dodací listy atd.",
+"If blank, parent Warehouse Account or company default will be considered in transactions","Pokud je prázdné, bude při transakcích zohledněn nadřazený účet skladu nebo výchozí nastavení společnosti",
+Service Level Agreement Details,Podrobnosti smlouvy o úrovni služeb,
+Service Level Agreement Status,Stav smlouvy o úrovni služeb,
+On Hold Since,Pozastaveno od,
+Total Hold Time,Celková doba zadržení,
+Response Details,Podrobnosti odpovědi,
+Average Response Time,Průměrná doba odezvy,
+User Resolution Time,Čas rozlišení uživatele,
+SLA is on hold since {0},SLA je pozastavena od {0},
+Pause SLA On Status,Pozastavit SLA na stav,
+Pause SLA On,Pozastavit SLA zapnuto,
+Greetings Section,Sekce pozdravů,
+Greeting Title,Pozdrav titul,
+Greeting Subtitle,Pozdrav titulky,
+Youtube ID,Youtube ID,
+Youtube Statistics,Statistiky YouTube,
+Views,Pohledy,
+Dislikes,Nelíbí se,
+Video Settings,Nastavení videa,
+Enable YouTube Tracking,Povolit sledování YouTube,
+30 mins,30 minut,
+1 hr,1 hod,
+6 hrs,6 hodin,
+Patient Progress,Pokrok pacienta,
+Targetted,Cílené,
+Score Obtained,Dosažené skóre,
+Sessions,Session,
+Average Score,Průměrné skóre,
+Select Assessment Template,Vyberte šablonu pro hodnocení,
+ out of ,mimo,
+Select Assessment Parameter,Vyberte parametr posouzení,
+Gender: ,Rod:,
+Contact: ,Kontakt:,
+Total Therapy Sessions: ,Celková terapeutická sezení:,
+Monthly Therapy Sessions: ,Měsíční terapeutická sezení:,
+Patient Profile,Profil pacienta,
+Point Of Sale,Místě prodeje,
+Email sent successfully.,Email úspěšně odeslán.,
+Search by invoice id or customer name,Hledání podle čísla faktury nebo jména zákazníka,
+Invoice Status,Stav faktury,
+Filter by invoice status,Filtrovat podle stavu faktury,
+Select item group,Vyberte skupinu položek,
+No items found. Scan barcode again.,Žádné předměty nenalezeny. Znovu naskenujte čárový kód.,
+"Search by customer name, phone, email.","Hledání podle jména zákazníka, telefonu, e-mailu.",
+Enter discount percentage.,Zadejte procento slevy.,
+Discount cannot be greater than 100%,Sleva nesmí být větší než 100%,
+Enter customer's email,Zadejte e-mail zákazníka,
+Enter customer's phone number,Zadejte telefonní číslo zákazníka,
+Customer contact updated successfully.,Kontakt se zákazníkem byl úspěšně aktualizován.,
+Item will be removed since no serial / batch no selected.,"Položka bude odstraněna, protože není vybráno žádné sériové číslo / dávka.",
+Discount (%),Sleva (%),
+You cannot submit the order without payment.,Objednávku nemůžete odeslat bez platby.,
+You cannot submit empty order.,Nemůžete odeslat prázdnou objednávku.,
+To Be Paid,Bude zaplaceno,
+Create POS Opening Entry,Vytvořte otevírací položku POS,
+Please add Mode of payments and opening balance details.,Přidejte prosím způsob platby a počáteční zůstatek.,
+Toggle Recent Orders,Přepnout nedávné objednávky,
+Save as Draft,Uložit jako koncept,
+You must add atleast one item to save it as draft.,"Musíte přidat alespoň jednu položku, abyste ji uložili jako koncept.",
+There was an error saving the document.,Při ukládání dokumentu došlo k chybě.,
+You must select a customer before adding an item.,Před přidáním položky musíte vybrat zákazníka.,
+Please Select a Company,Vyberte prosím společnost,
+Active Leads,Aktivní zájemci,
+Please Select a Company.,Vyberte prosím společnost.,
+BOM Operations Time,Čas provozu kusovníku,
+BOM ID,ID kusovníku,
+BOM Item Code,Kód položky kusovníku,
+Time (In Mins),Čas (v minutách),
+Sub-assembly BOM Count,Počet kusů podsestavy,
+View Type,Typ zobrazení,
+Total Delivered Amount,Celková dodaná částka,
+Downtime Analysis,Analýza prostojů,
+Machine,Stroj,
+Downtime (In Hours),Odstávka (v hodinách),
+Employee Analytics,Analýza zaměstnanců,
+"""From date"" can not be greater than or equal to ""To date""",„Od data“ nesmí být větší než nebo rovno „Od data“,
+Exponential Smoothing Forecasting,Exponenciální vyhlazování prognóz,
+First Response Time for Issues,Čas první reakce na problémy,
+First Response Time for Opportunity,Čas první reakce na příležitost,
+Depreciatied Amount,Odepsaná částka,
+Period Based On,Období založené na,
+Date Based On,Datum založeno na,
+{0} and {1} are mandatory,{0} a {1} jsou povinné,
+Consider Accounting Dimensions,Zvažte účetní dimenze,
+Income Tax Deductions,Srážky daně z příjmu,
+Income Tax Component,Složka daně z příjmu,
+Income Tax Amount,Výše daně z příjmu,
+Reserved Quantity for Production,Rezervované množství pro výrobu,
+Projected Quantity,Předpokládané množství,
+ Total Sales Amount,Celková částka prodeje,
+Job Card Summary,Shrnutí pracovní karty,
+Id,Id,
+Time Required (In Mins),Požadovaný čas (v minutách),
+From Posting Date,Od data zveřejnění,
+To Posting Date,K datu zaúčtování,
+No records found,Nenalezeny žádné záznamy,
+Customer/Lead Name,Jméno zákazníka / zájemce,
+Unmarked Days,Neoznačené dny,
+Jan,Jan,
+Feb,Února,
+Mar,Mar,
+Apr,Dubna,
+Aug,Srpen,
+Sep,Září,
+Oct,Října,
+Nov,listopad,
+Dec,Prosinec,
+Summarized View,Shrnutý pohled,
+Production Planning Report,Zpráva o plánování výroby,
+Order Qty,Množství objednávky,
+Raw Material Code,Kód suroviny,
+Raw Material Name,Název suroviny,
+Allotted Qty,Přidělené množství,
+Expected Arrival Date,Očekávané datum příjezdu,
+Arrival Quantity,Množství příjezdu,
+Raw Material Warehouse,Sklad surovin,
+Order By,Seřadit podle,
+Include Sub-assembly Raw Materials,Zahrnout suroviny podsestavy,
+Professional Tax Deductions,Profesionální odpočty daní,
+Program wise Fee Collection,Programově moudrý výběr poplatků,
+Fees Collected,Poplatky vybírány,
+Project Summary,Shrnutí projektu,
+Total Tasks,Celkem úkolů,
+Tasks Completed,Úkoly byly dokončeny,
+Tasks Overdue,Úkoly po splatnosti,
+Completion,Dokončení,
+Provident Fund Deductions,Srážky fondu poskytovatele,
+Purchase Order Analysis,Analýza nákupní objednávky,
+From and To Dates are required.,Od a do jsou požadována data.,
+To Date cannot be before From Date.,To Date nemůže být před From Date.,
+Qty to Bill,Množství Billovi,
+Group by Purchase Order,Seskupit podle nákupní objednávky,
+ Purchase Value,Hodnota nákupu,
+Total Received Amount,Celková přijatá částka,
+Quality Inspection Summary,Shrnutí kontroly kvality,
+ Quoted Amount,Citovaná částka,
+Lead Time (Days),Dodací lhůta (dny),
+Include Expired,Zahrnout vypršela,
+Recruitment Analytics,Náborová analýza,
+Applicant name,Jméno uchazeče,
+Job Offer status,Stav pracovní nabídky,
+On Date,Na rande,
+Requested Items to Order and Receive,Požadované položky k objednání a přijetí,
+Salary Payments Based On Payment Mode,Platy na základě platebního režimu,
+Salary Payments via ECS,Platy přes ECS,
+Account No,Číslo účtu,
+IFSC,IFSC,
+MICR,MICR,
+Sales Order Analysis,Analýza prodejní objednávky,
+Amount Delivered,Doručená částka,
+Delay (in Days),Zpoždění (ve dnech),
+Group by Sales Order,Seskupit podle prodejní objednávky,
+ Sales Value,Hodnota prodeje,
+Stock Qty vs Serial No Count,Skladové množství vs sériové číslo se nepočítá,
+Serial No Count,Sériové číslo,
+Work Order Summary,Shrnutí pracovní objednávky,
+Produce Qty,Množství produkce,
+Lead Time (in mins),Dodací lhůta (v minutách),
+Charts Based On,Grafy založené na,
+YouTube Interactions,Interakce s YouTube,
+Published Date,Datum zveřejnění,
+Barnch,Barnch,
+Select a Company,Vyberte společnost,
+Opportunity {0} created,Byla vytvořena příležitost {0},
+Kindly select the company first,Nejprve prosím vyberte společnost,
+Please enter From Date and To Date to generate JSON,"Chcete-li vygenerovat JSON, zadejte datum a datum",
+PF Account,Účet PF,
+PF Amount,Částka PF,
+Additional PF,Další PF,
+PF Loan,PF Půjčka,
+Download DATEV File,Stáhněte si soubor DATEV,
+Numero has not set in the XML file,Numero není nastaveno v souboru XML,
+Inward Supplies(liable to reverse charge),Dovozní dodávky (podléhající přenesení daňové povinnosti),
+This is based on the course schedules of this Instructor,Vychází to z rozvrhů kurzu tohoto instruktora,
+Course and Assessment,Kurz a hodnocení,
+Course {0} has been added to all the selected programs successfully.,Kurz {0} byl úspěšně přidán do všech vybraných programů.,
+Programs updated,Programy aktualizovány,
+Program and Course,Program a kurz,
+{0} or {1} is mandatory,{0} nebo {1} je povinné,
+Mandatory Fields,Povinná pole,
+Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nepatří do skupiny Student {2},
+Student Attendance record {0} already exists against the Student {1},Záznam docházky studentů {0} proti studentovi již existuje {1},
+Duplicate Entry,Duplicitní záznam,
+Course and Fee,Kurz a poplatek,
+Not eligible for the admission in this program as per Date Of Birth,Nemá nárok na přijetí v tomto programu podle data narození,
+Topic {0} has been added to all the selected courses successfully.,Téma {0} bylo úspěšně přidáno do všech vybraných kurzů.,
+Courses updated,Kurzy aktualizovány,
+{0} {1} has been added to all the selected topics successfully.,{0} {1} byl úspěšně přidán do všech vybraných témat.,
+Topics updated,Témata aktualizována,
+Academic Term and Program,Akademický termín a program,
+Last Stock Transaction for item {0} was on {1}.,Poslední skladová transakce u položky {0} proběhla {1}.,
+Stock Transactions for Item {0} cannot be posted before this time.,Skladové transakce s položkou {0} nelze do této doby zaúčtovat.,
+Please remove this item and try to submit again or update the posting time.,Odeberte tuto položku a zkuste ji odeslat znovu nebo aktualizujte čas zveřejnění.,
+Failed to Authenticate the API key.,Ověření klíče API se nezdařilo.,
+Invalid Credentials,Neplatná pověření,
+URL can only be a string,URL může být pouze řetězec,
+"Here is your webhook secret, this will be shown to you only once.","Toto je vaše tajemství webhooku, které se vám zobrazí pouze jednou.",
+The payment for this membership is not paid. To generate invoice fill the payment details,Platba za toto členství se neplatí. Pro vygenerování faktury vyplňte platební údaje,
+An invoice is already linked to this document,Faktura je již propojena s tímto dokumentem,
+No customer linked to member {},Žádný zákazník není propojen s členem {},
+You need to set <b>Debit Account</b> in Membership Settings,V nastavení členství musíte nastavit <b>debetní účet</b>,
+You need to set <b>Default Company</b> for invoicing in Membership Settings,Musíte nastavit <b>Výchozí společnost</b> pro fakturaci v Nastavení členství,
+You need to enable <b>Send Acknowledge Email</b> in Membership Settings,Musíte povolit <b>Odeslat potvrzovací e-mail</b> v Nastavení členství,
+Error creating membership entry for {0},Chyba při vytváření záznamu o členství pro {0},
+A customer is already linked to this Member,Zákazník je již s tímto členem propojen,
+End Date must not be lesser than Start Date,Datum ukončení nesmí být menší než datum zahájení,
+Employee {0} already has Active Shift {1}: {2},Zaměstnanec {0} již má aktivní posun {1}: {2},
+ from {0},od {0},
+ to {0},do {0},
+Please select Employee first.,Nejprve prosím vyberte Zaměstnanec.,
+Please set {0} for the Employee or for Department: {1},Nastavte prosím {0} pro zaměstnance nebo pro oddělení: {1},
+To Date should be greater than From Date,Do data by mělo být větší než Od data,
+Employee Onboarding: {0} is already for Job Applicant: {1},Zapojení zaměstnanců: {0} je již pro uchazeče o zaměstnání: {1},
+Job Offer: {0} is already for Job Applicant: {1},Nabídka práce: {0} je již pro uchazeče o zaměstnání: {1},
+Only Shift Request with status 'Approved' and 'Rejected' can be submitted,Lze odeslat pouze žádost o změnu se stavem „Schváleno“ a „Odmítnuto“,
+Shift Assignment: {0} created for Employee: {1},Přiřazení směny: {0} vytvořeno pro zaměstnance: {1},
+You can not request for your Default Shift: {0},O svůj výchozí posun nemůžete požádat: {0},
+Only Approvers can Approve this Request.,Tuto žádost mohou schválit pouze schvalovatelé.,
+Asset Value Analytics,Analýza hodnoty majetku,
+Category-wise Asset Value,Hodnota aktiv podle kategorie,
+Total Assets,Celková aktiva,
+New Assets (This Year),Nová aktiva (tento rok),
+Row #{}: Depreciation Posting Date should not be equal to Available for Use Date.,Řádek {{}: Datum zaúčtování odpisů by se nemělo rovnat Datumu použitelnosti.,
+Incorrect Date,Nesprávné datum,
+Invalid Gross Purchase Amount,Neplatná hrubá částka nákupu,
+There are active maintenance or repairs against the asset. You must complete all of them before cancelling the asset.,U aktiva probíhá aktivní údržba nebo opravy. Před zrušením aktiva je musíte všechny dokončit.,
+% Complete,% Kompletní,
+Back to Course,Zpět na kurz,
+Finish Topic,Dokončit téma,
+Mins,Min,
+by,podle,
+Back to,Zpět k,
+Enrolling...,Registrace ...,
+You have successfully enrolled for the program ,Úspěšně jste se zaregistrovali do programu,
+Enrolled,Zapsáno,
+Watch Intro,Sledujte úvod,
+We're here to help!,"Jsme tu, abychom vám pomohli!",
+Frequently Read Articles,Často číst články,
+Please set a default company address,Nastavte prosím výchozí adresu společnosti,
+{0} is not a valid state! Check for typos or enter the ISO code for your state.,{0} není platný stav! Zkontrolujte překlepy nebo zadejte kód ISO svého státu.,
+Error occured while parsing Chart of Accounts: Please make sure that no two accounts have the same name,"Při analýze účtové osnovy došlo k chybě: Ujistěte se, že žádné dva účty nemají stejný název",
+Plaid invalid request error,Přehozená chyba neplatné žádosti,
+Please check your Plaid client ID and secret values,Zkontrolujte prosím ID klienta a tajné hodnoty,
+Bank transaction creation error,Chyba při vytváření bankovní transakce,
+Unit of Measurement,Jednotka měření,
+Row #{}: Selling rate for item {} is lower than its {}. Selling rate should be atleast {},Řádek {}: Míra prodeje pro položku {} je nižší než její {}. Míra prodeje by měla být alespoň {},
+Fiscal Year {0} Does Not Exist,Fiskální rok {0} neexistuje,
+Row # {0}: Returned Item {1} does not exist in {2} {3},Řádek č. {0}: Vrácená položka {1} neexistuje v doméně {2} {3},
+Valuation type charges can not be marked as Inclusive,Poplatky typu ocenění nelze označit jako inkluzivní,
+You do not have permissions to {} items in a {}.,K {} položkám v {} nemáte oprávnění.,
+Insufficient Permissions,Nedostatečná oprávnění,
+You are not allowed to update as per the conditions set in {} Workflow.,Nemáte povolení k aktualizaci podle podmínek stanovených v {} Workflow.,
+Expense Account Missing,Chybí výdajový účet,
+{0} is not a valid Value for Attribute {1} of Item {2}.,{0} není platná hodnota pro atribut {1} položky {2}.,
+Invalid Value,Neplatná hodnota,
+The value {0} is already assigned to an existing Item {1}.,Hodnota {0} je již přiřazena ke stávající položce {1}.,
+"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.","Chcete-li pokračovat v úpravách této hodnoty atributu, povolte {0} v nastavení varianty položky.",
+Edit Not Allowed,Upravit není povoleno,
+Row #{0}: Item {1} is already fully received in Purchase Order {2},Řádek č. {0}: Položka {1} je již plně přijata v objednávce {2},
+You cannot create or cancel any accounting entries with in the closed Accounting Period {0},V uzavřeném účetním období nemůžete vytvářet ani rušit žádné účetní položky {0},
+POS Invoice should have {} field checked.,Na faktuře POS by mělo být zaškrtnuto pole {}.,
+Invalid Item,Neplatná položka,
+Row #{}: You cannot add postive quantities in a return invoice. Please remove item {} to complete the return.,"Řádek č. {}: Do zpáteční faktury nelze přidat poštovní množství. Chcete-li vrácení dokončit, odeberte položku {}.",
+The selected change account {} doesn't belongs to Company {}.,Vybraný účet změny {} nepatří společnosti {}.,
+Atleast one invoice has to be selected.,Je třeba vybrat alespoň jednu fakturu.,
+Payment methods are mandatory. Please add at least one payment method.,Platební metody jsou povinné. Přidejte alespoň jednu platební metodu.,
+Please select a default mode of payment,Vyberte prosím výchozí způsob platby,
+You can only select one mode of payment as default,Jako výchozí můžete vybrat pouze jeden způsob platby,
+Missing Account,Chybějící účet,
+Customers not selected.,Zákazníci nevybrali.,
+Statement of Accounts,Výpis z účtů,
+Ageing Report Based On ,Zpráva o stárnutí na základě,
+Please enter distributed cost center,Zadejte distribuované nákladové středisko,
+Total percentage allocation for distributed cost center should be equal to 100,Celková procentní alokace pro distribuované nákladové středisko by se měla rovnat 100,
+Cannot enable Distributed Cost Center for a Cost Center already allocated in another Distributed Cost Center,Nelze povolit distribuované nákladové středisko pro nákladové středisko již přidělené v jiném distribuovaném nákladovém středisku,
+Parent Cost Center cannot be added in Distributed Cost Center,Nadřazené nákladové středisko nelze přidat do distribuovaného nákladového střediska,
+A Distributed Cost Center cannot be added in the Distributed Cost Center allocation table.,Distribuované nákladové středisko nelze přidat do alokační tabulky Distribuované nákladové středisko.,
+Cost Center with enabled distributed cost center can not be converted to group,Nákladové středisko s povoleným distribuovaným nákladovým střediskem nelze převést na skupinu,
+Cost Center Already Allocated in a Distributed Cost Center cannot be converted to group,Nákladové středisko již přidělené v distribuovaném nákladovém středisku nelze převést na skupinu,
+Trial Period Start date cannot be after Subscription Start Date,Datum zahájení zkušebního období nemůže být po datu zahájení předplatného,
+Subscription End Date must be after {0} as per the subscription plan,Podle data předplatného musí být datum ukončení předplatného po {0},
+Subscription End Date is mandatory to follow calendar months,Datum ukončení předplatného je povinné pro dodržení kalendářních měsíců,
+Row #{}: POS Invoice {} is not against customer {},Řádek č. {}: POS faktura {} není proti zákazníkovi {},
+Row #{}: POS Invoice {} is not submitted yet,Řádek č. {}: POS faktura {} ještě není odeslána,
+Row #{}: POS Invoice {} has been {},Řádek č. {}: POS faktura {} byla {},
+No Supplier found for Inter Company Transactions which represents company {0},"Nebyl nalezen žádný dodavatel pro mezipodnikové transakce, který zastupuje společnost {0}",
+No Customer found for Inter Company Transactions which represents company {0},"Nebyl nalezen žádný zákazník pro mezipodnikové transakce, které představují společnost {0}",
+Invalid Period,Neplatné období,
+Selected POS Opening Entry should be open.,Vybraná položka otevření POS by měla být otevřená.,
+Invalid Opening Entry,Neplatný úvodní záznam,
+Please set a Company,Zadejte společnost,
+"Sorry, this coupon code's validity has not started","Je nám líto, platnost tohoto kódu kupónu nebyla zahájena",
+"Sorry, this coupon code's validity has expired","Je nám líto, platnost tohoto kódu kupónu vypršela",
+"Sorry, this coupon code is no longer valid","Je nám líto, tento kód kupónu již není platný",
+For the 'Apply Rule On Other' condition the field {0} is mandatory,Pro podmínku „Použít pravidlo na jiné“ je pole {0} povinné,
+{1} Not in Stock,{1} Není na skladě,
+Only {0} in Stock for item {1},Pouze {0} skladem u položky {1},
+Please enter a coupon code,Zadejte kód kupónu,
+Please enter a valid coupon code,Zadejte platný kód kupónu,
+Invalid Child Procedure,Postup při neplatném dítěti,
+Import Italian Supplier Invoice.,Importovat italskou dodavatelskou fakturu.,
+"Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.",K provádění účetních záznamů pro {1} {2} je vyžadována míra ocenění položky {0}.,
+ Here are the options to proceed:,"Zde jsou možnosti, jak pokračovat:",
+"If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.","Pokud položka v této položce probíhá jako položka s nulovou hodnotou, povolte v tabulce položky {0} položku „Povolit nulovou hodnotu.“",
+"If not, you can Cancel / Submit this entry ","Pokud ne, můžete tento záznam zrušit / odeslat",
+ performing either one below:,provedení některého z níže uvedených:,
+Create an incoming stock transaction for the Item.,Vytvořte příchozí skladovou transakci pro položku.,
+Mention Valuation Rate in the Item master.,Uveďte míru ocenění v předloze položky.,
+Valuation Rate Missing,Míra ocenění chybí,
+Serial Nos Required,Je vyžadováno sériové číslo,
+Quantity Mismatch,Neshoda množství,
+"Please Restock Items and Update the Pick List to continue. To discontinue, cancel the Pick List.","Chcete-li pokračovat, obnovte zásoby a aktualizujte výběrový seznam. Chcete-li pokračovat, zrušte výběrový seznam.",
+Out of Stock,Vyprodáno,
+{0} units of Item {1} is not available.,{0} jednotky položky {1} nejsou k dispozici.,
+Item for row {0} does not match Material Request,Položka pro řádek {0} neodpovídá požadavku na materiál,
+Warehouse for row {0} does not match Material Request,Sklad v řádku {0} neodpovídá požadavku na materiál,
+Accounting Entry for Service,Účetní záznam za službu,
+All items have already been Invoiced/Returned,Všechny položky již byly fakturovány / vráceny,
+All these items have already been Invoiced/Returned,Všechny tyto položky již byly fakturovány / vráceny,
+Stock Reconciliations,Burzovní vyrovnání,
+Merge not allowed,Sloučení není povoleno,
+The following deleted attributes exist in Variants but not in the Template. You can either delete the Variants or keep the attribute(s) in template.,"Následující odstraněné atributy existují ve variantách, ale ne v šabloně. Varianty můžete buď odstranit, nebo ponechat atributy v šabloně.",
+Variant Items,Položky variant,
+Variant Attribute Error,Chyba atributu varianty,
+The serial no {0} does not belong to item {1},Sériové číslo {0} nepatří do položky {1},
+There is no batch found against the {0}: {1},Proti {0} nebyla nalezena žádná dávka: {1},
+Completed Operation,Dokončená operace,
+Work Order Analysis,Analýza pracovního příkazu,
+Quality Inspection Analysis,Analýza kontroly kvality,
+Pending Work Order,Nevyřízená pracovní objednávka,
+Last Month Downtime Analysis,Analýza prostojů za poslední měsíc,
+Work Order Qty Analysis,Analýza množství zakázky,
+Job Card Analysis,Analýza karty práce,
+Monthly Total Work Orders,Celkový měsíční pracovní příkaz,
+Monthly Completed Work Orders,Měsíčně dokončené pracovní objednávky,
+Ongoing Job Cards,Probíhající pracovní karty,
+Monthly Quality Inspections,Měsíční kontroly kvality,
+(Forecast),(Předpověď),
+Total Demand (Past Data),Celková poptávka (minulá data),
+Total Forecast (Past Data),Celková předpověď (minulá data),
+Total Forecast (Future Data),Celková prognóza (budoucí data),
+Based On Document,Na základě dokumentu,
+Based On Data ( in years ),Na základě údajů (v letech),
+Smoothing Constant,Konstantní vyhlazování,
+Please fill the Sales Orders table,Vyplňte prosím tabulku Prodejní objednávky,
+Sales Orders Required,Požadované prodejní objednávky,
+Please fill the Material Requests table,Vyplňte prosím tabulku požadavků na materiál,
+Material Requests Required,Požadované materiály,
+Items to Manufacture are required to pull the Raw Materials associated with it.,"K výrobě surovin, které jsou s ní spojené, jsou nutné položky k výrobě.",
+Items Required,Požadované položky,
+Operation {0} does not belong to the work order {1},Operace {0} nepatří do pracovního příkazu {1},
+Print UOM after Quantity,Tisk MJ po množství,
+Set default {0} account for perpetual inventory for non stock items,U výchozích položek nastavte výchozí účet {0} pro věčný inventář,
+Loan Security {0} added multiple times,Zabezpečení půjčky {0} přidáno několikrát,
+Loan Securities with different LTV ratio cannot be pledged against one loan,Úvěrové cenné papíry s různým poměrem LTV nelze zastavit proti jedné půjčce,
+Qty or Amount is mandatory for loan security!,Množství nebo částka je pro zajištění půjčky povinné!,
+Only submittted unpledge requests can be approved,Schváleny mohou být pouze odeslané žádosti o odpojení,
+Interest Amount or Principal Amount is mandatory,Částka úroku nebo částka jistiny je povinná,
+Disbursed Amount cannot be greater than {0},Vyplacená částka nemůže být větší než {0},
+Row {0}: Loan Security {1} added multiple times,Řádek {0}: Zabezpečení půjčky {1} přidáno několikrát,
+Row #{0}: Child Item should not be a Product Bundle. Please remove Item {1} and Save,Řádek č. {0}: Podřízená položka by neměla být balíkem produktů. Odeberte prosím položku {1} a uložte ji,
+Credit limit reached for customer {0},Dosažen úvěrový limit pro zákazníka {0},
+Could not auto create Customer due to the following missing mandatory field(s):,Nelze automaticky vytvořit zákazníka kvůli následujícím chybějícím povinným polím:,
+Please create Customer from Lead {0}.,Vytvořte prosím zákazníka z Lead {0}.,
+Mandatory Missing,Povinně chybí,
+Please set Payroll based on in Payroll settings,Nastavte prosím mezd na základě v nastavení mezd,
+Additional Salary: {0} already exist for Salary Component: {1} for period {2} and {3},Další plat: {0} již pro komponentu Plat: {1} pro období {2} a {3},
+From Date can not be greater than To Date.,Od data nemůže být větší než od data.,
+Payroll date can not be less than employee's joining date.,Datum výplaty nesmí být menší než datum nástupu zaměstnance.,
+From date can not be less than employee's joining date.,Od data nesmí být menší než datum nástupu zaměstnance.,
+To date can not be greater than employee's relieving date.,K dnešnímu dni nemůže být větší než datum ulehčení zaměstnance.,
+Payroll date can not be greater than employee's relieving date.,Datum výplaty nesmí být větší než datum uvolnění zaměstnance.,
+Row #{0}: Please enter the result value for {1},Řádek č. {0}: Zadejte hodnotu výsledku pro {1},
+Mandatory Results,Povinné výsledky,
+Sales Invoice or Patient Encounter is required to create Lab Tests,K vytvoření laboratorních testů je nutná prodejní faktura nebo setkání pacientů,
+Insufficient Data,Nedostatečné údaje,
+Lab Test(s) {0} created successfully,Laboratorní testy {0} byly úspěšně vytvořeny,
+Test :,Test :,
+Sample Collection {0} has been created,Byla vytvořena kolekce vzorků {0},
+Normal Range: ,Normální vzdálenost:,
+Row #{0}: Check Out datetime cannot be less than Check In datetime,Řádek č. {0}: Datum odhlášení nemůže být menší než datum odbavení,
+"Missing required details, did not create Inpatient Record","Chybějící požadované podrobnosti, nevytvořil záznam o hospitalizaci",
+Unbilled Invoices,Nevyfakturované faktury,
+Standard Selling Rate should be greater than zero.,Standardní prodejní sazba by měla být větší než nula.,
+Conversion Factor is mandatory,Konverzní faktor je povinný,
+Row #{0}: Conversion Factor is mandatory,Řádek č. {0}: Konverzní faktor je povinný,
+Sample Quantity cannot be negative or 0,Množství vzorku nesmí být záporné nebo 0,
+Invalid Quantity,Neplatné množství,
+"Please set defaults for Customer Group, Territory and Selling Price List in Selling Settings","V nastavení prodeje prosím nastavte výchozí hodnoty pro skupinu zákazníků, teritorium a ceník prodeje",
+{0} on {1},{0} dne {1},
+{0} with {1},{0} s {1},
+Appointment Confirmation Message Not Sent,Zpráva o potvrzení schůzky nebyla odeslána,
+"SMS not sent, please check SMS Settings","SMS nebyla odeslána, zkontrolujte nastavení SMS",
+Healthcare Service Unit Type cannot have both {0} and {1},Typ jednotky zdravotní péče nemůže mít {0} i {1},
+Healthcare Service Unit Type must allow atleast one among {0} and {1},Typ jednotky zdravotní péče musí umožňovat alespoň jednu z {0} a {1},
+Set Response Time and Resolution Time for Priority {0} in row {1}.,Nastavte čas odezvy a čas rozlišení pro prioritu {0} v řádku {1}.,
+Response Time for {0} priority in row {1} can't be greater than Resolution Time.,Doba odezvy pro {0} prioritu v řádku {1} nesmí být větší než doba rozlišení.,
+{0} is not enabled in {1},{0} není povolen v {1},
+Group by Material Request,Seskupit podle požadavku na materiál,
+"Row {0}: For Supplier {0}, Email Address is Required to Send Email",Řádek {0}: U dodavatele {0} je pro odesílání e-mailů vyžadována e-mailová adresa,
+Email Sent to Supplier {0},E-mail odeslaný dodavateli {0},
+"The Access to Request for Quotation From Portal is Disabled. To Allow Access, Enable it in Portal Settings.","Přístup k žádosti o nabídku z portálu je zakázán. Chcete-li povolit přístup, povolte jej v nastavení portálu.",
+Supplier Quotation {0} Created,Nabídka dodavatele {0} vytvořena,
+Valid till Date cannot be before Transaction Date,Platnost do data nemůže být před datem transakce,
