apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Penzijní fondy
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Úprava zaokrouhlování (měna společnosti
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Kurz je povinný v řádku {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Úvěrový účet
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum podání
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Změnit kód šablony
DocType: Expense Claim,Total Sanctioned Amount,Celková sankční částka
DocType: Email Digest,New Expenses,Nové náklady
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Praktický lékař není k dispozici v {0}
DocType: Delivery Note,Transport Receipt No,Dopravní doklad č
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,úředník
DocType: Opportunity,Probability (%),Pravděpodobnost (%)
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Produkty WooCommerce
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Pouze platební účet
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit výchozí hodnoty jako společnost, měna, aktuální fiskální rok atd."
apps/erpnext/erpnext/config/projects.py,Time Tracking,Sledování času
DocType: Employee Education,Under Graduate,Pod absolventem
DocType: Request for Quotation Item,Supplier Part No,Číslo dílu dodavatele
DocType: Journal Entry Account,Party Balance,Party Balance
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Zdroj finančních prostředků (závazky)
DocType: Payroll Period,Taxable Salary Slabs,Zdanitelné platové tabulky
DocType: Quality Action,Quality Feedback,Kvalitní zpětná vazba
DocType: Support Settings,Support Settings,Nastavení podpory
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Nejprve zadejte výrobní položku
DocType: Quiz,Grading Basis,Třídění základů
DocType: Stock Entry Detail,Basic Amount,Základní částka
DocType: Journal Entry,Pay To / Recd From,Zaplatit / Odhlásit
DocType: BOM,Scrap Material Cost,Náklady na šrot
DocType: Material Request Item,Received Quantity,Přijaté množství
,Sales Person-wise Transaction Summary,Shrnutí transakce s osobními obraty
DocType: Work Order,Actual Operating Cost,Skutečné provozní náklady
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Způsob platby
DocType: Stock Entry,Send to Subcontractor,Odeslat subdodavateli
DocType: Purchase Invoice,Select Shipping Address,Vyberte možnost Přepravní adresa
DocType: Student,AB-,AB-
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Shrnutí projektu pro {0}
apps/erpnext/erpnext/regional/india/bank_remittance.py,"{0} is mandatory for generating remittance payments, set the field and try again","{0} je povinné pro generování plateb, nastavte pole a zkuste to znovu"
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Některé e-maily jsou neplatné
DocType: Asset,Calculate Depreciation,Vypočítat odpisy
DocType: Academic Term,Term Name,Termín Název
DocType: Question,Question,Otázka
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podkategorie výjimek
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Více informací
DocType: Salary Component,Earning,Vydělávat
DocType: Restaurant Order Entry,Click Enter To Add,Klepněte na tlačítko Enter To Add
DocType: Employee Group,Employee Group,Zaměstnanecká skupina
DocType: Quality Procedure,Processes,Procesy
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Určete směnný kurz pro převod jedné měny na jinou
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Rozsah stárnutí 4
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Sklad je vyžadován Skladem Položka {0}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Funkci skóre skóre nelze vyřešit pro {0}. Ujistěte se, že vzorec je platný."
DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnout odsouhlasené položky
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povolit hodnotu Zero Valuation Rate
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,"Nic víc, co by se dalo ukázat."
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Kategorie daně byla změněna na &quot;Celkem&quot;, protože všechny položky nejsou skladem"
DocType: Salary Detail,Tax on flexible benefit,Daň z flexibilní dávky
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,To je založeno na časových listech vytvořených proti tomuto projektu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Kupní kurz
DocType: Water Analysis,Type of Sample,Typ vzorku
DocType: Budget,Budget Accounts,Rozpočtové účty
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Sériové číslo {0} množství {1} nemůže být zlomkem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Sklad V Ruce
DocType: Workstation,Wages,Mzdy
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Nebyl nalezen záznam o dovolené pro zaměstnance {0} for {1}
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Účet pohledávek nezaplacený účet
DocType: GST Account,SGST Account,Účet SGST
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Poloviční den by měl být mezi prací od data a koncem práce
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Platí pro případ nástupu zaměstnance
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},Specifikovaný kusovník {0} pro položku {1} neexistuje
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Společnost (nikoli zákazník nebo dodavatel) velitel.
DocType: Shopify Settings,Sales Invoice Series,Řada prodejních faktur
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Byl vytvořen záznam pohybu aktiv {0}
DocType: Lab Prescription,Test Created,Test vytvořen
DocType: Academic Term,Term Start Date,Termín Datum zahájení
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Schůzka {0} a prodejní faktura {1} byla zrušena
DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Vaše emailová adresa...
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Include Default Book Entries,Zahrnout výchozí položky knihy
DocType: Activity Cost,Activity Type,Aktivní typ
DocType: Purchase Invoice,Get Advances Paid,Zaplacené zálohy
DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / ztráta z prodeje aktiv
DocType: GL Entry,Voucher No,Poukaz č
DocType: Item,Reorder level based on Warehouse,Úroveň pořadí na základě skladu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavený pracovní příkaz nelze zrušit, nejprve jej zrušíte"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériová čísla potřebná pro položku {1}. Poskytli jste {2}.
DocType: Customer,Customer Primary Contact,Primární kontakt zákazníka
DocType: Purchase Order Item Supplied,BOM Detail No,Detail kusovníku č
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Peníze v hotovosti
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Dovolená na {0} není mezi Od data a do data
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Lead must be set if Opportunity is made from Lead,"Olovo musí být nastaveno, pokud je možnost Olovo vyrobena"
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Účet s existující transakcí nelze převést na skupinu.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Časový rozvrh {0} je již dokončen nebo zrušen
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Standardní smluvní podmínky, které mohou být přidány do prodeje a nákupu. Příklady: 1. Platnost nabídky. 1. Platební podmínky (v Advance, On Credit, part advance atd.). 1. Co je extra (nebo splatné zákazníkem). 1. Varování týkající se bezpečnosti / použití. 1. Záruka, pokud existuje. 1. Vrací zásady. 1. Podmínky přepravy, pokud existují. 1. Způsoby řešení sporů, odškodnění, odpovědnosti atd. 1. Adresa a kontakt Vaší společnosti."
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Opustit oznámení o stavu
DocType: Designation Skill,Designation Skill,Označení Skill
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Množství požadované pro položku {0} v řádku {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Strany, vyberte nejprve Typ strany"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Struktura platu pro zaměstnance {0} nebyla zadána v daný den {1}
DocType: Prescription Duration,Number,Číslo
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina založená na kurzu pro každou dávku
DocType: Healthcare Settings,Require Lab Test Approval,Vyžadovat schválení laboratorního testu
DocType: Bank Reconciliation,Update Clearance Date,Datum aktualizace
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Importovat graf účtů ze souboru csv
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Support for public app is deprecated. Please setup private app, for more details refer user manual","Podpora veřejné aplikace je zastaralá. Prosím, nastavte soukromou aplikaci, pro více informací viz uživatelská příručka"
DocType: Contract,Signed,Podepsaný
DocType: Purchase Invoice,Terms and Conditions1,Smluvní podmínky1
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Nejdříve vyberte prosím záznam zaměstnance.
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Zásady hesla pro výplaty platů nejsou nastaveny
DocType: Assessment Result Tool,Result HTML,Výsledek HTML
DocType: Agriculture Task,Ignore holidays,Ignorovat svátky
DocType: Linked Soil Texture,Linked Soil Texture,Textura propojené půdy
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,To je založeno na protokolech proti tomuto vozidlu. Podrobnosti naleznete v níže uvedené časové ose
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Employee,Emergency Contact,Nouzový kontakt
DocType: QuickBooks Migrator,Authorization URL,Autorizační adresa URL
DocType: Attendance,On Leave,Na odchodu
DocType: Item,Show a slideshow at the top of the page,Zobrazit prezentaci v horní části stránky
DocType: Cheque Print Template,Payer Settings,Nastavení plátce
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Nastavit daňové pravidlo pro nákupní košík
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,Ve výrobě
DocType: Payment Entry,Payment References,Platební odkazy
DocType: Fee Validity,Valid Till,Platný do
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Od {0} typu {1}
DocType: Request for Quotation Item,Project Name,název projektu
DocType: Purchase Invoice Item,Stock Qty,Sklad
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Dětská položka by neměla být produktovým balíčkem. Odstraňte prosím položku &quot;{0}&quot; a uložte ji
DocType: Support Search Source,Response Result Key Path,Cesta klíče odpovědi Výsledek
DocType: Travel Request,Fully Sponsored,Plně sponzorováno
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Nepovoleno. Zakázat typ jednotky služby
DocType: POS Profile,Offline POS Settings,Nastavení offline POS
DocType: Supplier Scorecard Period,Calculations,Výpočty
DocType: Production Plan,Material Requested,Požadovaný materiál
DocType: Payment Reconciliation Payment,Reference Row,Referenční řádek
DocType: Leave Policy Detail,Annual Allocation,Roční přidělení
DocType: Buying Settings,Subcontract,Subdodávky
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Poplatky typu oceňování nelze označit jako inkluzivní
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Rodičovský účet {1} nepatří společnosti: {2}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Přihlášení selhalo
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Položky a ceny
DocType: Payment Terms Template,Payment Terms Template,Šablona platebních podmínek
DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
DocType: Assessment Plan,Program,Program
DocType: Antibiotic,Healthcare,Zdravotní péče
DocType: Complaint,Complaint,Stížnost
DocType: Shipping Rule,Restrict to Countries,Omezit na země
DocType: Hub Tracked Item,Item Manager,Správce položek
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Měna závěrečného účtu musí být {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Rozpočty
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Položka otevírací faktury
DocType: Work Order,Plan material for sub-assemblies,Plán materiálu pro dílčí sestavy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Hardware
DocType: Budget,Action if Annual Budget Exceeded on MR,Akce v případě překročení ročního rozpočtu na MR
DocType: Sales Invoice Advance,Advance Amount,Předběžná částka
DocType: Accounting Dimension,Dimension Name,Název dimenze
DocType: Delivery Note Item,Against Sales Invoice Item,Proti položce prodejní faktury
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
DocType: BOM Explosion Item,Include Item In Manufacturing,Zahrnout položku do výroby
DocType: Item Reorder,Check in (group),Přihlášení (skupina)
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Nezobrazovat žádný symbol jako $ atd. Vedle měn.
DocType: Additional Salary,Salary Component Type,Typ složky mzdy
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Akcionář do této společnosti nepatří
DocType: Payment Term,Day(s) after the end of the invoice month,Den (y) po skončení fakturačního měsíce
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Typ vozidla
DocType: Antibiotic,Healthcare Administrator,Správce zdravotnictví
DocType: Tax Withholding Rate,Single Transaction Threshold,Mezní hodnota jedné transakce
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Vysílání
DocType: Support Search Source,Post Title Key,Klíč titulku
DocType: Customer,Customer Primary Address,Primární adresa zákazníka
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Vyberte dávky pro dávkovou položku
DocType: Pricing Rule,Min Qty,Min
DocType: Payment Entry,Payment Deductions or Loss,Srážky nebo ztráty z plateb
DocType: Purchase Taxes and Charges,On Item Quantity,Na položce Množství
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Nahraďte kusovník a aktualizujte nejnovější cenu ve všech kusovnících
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Musí být nastaveno datum zahájení zkušebního období i datum ukončení zkušebního období
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Žádné časové listy
DocType: Bank Statement Settings,Statement Header Mapping,Mapování záhlaví výpisu
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Half Day
DocType: Stock Entry,Material Transfer for Manufacture,Převod materiálu pro výrobu
DocType: Supplier,Block Supplier,Blokovat dodavatele
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Zadejte adresu URL serveru Woocommerce
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Od místa
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Nebyly nalezeny žádné kontakty s ID e-mailu.
DocType: Clinical Procedure,Consumption Invoiced,Fakturovaná spotřeba
DocType: Bin,Requested Quantity,Požadované množství
DocType: Student,Exit,Výstup
DocType: Delivery Stop,Dispatch Information,Informace o odeslání
DocType: BOM Scrap Item,Basic Amount (Company Currency),Základní částka (měna společnosti)
DocType: Selling Settings,Selling Settings,Prodejní nastavení
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Otázka musí mít více možností
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Nastavte prosím datum vstupu pro zaměstnance {0}
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your company,O vaší společnosti
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Fiskální rok {0} neexistuje
DocType: Attendance,Leave Application,Opustit aplikaci
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Protokol údržby
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Neplatný čas účtování
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Sleva
DocType: Sales Invoice,Redeem Loyalty Points,Uplatnit věrnostní body
DocType: Shopping Cart Settings,Quotation Series,Série nabídky
DocType: Guardian,Occupation,obsazení
DocType: Item,Opening Stock,Otevření skladu
DocType: Supplier Scorecard,Supplier Score,Skóre dodavatele
DocType: POS Profile,Only show Items from these Item Groups,Zobrazovat pouze položky z těchto skupin položek
DocType: Job Card Time Log,Time In Mins,Čas V Minách
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Položka {0} neexistuje v systému nebo vypršela platnost
DocType: Pricing Rule,Price Discount Scheme,Cenová sleva
DocType: Vital Signs,Hyper,Hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Co to dělá?
,Sales Invoice Trends,Trendy prodejní faktury
DocType: Bank Reconciliation,Payment Entries,Platební položky
DocType: Employee Education,Class / Percentage,Třída / Procenta
,Electronic Invoice Register,Elektronický registr faktur
DocType: Sales Invoice,Is Return (Credit Note),Is Return (Credit Note)
DocType: Lab Test Sample,Lab Test Sample,Vzorek laboratorního testu
DocType: Shopify Settings,status html,status html
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např. 2012, 2012-13"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,zdravotně postiženého uživatele
DocType: Amazon MWS Settings,ES,ES
DocType: Warehouse,Warehouse Type,Typ skladu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Rychlý záznam deníku
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Spotřebovaná částka
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Already completed,Již dokončeno
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Čeká na vyřízení
DocType: Supplier,Warn RFQs,Varovat RFQs
DocType: Lab Prescription,Lab Prescription,Laboratorní předpis
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Řádek odpisů {0}: Další datum odpisu nemůže být před datem k dispozici
DocType: Certification Application,USD,americký dolar
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Účet {0} nelze zrušit, protože je již {1}"
DocType: Delivery Trip,Departure Time,Čas odjezdu
DocType: Donor,Donor Type,Typ dárce
DocType: Company,Monthly Sales Target,Měsíční prodejní cíl
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum odkupu
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejný jako uživatel
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Poplatek Rozvrh Studentská skupina
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Od Datum nemůže být větší než Datum
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Zadejte prosím číslo {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Na GSTIN
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Datum ukončení nemůže být dřívější než datum zahájení. Opravte data a zkuste to znovu.
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No Employee Found,Nebyl nalezen žádný zaměstnanec
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorie výjimek
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Vytvořit položku Výplata
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Účel musí být {0}
DocType: Content Activity,Last Activity ,poslední aktivita
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,"Odkaz na všechna umístění, ve kterých rostou plodiny"
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Kurz Zápis {0} neexistuje
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Maximální dovolená dovolená v typu dovolené {0} je {1}
,Qty to Transfer,Množství k převodu
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Identifikujte / vytvořte účet (skupina) pro typ - {0}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,Nastavte výchozí skupinu zákazníků a území v části Nastavení prodeje
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Pro vybranou položku neexistuje žádná varianta položky
DocType: Contract,Contract Details,Podrobnosti smlouvy
DocType: Customer,"Select, to make the customer searchable with these fields","Vyberte, chcete-li, aby byl zákazník vyhledávatelný pomocí těchto polí"
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Celkem Skutečně
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Změnit kód
DocType: Crop,Planting Area,Plocha výsadby
DocType: Leave Control Panel,Employee Grade (optional),Zaměstnanecký stupeň (volitelné)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Nákladové středisko pro položku s kódem položky
DocType: Stock Settings,Default Stock UOM,Výchozí skladem UOM
DocType: Workstation,Rent Cost,Náklady na pronájem
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Výsledek školení
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Pracovní příkaz nebyl vytvořen
apps/erpnext/erpnext/utilities/user_progress.py,Meter,Metr
DocType: Course,Hero Image,Obrázek hrdiny
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Žádné položky k balení
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Dodací sklad pro skladovou položku {0}
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Vyhrazený sklad je povinný pro položku {0} v dodaných surovinách
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Pro objekt {0} je vyžadováno cílové umístění
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,SGST Částka
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek účtu je již v kreditu, není povoleno nastavit &#39;zůstatek musí být&#39; jako &#39;debet&#39;"
DocType: GSTR 3B Report,GSTR 3B Report,Zpráva GSTR 3B
DocType: BOM Item,Rate & Amount,Sazba &amp; Částka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Vyžaduje se debet
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Item Name,Název položky
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Náklady na nový nákup
DocType: Customer,Additional information regarding the customer.,Další informace týkající se zákazníka.
DocType: Quiz Result,Wrong,Špatně
apps/erpnext/erpnext/config/help.py,Batch Inventory,Dávková inventura
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Mzdový lístek zasílaný zaměstnanci bude chráněn heslem, heslo bude vygenerováno na základě zásady pro heslo."
DocType: Payment Entry,Received Amount,Přijatá částka
DocType: Item,Is Sales Item,Je prodejní položka
apps/erpnext/erpnext/accounts/doctype/payment_order/regional/india.js,Generate Text File,Generovat textový soubor
DocType: Item,Variants,Varianty
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozdělovány úměrně podle položky qty nebo částky, podle vašeho výběru"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,Probíhající aktivity pro dnešek
DocType: Quality Procedure Process,Quality Procedure Process,Proces kvality
DocType: Fee Schedule Program,Student Batch,Studentská dávka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item in row {0},Míra ocenění požadovaná pro položku v řádku {0}
DocType: BOM Operation,Base Hour Rate(Company Currency),Základní hodinová sazba (měna společnosti)
DocType: Job Offer,Printing Details,Podrobnosti o tisku
DocType: Asset Repair,Manufacturing Manager,Manažer výroby
DocType: BOM,Job Card,Karta zaměstnání
DocType: Subscription Settings,Prorate,Prorate
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","ID uživatele systému (přihlášení). Pokud je nastaveno, stane se výchozím pro všechny formuláře HR."
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Všechny skupiny položek
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Vyberte Stav
DocType: Subscription Plan,Fixed rate,Fixní sazba
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Letecká linka
DocType: Quotation,Term Details,Termín Podrobnosti
DocType: Vehicle,Acquisition Date,Datum akvizice
DocType: SMS Center,Send To,Poslat komu
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Průměrné hodnocení
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavte počet v transakcích založených na sériovém vstupu
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Měna zálohového účtu by měla být stejná jako měna společnosti {0}
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Upravit sekce domovské stránky
DocType: GSTR 3B Report,October,říjen
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Skrýt daňové identifikační číslo zákazníka z prodejních transakcí
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,Neplatný GSTIN! GSTIN musí mít 15 znaků.
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Pravidlo cen {0} je aktualizováno
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolní seznam plnění smlouvy
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Všechny produkty
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Vyhledávání produktů
DocType: Salary Slip,Net Pay,Čistá mzda
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Invoiced Amt,Celkový fakturovaný Amt
DocType: Clinical Procedure,Consumables Invoice Separately,Fakturace spotřebního materiálu odděleně
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Rozpočet nelze přiřadit k účtu skupiny {0}
DocType: Purchase Receipt Item,Rate and Amount,Sazba a částka
DocType: Patient Appointment,Check availability,Zkontrolujte dostupnost
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Položka s tímto čárovým kódem nelze najít
DocType: Hotel Settings,Default Invoice Naming Series,Výchozí řada pojmenování faktur
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} quantities of the item <b>{2}</b>, the scheme <b>{3}</b>
			will be applied on the item.","Pokud {0} {1} množství položky <b>{2}</b> , bude na položku použito schéma <b>{3}</b> ."
DocType: Student Siblings,Student Siblings,Student sourozenci
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Položka žurnálu {0} nemá účet {1} nebo již nebyl porovnán s jiným dokladem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Právní náklady
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Překontrolovat
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Podrobnosti o členství
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Nastavte adresu zákazníka
apps/erpnext/erpnext/utilities/user_progress.py,List your products or services that you buy or sell.,"Seznam produktů nebo služeb, které si koupíte nebo prodáte."
DocType: Account,Income,Příjem
DocType: Account,Rate at which this tax is applied,"Sazba, za kterou se tato daň uplatňuje"
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Poznámka o přijetí platby
DocType: Asset Finance Book,In Percentage,V procentech
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Citace od dodavatelů.
DocType: Journal Entry Account,Reference Due Date,Datum splatnosti reference
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Dny vedoucího času
DocType: Quality Goal,Revision and Revised On,Revize a revize dne
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} proti objednávce {1}
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Záznamy o poplatcích vytvořené - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Poznámka: {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Sériové číslo {0} již bylo přijato
DocType: HR Settings,Leave Settings,Opustit nastavení
DocType: Delivery Note,Issue Credit Note,Poznámka k emisi
,Batch Item Expiry Status,Stav vypršení dávky
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Akciové transakce
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Místo konání akce
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Film a video
DocType: Crop,Row Spacing,Řádkování
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Číslo účtu pro účet {0} není k dispozici. <br> Nastavte prosím svůj účet účtů správně.
DocType: Cheque Print Template,Starting location from left edge,Výchozí umístění od levého okraje
DocType: HR Settings,HR Settings,Nastavení HR
DocType: Healthcare Practitioner,Appointments,Jmenování
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Bylo vytvořeno {0}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Zadejte plánovaný počet pro položku {0} v řádku {1}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Vyberte položku Dávka
DocType: BOM,Item Description,Popis položky
DocType: Account,Account Name,Jméno účtu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Zadejte prosím spotřebitelský klíč API
DocType: Products Settings,Products per Page,Produkty na stránku
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Duplikát {0} naleznete v tabulce
DocType: Global Defaults,Default Distance Unit,Výchozí jednotka vzdálenosti
DocType: Clinical Procedure,Consume Stock,Konzumujte zásoby
DocType: Appraisal Template Goal,Key Performance Area,Klíčová oblast výkonu
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,Takže ne.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for item {1},{0} nebyl nalezen pro položku {1}
DocType: Sales Invoice,Set Source Warehouse,Nastavit zdrojový sklad
DocType: Healthcare Settings,Out Patient Settings,Out Patient Settings
DocType: Asset,Insurance End Date,Datum ukončení pojištění
DocType: Bank Account,Branch Code,Kód pobočky
apps/erpnext/erpnext/support/doctype/issue/issue.js,Time To Respond,Čas reagovat
apps/erpnext/erpnext/public/js/conf.js,User Forum,Uživatelské fórum
DocType: Landed Cost Item,Landed Cost Item,Položka nákladových nákladů
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Prodávající a kupující nemohou být stejní
DocType: Project,Copied From,Zkopírováno z
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Dostupný
DocType: Sales Person,Sales Person Targets,Cíle prodejní osoby
DocType: BOM Operation,BOM Operation,Ovládání kusovníku
DocType: Student,O-,Ó-
DocType: Repayment Schedule,Interest Amount,Úroková částka
DocType: Water Analysis,Origin,Původ
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,přidat novou adresu
DocType: POS Profile,Write Off Account,Zapsat účet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Nabídka nabídky / ceny
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Spolupracovník
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Zadejte všechny požadované hodnoty výsledků
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodaná položka objednávky
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Položka {0} není serializovaná položka
DocType: GoCardless Mandate,GoCardless Customer,Zákazník GoCardless
DocType: Leave Encashment,Leave Balance,Nechte zůstatek
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje proti {1}
DocType: Assessment Plan,Supervisor Name,Jméno supervizora
DocType: Selling Settings,Campaign Naming By,Pojmenování podle kampaně
DocType: Student Group Creation Tool Course,Course Code,Kód kurzu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Letectví a kosmonautika
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatky založené na
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kritéria hodnocení skóre dodavatele
DocType: Account,Stock,Skladem
DocType: Landed Cost Item,Receipt Document Type,Typ dokladu
DocType: Territory,Classification of Customers by region,Klasifikace zákazníků podle krajů
DocType: Hotel Room Amenity,Billable,Zúčtovatelné
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Vláda
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Vytvořte záznamy o zaměstnancích pro správu listů, nároků na výdaje a výplatních listů"
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Místě prodeje
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Uživatel {0} je již přiřazen k programu Healthcare Practitioner {1}
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Standardní nákup
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Učeň
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Přidat časové rozvrhy
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix","Číslo nového účtu, které bude zahrnuto do názvu účtu jako předpona"
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatelský sklad je povinen pro subdodavatelský nákupní doklad
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Zadejte preferovaný kontaktní e-mail
DocType: Vital Signs,Normal,Normální
DocType: Customer,Customer POS Id,ID zákazníka POS
DocType: Purchase Invoice Item,Weight Per Unit,Hmotnost na jednotku
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Podřízené uzly lze vytvořit pouze pod uzly typu „Skupina“
DocType: Share Transfer,(including),(počítaje v to)
,Requested,Požadováno
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Položka {0} není skladem Položka
DocType: Journal Entry,Multi Currency,Více měn
DocType: Payment Entry,Write Off Difference Amount,Odchylka rozdílu
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Položka {0} je zakázána
DocType: Asset Maintenance Task,Last Completion Date,Datum posledního dokončení
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Splnění
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Úkol byl zařazen jako práce na pozadí. V případě, že dojde k nějakému problému se zpracováním v pozadí, systém přidá komentář k chybě v tomto odsouhlasení zásob a vrátí se do fáze Koncept."
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Zvažovaná celková objednávka
DocType: Delivery Trip,Optimize Route,Optimalizace trasy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Discount Percentage can be applied either against a Price List or for all Price List.,"Procento slevy lze uplatnit buď proti ceníku, nebo pro všechny ceníky."
DocType: Training Event,Trainer Email,E-mail trenéra
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Dostaňte se od pacientského setkání
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Vývojář softwaru
DocType: Clinical Procedure Template,Sample Collection,Kolekce vzorků
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Sdělte nám svůj názor na školení kliknutím na odkaz „Zpětná vazba školení“ a poté na možnost „Nová“.
DocType: QuickBooks Migrator,Connecting to QuickBooks,Připojení k QuickBooks
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Zápis studenta
DocType: Employee Advance,Claimed,Tvrdil
apps/erpnext/erpnext/config/hr.py,Leaves,Listy
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Rozpad platů založený na výdělku a odpočtu.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Chybí struktura mzdy
DocType: Setup Progress Action,Action Field,Pole Akce
,Quotation Trends,Trendy nabídky
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Připojte Amazon s ERPNext
DocType: Service Level Agreement,Response and Resolution Time,Reakce a doba rozlišení
DocType: Loyalty Program,Collection Tier,Kolekce Tier
DocType: Guardian,Guardian Of ,Strážce
DocType: Payment Request,Payment Gateway Details,Detaily platební brány
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Personální plán {0} již existuje pro označení {1}
DocType: Item,Website Warehouse,Webové stránky skladu
DocType: Sales Invoice Item,Rate With Margin,Sazba s marží
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Mzdová struktura musí být předložena před podáním prohlášení o daňovém osvobození
apps/erpnext/erpnext/public/js/event.js,Add Leads,Přidat vede
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Rezervační sklad
DocType: Payment Term,Payment Term Name,Název termínu platby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Bez povolení
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Vybrat společnost ...
DocType: Stock Settings,Use Naming Series,Použijte pomenování Series
DocType: Salary Component,Formula,Vzorec
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,"Akce v případě, že kumulovaný měsíční rozpočet překročil skutečnou hodnotu"
DocType: Leave Type,Allow Encashment,Povolit započtení
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Činnost projektu / úkol.
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Položka fakturace bankovního výpisu
DocType: Work Order,Total Operating Cost,Celkové provozní náklady
DocType: Employee Onboarding,Employee Onboarding Template,Zaměstnanec palubní šablona
DocType: Pricing Rule,Same Item,Stejná položka
apps/erpnext/erpnext/regional/india/bank_remittance.py,"Amount for a single transaction exceeds maximum allowed amount, create a separate payment order by splitting the transactions","Částka za jednu transakci přesahuje maximální povolenou částku, vytvořením samostatného platebního příkazu rozdělením transakcí"
DocType: Payroll Entry,Salary Slips Created,Vytvořily se výplatní pásy
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Laboratorní testy
DocType: Payment Request,Party Details,Podrobnosti o straně
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Náklady na zakoupené položky
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,Veškerá komunikace včetně a nad ní bude přesunuta do nového vydání
DocType: Stock Entry,Material Consumption for Manufacture,Spotřeba materiálu pro výrobu
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabulka pro položku, která bude zobrazena na webu"
DocType: Restaurant Menu,Restaurant Menu,Restaurace Menu
DocType: Asset Movement,Purpose,Účel
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Přidělení mzdové struktury pro zaměstnance již existuje
DocType: Clinical Procedure,Service Unit,Servisní jednotka
DocType: Travel Request,Identification Document Number,identifikační číslo dokumentu
DocType: Stock Entry,Additional Costs,Další výdaje
DocType: Employee Education,Employee Education,Vzdělávání zaměstnanců
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Number of positions cannot be less then current count of employees,Počet míst nemůže být menší než současný počet zaměstnanců
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Všechny skupiny zákazníků
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Nákup Ceník
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Dokončený kód dobré položky
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Pro datum {0} existuje více fiskálních let. Nastavte prosím společnost ve fiskálním roce
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Vyžaduje se datum použitelnosti
DocType: Employee Training,Training Date,Datum školení
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čtení nahraného souboru
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Požadavek na materiál
DocType: Payment Entry,Total Allocated Amount (Company Currency),Celková přidělená částka (měna společnosti)
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Položka objednávky restaurace
DocType: Delivery Stop,Distance,Vzdálenost
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Získejte finanční rozložení údajů o daních a poplatcích společností Amazon
DocType: Vehicle Service,Mileage,Tachometr
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",U položky {0} musí být množství kladné číslo
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Položka Košík
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Platební položky {0} jsou un-linked
DocType: Email Digest,Open Notifications,Otevřete Oznámení
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Úspěšně vytvořené položky platby
DocType: Soil Analysis,Mg/K,Mg / K
DocType: Item,Has Serial No,Má sériové číslo
DocType: Asset Maintenance,Manufacturing User,Výrobní uživatel
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,účetní kniha
DocType: Journal Entry Account,Loan,Půjčka
DocType: Vehicle,Fuel UOM,Palivo UOM
DocType: Issue,Support,"Podpěra, podpora"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Neplatná společnost pro transakce mezi společnostmi.
DocType: Company,Fixed Asset Depreciation Settings,Nastavení odpisů fixních aktiv
DocType: Employee,Department and Grade,Oddělení a stupeň
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Požadované kontroly
DocType: Lead,Do Not Contact,Neodpovídejte
DocType: Sales Invoice,Update Billed Amount in Sales Order,Aktualizace fakturované částky v zakázce odběratele
DocType: Travel Itinerary,Meal Preference,Preference jídla
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidel pro stanovení cen s nejvyšší prioritou, použijí se následující interní priority:"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Seznam všech transakcí s akciemi
DocType: Item Default,Sales Defaults,Výchozí hodnoty prodeje
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Překrývání v bodování {0} a {1}
DocType: Course Assessment Criteria,Weightage,Váha
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Vytvořit novou platbu / záznam deníku
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Pokud se na základě výše uvedených podmínek zjistí dvě nebo více cenových pravidel, použije se priorita. Priorita je číslo mezi 0 až 20, zatímco výchozí hodnota je nula (prázdná). Vyšší číslo znamená, že bude mít přednost v případě, že budou existovat vícenásobná pravidla pro stanovení ceny za stejných podmínek."
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Řádek {0}: Množství je povinné
DocType: Sales Invoice,Against Income Account,Proti účtu příjmů
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Řádek # {0}: Fakturu nelze provést proti existujícímu majetku {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Pravidla pro používání různých propagačních programů.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},Koeficient konverze UOM požadovaný pro UOM: {0} v položce: {1}
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Zadejte množství pro položku {0}
DocType: Workstation,Electricity Cost,Náklady na elektřinu
DocType: Vehicle Service,Vehicle Service,Servis vozidel
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Vytváření skladových položek
DocType: Bank Guarantee,Fixed Deposit Number,Fixní vkladové číslo
DocType: Vital Signs,Very Coated,Velmi potažené
DocType: Delivery Trip,Initial Email Notification Sent,Původní e-mailové oznámení bylo odesláno
DocType: Production Plan,For Warehouse,Pro sklad
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: Email zaměstnance nebyl nalezen, proto e-mail nebyl odeslán"
DocType: Currency Exchange,From Currency,Od měny
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Poznámka k vrácení / inkasu
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Objednávka, ve které se mají zobrazovat sekce. 0 je první, 1 je druhá a tak dále."
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,"Vytvářejte zakázky odběratelům, které vám pomohou naplánovat vaši práci a dodat čas"
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Něco se pokazilo!
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Zvolte prosím službu Zdravotnictví
DocType: Leave Application,Apply / Approve Leaves,Použít / Schválit listy
DocType: Leave Block List,Applies to Company,Platí pro společnost
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Řádek {0}: Rozpiska nebyla nalezena pro položku {1}
DocType: Loan,Account Info,Informace o účtu
DocType: Item Attribute Value,Abbreviation,Zkratka
DocType: Email Digest,Purchase Orders to Bill,Objednávky objednávejte společnosti Bill
DocType: Purchase Invoice,Total Net Weight,Celková čistá hmotnost
DocType: Authorization Rule,Approving Role (above authorized value),Schválení role (nad autorizovanou hodnotou)
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
DocType: Job Applicant,Resume Attachment,Obnovení přílohy
DocType: Agriculture Analysis Criteria,Agriculture Manager,Zemědělský manažer
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Dávkové zápisy
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Povolte prosím Platnost na Objednávku a Platí pro Rezervace skutečných nákladů
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,Zisk / ztráta z prodeje aktiv
DocType: Loan,Total Payment,Celková platba
DocType: Asset,Total Number of Depreciations,Celkový počet odpisů
DocType: Asset,Fully Depreciated,Plně odepsáno
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts,Vytváření účtů
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Nastavení varianty položky
DocType: Supplier Group,Supplier Group Name,Název skupiny dodavatelů
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Prodejní ceník
DocType: Email Digest,How frequently?,Jak často?
DocType: Purchase Invoice,Supplier Warehouse,Dodavatelský sklad
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Pouze daňový dopad (nelze nárokovat, ale část zdanitelného příjmu)"
DocType: Item Default,Purchase Defaults,Výchozí hodnoty nákupu
DocType: Contract,Contract Template,Šablona smlouvy
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Sériové číslo {0} nepatří do dávky {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Čeká na listy
DocType: Student Applicant,Applied,Aplikovaný
DocType: Clinical Procedure,Consumption Details,Podrobnosti o spotřebě
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Načítání platebního systému
DocType: Assessment Plan,Maximum Assessment Score,Maximální hodnocení
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Nastavte výchozí šablonu pro Leave Status Notification v nastavení HR.
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Karta studentské zprávy
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Příroda Dodávky
DocType: Shopify Settings,Last Sync Datetime,Poslední synchronizace dat
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kód {0} již existuje
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Na základě platebních podmínek
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Tato hodnota je aktualizována ve výchozím prodejním ceníku.
DocType: Special Test Template,Special Test Template,Speciální testovací šablona
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Vytvořit varianty
DocType: Item Default,Default Expense Account,Výchozí účet výdajů
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Nastavte prosím Studenti ve Studentských skupinách
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Zdanitelná částka
DocType: Lead,Lead Owner,Vedoucí vlastník
DocType: Share Transfer,Transfer,Převod
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Vyhledávací položka (Ctrl + i)
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0} Výsledek odeslán
DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Název nového účtu. Poznámka: Nevytvářejte účty pro zákazníky a dodavatele
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Studentská skupina nebo rozvrh kurzu je povinný
DocType: Tax Rule,Sales Tax Template,Šablona daně z prodeje
DocType: BOM,Routing,Směrování
DocType: Payment Reconciliation,Payment Reconciliation,Srovnávání plateb
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,Shoda neodpovídajících faktur a plateb.
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,Zahajovací zůstatky
DocType: Supplier,PAN,PÁNEV
DocType: Work Order,Operation Cost,Provozní náklady
DocType: Bank Guarantee,Name of Beneficiary,Jméno příjemce
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Nová adresa
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies","Dceřiné společnosti již plánují {1} volných pracovních míst s rozpočtem {2}. Personální plán pro {0} by měl přidělit více volných pracovních míst a rozpočet pro {3}, než je plánováno pro jeho dceřiné společnosti"
DocType: Stock Entry,From BOM,Z kusovníku
DocType: Program Enrollment Tool,Student Applicant,Žadatel o studium
DocType: Leave Application,Leave Balance Before Application,Nechte zůstatek před aplikací
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item,Pro vybranou položku je povinné datum vypršení platnosti
DocType: Stock Entry,Default Target Warehouse,Výchozí cílový sklad
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Zobrazit výplatní pásku
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Procentní alokace by se měla rovnat 100%
DocType: Purchase Invoice Item,UOM Conversion Factor,Faktor konverze UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Zásobu nelze aktualizovat proti Potvrzení nákupu {0}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,Položka Řádek {0}: {1} {2} neexistuje ve výše uvedené tabulce {1}
DocType: Asset Maintenance Task,2 Yearly,2 Ročně
DocType: Guardian Student,Guardian Student,Strážný student
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,Do účtu účtů přidejte účet Dočasné otevření
DocType: Account,Include in gross,Zahrnout do hrubé
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Vyberte Sériová čísla
DocType: Tally Migration,UOMs,UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Řádek {0}: strana / účet neodpovídá {1} / {2} v {3} {4}
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Neplatný odkaz {0} {1}
DocType: Quality Action,Corrective/Preventive,Korektivní / preventivní
DocType: Work Order Operation,Work In Progress,Probíhající práce
DocType: Bank Reconciliation,Account Currency,Měna účtu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,credit_note_amt,credit_note_amt
DocType: Setup Progress Action,Action Name,Název akce
DocType: Employee,Health Insurance,Zdravotní pojištění
DocType: Student Group,Max Strength,Max
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Duplicitní skupina zákazníků nalezená v tabulce skupin cutomer
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nelze uplatnit / zrušit před {0}, protože zůstatek dovolené již byl převeden v budoucím záznamu o přidělení dovolené {1}"
DocType: Promotional Scheme Price Discount,Min Amount,Min
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Sazba s marží (měna společnosti)
DocType: Lead,Follow Up,Následovat
DocType: Tax Rule,Shipping Country,Přepravní země
DocType: Delivery Note,Track this Delivery Note against any Project,Sledujte tento dodací list proti jakémukoli projektu
DocType: Company,Default Payroll Payable Account,Výchozí mzdový účet
DocType: Drug Prescription,Update Schedule,Plán aktualizace
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Updating estimated arrival times.,Aktualizace odhadovaných časů příjezdu.
DocType: Asset Category,Finance Book Detail,Detail finanční knihy
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Sériové číslo {0} nepatří k Poznámka k doručení {1}
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Nastavte ID daně pro zákazníka &#39;% s&#39;
DocType: Sales Partner,Logo,Logo
DocType: Leave Type,Include holidays within leaves as leaves,Zahrnout dovolenou do listů jako listy
DocType: Shift Assignment,Shift Request,Požadavek Shift
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Nelze označit Inpatient Record Discharged, jsou zde fakturace nevyfakturované {0}"
DocType: QuickBooks Migrator,Scope,Rozsah
DocType: Purchase Invoice Item,Service Stop Date,Datum zastavení služby
DocType: Article,Publish Date,Datum publikování
DocType: Student,O+,O +
DocType: BOM,Work Order,Zakázka
DocType: Bank Statement Transaction Settings Item,Transaction,Transakce
DocType: Workstation,per hour,za hodinu
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,Tato akce zastaví budoucí fakturaci. Opravdu chcete toto předplatné zrušit?
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Stát / UT daň
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,Scorecards
,Projected Quantity as Source,Předpokládané množství jako zdroj
DocType: Supplier Group,Parent Supplier Group,Skupina mateřských dodavatelů
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Řádky s duplicitními daty splatnosti v jiných řádcích byly nalezeny: {0}
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Šablona účtů
DocType: Lead,Lead,Vést
DocType: Appraisal Template Goal,KRA,KRA
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,Instalační program
,Salary Register,Registrace platů
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",V případě víceúrovňového programu budou Zákazníci automaticky přiřazeni k příslušné vrstvě podle vynaložených nákladů
DocType: Bank Reconciliation Detail,Posting Date,Datum zaslání
DocType: Upload Attendance,Attendance From Date,Účast od data
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,Program ve struktuře poplatků a studentské skupině {0} je odlišný.
DocType: GST Settings,GST Summary,Souhrn GST
DocType: Education Settings,Make Academic Term Mandatory,Udělejte povinný akademický termín
DocType: Vehicle,Odometer Value (Last),Hodnota počítadla kilometrů (poslední)
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Převeďte aktivum z jednoho skladu do druhého
DocType: Room,Seating Capacity,Počet míst k sezení
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Detail aplikace Zaměstnanecké výhody
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Zaměstnanec {0} již požádal o {1} mezi {2} a {3}:
DocType: Asset Category Account,Capital Work In Progress Account,Účet kapitálové práce
DocType: Employee Benefit Claim,Benefit Type and Amount,Typ výhody a částka
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},Nastavte výchozí platební účet společnosti {0}
DocType: Daily Work Summary Group,Holiday List,Seznam prázdnin
DocType: Job Card,Total Time in Mins,Celkový čas v minách
DocType: Shipping Rule,Shipping Amount,Přepravní částka
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Celkem chybí
DocType: Fee Validity,Reference Inv,Odkaz Inv
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,Řádek {0}: {1} je zapotřebí k vytvoření faktur Otevření {2}
DocType: Bank Account,Is Company Account,Je firemní účet
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Chcete upozornit všechny zákazníky e-mailem?
DocType: Opening Invoice Creation Tool,Sales,Odbyt
DocType: Vital Signs,Tongue,Jazyk
DocType: Journal Entry,Excise Entry,Vstup do spotřební daně
apps/erpnext/erpnext/www/all-products/index.html,Clear filters,Vymazat filtry
DocType: Delivery Trip,In Transit,V tranzitu
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Čárový kód {0} není platný kód {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Zůstatek pro účet {0} musí být vždy {1}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka deky pro vybraného zákazníka a položku
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Pokud je tato možnost povolena, systém vytvoří zakázku pro rozložené položky, proti kterým je rozpiska k dispozici."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Produktový balíček
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Nový směnný kurz
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Otevřít
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Seznam příjemců je prázdný. Vytvořte seznam příjemců
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Běžné závazky
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
DocType: Patient,Other Risk Factors,Ostatní rizikové faktory
DocType: Item Attribute,To Range,V rozmezí
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} použitelné po {1} pracovních dnech
DocType: Task,Task Description,Popis ulohy
DocType: Bank Account,SWIFT Number,Číslo SWIFT
DocType: Accounts Settings,Show Payment Schedule in Print,Zobrazit plán plateb v Print
DocType: Purchase Invoice,Apply Tax Withholding Amount,Žádaná částka srážkové daně
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Dodavatel Scorecard postavení
DocType: Quality Inspection Reading,Quality Inspection Reading,Čtení kontroly kvality
DocType: Healthcare Settings,Valid number of days,Platný počet dnů
DocType: Production Plan Item,material_request_item,material_request_item
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Healthcare Settings,Custom Signature in Print,Vlastní podpis v tisku
DocType: Patient Encounter,Procedures,Postupy
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,Otevřené problémy
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Série pro položku odpisu aktiv (položka deníku)
DocType: Healthcare Service Unit,Occupancy Status,Stav obsazení
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Oprávnění Privilege
DocType: Subscription,Current Invoice End Date,Aktuální datum ukončení faktury
DocType: Sample Collection,Collected Time,Shromážděný čas
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Vyberte položku BOM pro položku v řádku {0}
DocType: Department,Expense Approver,Schvalovatel výdajů
DocType: Bank Statement Transaction Entry,New Transactions,Nové transakce
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Splatná částka
DocType: SMS Center,All Supplier Contact,Kontakt na dodavatele
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Citace {0} není typu {1}
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Typ ponechání {0} není zapnutelný
DocType: Contract,Fulfilment Status,Stav plnění
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Odhlásit se z tohoto e-mailu Digest
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} vytvořeno
DocType: Water Analysis,Person Responsible,Zodpovědná osoba
DocType: Asset,Asset Category,Kategorie aktiv
DocType: Stock Settings,Limit Percent,Procentní limit
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Účty mapování peněžních toků
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Zvolte sériové číslo
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Výnos z prodeje
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Záznam nenalezen
DocType: Department,Expense Approvers,Schvalovatelé výdajů
DocType: Purchase Invoice,Group same items,Seskupte stejné položky
DocType: Company,Parent Company,Mateřská společnost
DocType: Daily Work Summary Group,Reminder,Připomínka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Kontokorentní účet
DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group","Skupina položek existuje se stejným názvem, změňte název položky nebo přejmenujte skupinu položek"
DocType: Student,B+,B +
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Následující položka {0} není označena jako položka {1}. Můžete je povolit jako položku {1} ze svého hlavního prvku položky
DocType: Healthcare Service Unit,Allow Overlap,Povolit překrytí
apps/erpnext/erpnext/controllers/item_variant.py,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Hodnota pro atribut {0} musí být v rozsahu {1} až {2} v krocích {3} pro položku {4}
DocType: Timesheet,Billing Details,Podrobnosti fakturace
DocType: Quality Procedure Table,Quality Procedure Table,Tabulka kvality
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Vytvořeno sériové číslo {0}
DocType: Warehouse,Warehouse Detail,Detail skladu
DocType: Sales Order,To Deliver and Bill,Doručit a Billa
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Přidáno k detailům
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Přidat uživatele na trh
DocType: Healthcare Settings,Remind Before,Připomenout dříve
DocType: Healthcare Settings,Manage Customer,Správa zákazníka
DocType: Loyalty Program Collection,Tier Name,Název třídy
DocType: Manufacturing Settings,Manufacturing Settings,Výrobní nastavení
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Přijata
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Vyberte položku Datum zahájení a datum ukončení položky {0}
DocType: Education Settings,Education Settings,Nastavení vzdělávání
DocType: Student Admission,Admission End Date,Datum ukončení přijetí
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} worth item <b>{2}</b>, the scheme <b>{3}</b> will be applied on the item.
				","Pokud {0} {1} stojí za položku <b>{2}</b> , bude na položku použito schéma <b>{3}</b> ."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,"Zadejte prosím společnost, kterou chcete pokračovat"
DocType: Asset Maintenance Team,Asset Maintenance Team,Tým údržby aktiv
DocType: Production Plan Material Request,Material Request Date,Datum požadavku na materiál
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Povinnosti
DocType: Project,Total Costing Amount (via Timesheets),Celková částka kalkulace (prostřednictvím výkazů)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Import položek a UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Listy za rok
DocType: Student,Date of Leaving,Datum odjezdu
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Export e-faktur
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorní SMS upozornění
DocType: Program,Is Published,Je publikováno
DocType: Clinical Procedure,Healthcare Practitioner,Zdravotnický lékař
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Položka Cena aktualizována pro {0} v ceníku {1}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Dávková položka {0} nemůže být aktualizována pomocí Sladění zásob, namísto použití položky Vstup"
DocType: Employee External Work History,Total Experience,Celková zkušenost
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Materiál pro dodavatele
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Zákazník je povinen proti účtu Pohledávky {2}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Zdravotnické služby
DocType: Grading Scale Interval,Grade Code,Kód třídy
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Schůzky a setkání pacientů
,TDS Computation Summary,Shrnutí výpočtu TDS
DocType: Shipping Rule,Shipping Rule Label,Přepravní štítek
DocType: Buying Settings,Supplier Naming By,Označení dodavatele podle
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Přijetí na {0}
DocType: Loan,Loan Details,Podrobnosti o úvěru
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Zaměstnanec {0} na půl dne dne {1}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Maximální částka osvobození od daně nesmí být vyšší než maximální výše výjimky {0} kategorie osvobození od daně {1}
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Nastavte politiku dovolené pro zaměstnance {0} v záznamu Zaměstnanec / Stupeň
DocType: Bank Reconciliation Detail,Cheque Number,Kontrolní číslo
,Prospects Engaged But Not Converted,"Vyhlídky zapojené, ale ne převedené"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Závazky z akcií
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,-Above,-Výše
DocType: Item Website Specification,Item Website Specification,Specifikace webového místa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.","Položka {0} (sériové číslo: {1}) nemůže být spotřebována tak, jak je určena k plnění objednávky odběratele {2}."
DocType: Vehicle,Electric,Elektrický
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Položka Cena se zobrazí několikrát na základě Ceníku, Dodavatele / Zákazníka, Měny, Položky, UOM, Množství a Data."
DocType: Stock Ledger Entry,Stock Ledger Entry,Položka knihy
DocType: HR Settings,Email Salary Slip to Employee,E-mail mzdy Slip na zaměstnance
DocType: Stock Entry,Delivery Note No,Dodací list č
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Přidat Timeslots
DocType: Packing Slip Item,Packing Slip Item,Balení Slip Item
DocType: Payroll Period,Standard Tax Exemption Amount,Standardní částka osvobození od daně
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Serializovaná inventura
DocType: Contract,Requires Fulfilment,Vyžaduje splnění
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Bank Statement Transaction Entry,Receivable Account,Účet pohledávek
DocType: Website Attribute,Website Attribute,Atribut webových stránek
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Zatím nebyla přidána žádná adresa.
DocType: Sales Order,Partly Billed,Částečně účtováno
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Zákazník není zapsán do žádného věrnostního programu
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Pracovní místa
DocType: Expense Claim,Approval Status,stav schválení
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Otevírací množství
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Přeskočení mzdové struktury Přiřazení pro následující zaměstnance, protože záznamy o přiřazení struktury platů již existují proti nim. {0}"
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Datum ukončení lhůty nesmí být pozdější než konec roku akademického roku, ke kterému je termín připojen (akademický rok {}). Opravte data a zkuste to znovu."
DocType: Purchase Order,% Billed,% Fakturováno
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Celková odchylka
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Problém s rozdělením
DocType: Item Default,Default Supplier,Výchozí dodavatel
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Báze
apps/erpnext/erpnext/config/accounting.py,Share Management,Správa akcií
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Sales Order {0} is not valid,Prodejní objednávka {0} není platná
DocType: Leave Control Panel,Branch (optional),Pobočka (volitelné)
DocType: Bank Reconciliation Detail,Clearance Date,Datum schválení
DocType: Supplier Scorecard Period,Criteria,Kritéria
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Zvýšení požadavku na materiál při dosažení stavu opětovné objednávky
,Campaign Efficiency,Účinnost kampaně
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vytvořit časový rozvrh
DocType: Employee,Internal Work History,Historie interní práce
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Vyberte cílový sklad
DocType: Subscription Settings,Grace Period,Období milosti
DocType: Patient,Married,Ženatý
DocType: Work Order Item,Available Qty at Source Warehouse,K dispozici ve skladu ve zdrojovém skladu
DocType: Shipping Rule Country,Shipping Rule Country,Přepravní pravidlo země
DocType: Delivery Stop,Email Sent To,Email poslán
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Spotřeba materiálu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Nic se nezmění
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Nebyl vytvořen žádný laboratorní test
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximální počet vzorků - {0} již bylo zachováno pro dávku {1} a položku {2} v dávce {3}.
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měnu společnosti, protože existují existující transakce. Chcete-li změnit výchozí měnu, musí být transakce zrušeny."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Náklady na údržbu kanceláří
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Celkový počet přidělených listů je více než maximální alokace {0} volna pro zaměstnance {1} v daném období
DocType: Stock Entry,Update Rate and Availability,Rychlost aktualizace a dostupnost
DocType: Item Variant Attribute,Item Variant Attribute,Atribut Varianta položky
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,K dispozici Batch Qty ve skladu
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Sleva (%) z Ceníkové sazby s marží
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Zkontrolujte, zda Asset vyžaduje preventivní údržbu nebo kalibraci"
DocType: Lab Test,Technician Name,Jméno technika
DocType: Lab Test Groups,Normal Range,Normální vzdálenost
DocType: Item,Total Projected Qty,Celkový předpokládaný počet
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,Boms
DocType: Work Order,Actual Start Date,Aktuální datum zahájení
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Nejsou přítomny všechny dny mezi dny žádostí o náhradní dovolenou
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,Strom finančních účtů.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Nepřímý příjem
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Rezervace hotelového pokoje
DocType: Course Scheduling Tool,Course Start Date,Datum zahájení kurzu
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Prodat
DocType: Support Search Source,Post Route String,Příkaz Řetězec trasy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Elektrický
DocType: Journal Entry,Total Debit,Celkový debet
DocType: Guardian,Guardian,Strážce
DocType: Share Transfer,Transfer Type,Typ přenosu
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Databáze potenciálních zákazníků.
DocType: Skill,Skill Name,Jméno dovednosti
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Tisk sestavy
DocType: Soil Texture,Ternary Plot,Ternární pozemek
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte položku Řada jmen pro {0} přes Nastavení&gt; Nastavení&gt; Řada názvů
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Podpora Vstupenky
DocType: Asset Category Account,Fixed Asset Account,Účet stálých aktiv
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Nejnovější
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Odeslat Plat Slip
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Rychlost pulzů dospělých je 50 až 80 úderů za minutu.
DocType: Program Enrollment Course,Program Enrollment Course,Kurz zápisu do programu
,IRS 1099,IRS 1099
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,Nastavte prosím použitou řadu.
DocType: Delivery Trip,Distance UOM,Vzdálenost UOM
DocType: Accounting Dimension,Mandatory For Balance Sheet,Povinné Pro rozvahu
DocType: Payment Entry,Total Allocated Amount,Celková přidělená částka
DocType: Sales Invoice,Get Advances Received,Získané zálohy
DocType: Student,B-,B-
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Položka Daňová částka zahrnuta v hodnotě
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Řádek {0}: Faktura {1} je neplatná, může být zrušena / neexistuje. Zadejte platnou fakturu"
DocType: Subscription Plan,Subscription Plan,Plán předplatného
DocType: Student,Blood Group,Krevní skupina
apps/erpnext/erpnext/config/healthcare.py,Masters,Mistři
DocType: Crop,Crop Spacing UOM,Mezera oříznutí UOM
apps/erpnext/erpnext/templates/pages/home.html,Explore,Prozkoumat
DocType: Promotional Scheme,Product Discount Slabs,Desky slev na výrobky
DocType: Hotel Room Package,Amenities,Vybavení
DocType: Lab Test Groups,Add Test,Přidat test
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Řádek # {0}: Nelze vrátit více než {1} pro položku {2}
DocType: Student Leave Application,Student Leave Application,Aplikace pro studentské studium
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py,Repayment amount {} should be greater than monthly interest amount {},Částka splátek {} by měla být vyšší než měsíční částka úroků {}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Položka plánu údržby
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil je nutný pro zadání POS vstupu
DocType: Education Settings,Enable LMS,Povolit LMS
DocType: POS Closing Voucher,Sales Invoices Summary,Přehled prodejních faktur
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Výhoda
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Úvěr Na účet musí být účet rozvahy
DocType: Video,Duration,Doba trvání
DocType: Lab Test Template,Descriptive,Popisný
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Zvolte prosím Ceník
DocType: Payment Reconciliation,From Invoice Date,Od data faktury
DocType: Education Settings,Validate Batch for Students in Student Group,Ověřte dávku pro studenty ve studentské skupině
DocType: Leave Policy,Leave Allocations,Opustit přidělení
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Skóre nesmí být větší než maximální skóre
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},Kusovník není zadán pro položku subdodávky {0} v řádku {1}
DocType: Item,Automatically Create New Batch,Automaticky vytvořit novou dávku
DocType: Restaurant Menu,Price List (Auto created),Ceník (Auto created)
DocType: Customer,Credit Limit and Payment Terms,Úvěrový limit a platební podmínky
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Zobrazit varianty
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Nastavte prosím „Zisk / ztráta na likvidaci majetku“ ve společnosti {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Platový lístek zaměstnance {0} již vytvořený pro časový výkaz {1}
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Časový rozvrh úkolů.
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokrouhlený celkem (měna společnosti)
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Nastavení pro výpis produktů z webových stránek
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Úspěšně Nastavit Dodavatele
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,Datum začátku smlouvy nemůže být větší než nebo rovna koncovému datu.
,Item Prices,Položka Ceny
DocType: Products Settings,Product Page,Stránka produktu
DocType: Amazon MWS Settings,Market Place ID,ID tržiště
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order has been {0},Výrobní zakázka byla {0}
DocType: Employee Benefit Application,Employee Benefit Application,Aplikace Benefit pro zaměstnance
DocType: BOM Item,Item operation,Provoz položky
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Částečně přijato
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
DocType: Employee Advance,Due Advance Amount,Nároková částka
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Celkový počet přidělených listů {0} nesmí být nižší než počet schválených listů {1} za dané období
DocType: Email Digest,New Purchase Orders,Nové objednávky
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Položka: {0} v systému neexistuje
DocType: Loan Application,Loan Info,Informace o půjčce
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Zkuste naplánovat operace na X dní předem.
DocType: Serial No,Is Cancelled,Je zrušeno
DocType: Request for Quotation,For individual supplier,Pro individuálního dodavatele
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min Množství nesmí být větší než Max
DocType: Soil Texture,Loamy Sand,Hlinitý písek
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Řádek {0}: Platba proti objednávce by měla být vždy označena jako záloha
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Příklad: ABCD. #####. Pokud je nastavena série a v transakcích není uvedeno číslo šarže, bude na základě této série vytvořeno automatické číslo šarže. Pokud chcete pro tuto položku vždy výslovně uvést číslo dávky, ponechte toto prázdné. Poznámka: Toto nastavení bude mít přednost před předponou Řada názvů v Nastavení skladu."
apps/erpnext/erpnext/config/healthcare.py,Consultation,Konzultace
DocType: Item,Item Defaults,Výchozí položka
DocType: Sales Invoice,Total Commission,Komise celkem
DocType: Hotel Room,Hotel Room,Hotelový pokoj
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} hodin
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Sériové číslo je povinné pro položku {0}
DocType: Company,Standard Template,Standardní šablona
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,Počet akcií a čísla akcií jsou nekonzistentní
DocType: Project,Start and End Dates,Datum zahájení a ukončení
DocType: Supplier Scorecard,Notify Employee,Upozornit zaměstnance
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Software
DocType: Program,Allow Self Enroll,Povolit zápis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Skladové náklady
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali Referenční datum"
DocType: Training Event,Workshop,Dílna
DocType: Stock Settings,Auto insert Price List rate if missing,"Automatické vložení ceny Ceník, pokud chybí"
DocType: Course Content,Course Content,Obsah kurzu
DocType: Purchase Order Item,Material Request Item,Položka požadavku na materiál
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Účel údržby
DocType: Designation,Skills,Dovednosti
DocType: Asset,Out of Order,Mimo provoz
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},K dispozici {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Vyberte možnost Zákazník
DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorovat časové překrytí pracovní stanice
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skrytý seznam uchovávající seznam kontaktů spojených s akcionářem
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Same item has been entered multiple times,Stejná položka byla zadána vícekrát
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Sériové číslo {0} je ve smlouvě o údržbě až {1}
DocType: Bin,FCFS Rate,Sazba FCFS
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Negativní množství není povoleno
DocType: Quotation Item,Planning,Plánování
DocType: Marketplace Settings,Marketplace URL (to hide and update label),Adresa URL tržiště (pro skrytí a aktualizaci štítku)
DocType: Item Group,Parent Item Group,Skupina mateřských položek
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Prům. Výkupní cena
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Řádek # {0}: Časování je v rozporu s řádkem {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Opakujte zákazníky
DocType: Fee Schedule,Fee Schedule,Rozpis poplatků
DocType: Quality Inspection Reading,Reading 10,Čtení 10
apps/erpnext/erpnext/config/hr.py,Setting up Employees,Nastavení zaměstnanců
DocType: Selling Settings,Settings for Selling Module,Nastavení modulu Prodej
DocType: Payment Reconciliation,Reconcile,Smířit se
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Účet rozdílu musí být účet typu aktiv / pasiv, protože tento záznam o akci je vstupním záznamem"
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Konec Rok nemůže být před začátkem roku
DocType: Task,Parent Task,Rodičovský úkol
DocType: Attendance,Attendance Request,Žádost o účast
DocType: Item,Moving Average,Pohyblivý průměr
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačená účast
DocType: Homepage Section,Number of Columns,Počet sloupců
DocType: Holiday List,Add Weekly Holidays,Přidat týdenní svátky
DocType: Shopify Log,Shopify Log,Shopify Log
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Vytvořit platový skluz
DocType: Customs Tariff Number,Customs Tariff Number,Číslo celního sazebníku
DocType: Job Offer Term,Value / Description,Hodnota / Popis
DocType: Warranty Claim,Issue Date,Datum vydání
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte dávku pro položku {0}. Nelze najít jednu dávku, která splňuje tento požadavek"
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Nelze vytvořit retenční bonus pro levé zaměstnance
DocType: Purchase Order,To Receive,Obdržet
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,"Nacházíte se v režimu offline. Nebudete moci znovu načíst, dokud nebudete mít síť."
DocType: Course Activity,Enrollment,Zápis
DocType: Lab Test Template,Lab Test Template,Lab Test šablony
,Employee Birthday,Narozeniny zaměstnanců
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Chybí informace o elektronické fakturaci
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Nebyl vytvořen žádný požadavek na materiál
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
DocType: Loan,Total Amount Paid,Celková částka zaplacena
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
DocType: Training Event,Trainer Name,Jméno trenéra
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Projektový manažer
DocType: Travel Itinerary,Non Diary,Non Diary
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Akcie neexistují s {0}
DocType: Lab Test,Test Group,Testovací skupina
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,"Počet dní, po které musí účastník zaplatit faktury generované tímto předplatným"
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Nastavte účet nerealizované výměny / ztráty ve společnosti {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Vyberte položku Platební účet, chcete-li zadat položku Bankovní vklad"
DocType: Supplier Scorecard,Scoring Setup,Nastavení Scoring
DocType: Salary Slip,Total Interest Amount,Celková částka úroků
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení fiskálního roku a datum ukončení fiskálního roku jsou již nastaveny ve fiskálním roce {0}
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Fakturovatelné hodiny
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Sloučit s existujícím účtem
DocType: Lead,Lost Quotation,Ztracená nabídka
DocType: Email Digest,Note: Email will not be sent to disabled users,Poznámka: E-mail nebude odeslán postiženým uživatelům
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Vytvářejte a spravujte denní, týdenní a měsíční e-maily."
DocType: Academic Term,Academic Year,Akademický rok
DocType: Sales Stage,Stage Name,Pseudonym
DocType: SMS Center,All Employee (Active),Všichni zaměstnanci (aktivní)
DocType: Accounting Dimension,Accounting Dimension,Účetní rozměr
DocType: Project,Customer Details,Detaily zákazníka
DocType: Buying Settings,Default Supplier Group,Skupina výchozích dodavatelů
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Receipt {0} first,Nejdříve prosím zrušte nákupní doklad {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Poplatek typu &#39;Skutečný&#39; v řádku {0} nelze zahrnout do sazby položky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Business Development Manager
DocType: Agriculture Task,Urgent,Naléhavé
DocType: Shipping Rule Condition,From Value,Od hodnoty
DocType: Asset Maintenance Task,Next Due Date,Další datum splatnosti
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Koupit
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Pokrok% pro úkol nesmí být větší než 100.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Počet kořenových účtů nesmí být menší než 4
DocType: Item,Website Item Groups,Skupiny položek webových stránek
DocType: Certified Consultant,Certified Consultant,Certifikovaný konzultant
DocType: Driving License Category,Class,Třída
DocType: Asset,Sold,Prodáno
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},V {0} {1} může být pouze 1 účet na společnost
DocType: GL Entry,Against,Proti
DocType: Company,Default Deferred Expense Account,Výchozí účet odložených výdajů
DocType: Stock Settings,Auto Material Request,Automatická žádost o materiál
DocType: Marketplace Settings,Sync in Progress,Probíhá synchronizace
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No salary slip found to submit for the above selected criteria OR salary slip already submitted,"Nebyl nalezen žádný výplatní list, který by byl předložen pro výše uvedená kritéria NEBO již předložený výplatní list"
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Vytvořit pravidla pro omezení transakcí na základě hodnot.
DocType: Products Settings,Enable Field Filters,Povolit filtry polí
DocType: Loan,Loan Amount,Částka půjčky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Různé náklady
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',Stanovte prosím fiskální kód pro veřejnou správu „% s“
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline)
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Uživatel {0} nemá žádný výchozí POS profil. Zaškrtněte Výchozí v řádku {1} pro tohoto uživatele.
DocType: Department,Leave Block List,Seznam bloků ponechte
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html,Select Patient,Vyberte možnost Pacient
DocType: Attendance,Leave Type,Typ ponechání
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Vytváření skupin studentů
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Rostliny a stroje
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,Není označeno
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Doklad o nákupu
DocType: GL Entry,Is Opening,Otevírá se
DocType: Accounts Settings,Accounts Settings,Nastavení účtů
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Skutečné množství: Množství dostupné ve skladu.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Platnost vyprší
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Účetní zápis aktiva
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Rozvrh kurzu
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Nákladové středisko s existujícími transakcemi nelze převést na účet
,Bank Clearance Summary,Přehled o zúčtování bank
DocType: SMS Center,SMS Center,SMS centrum
DocType: Pricing Rule,Threshold for Suggestion,Prahová hodnota pro návrh
DocType: Stock Entry,Sales Invoice No,Prodejní faktura č
DocType: Project Update,Project Update,Aktualizace projektu
DocType: Student Sibling,Student ID,ID studenta
,Pending SO Items For Purchase Request,Položky čekající na vyřízení pro objednávku
DocType: Task,Timeline,Časová osa
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Věrnostní program není pro vybranou společnost platný
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurovat {0}
DocType: Employee,Contact Details,Kontaktní údaje
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učebny / Laboratoře atd., Kde lze přednášky naplánovat."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože odeslaná položka položky {0} existuje"
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Zůstatek v měně účtu
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Zavřete POS
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry",V případě {0} mohou být proti jinému debetnímu záznamu propojeny pouze kreditní účty
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Farmaceutické
DocType: Program Enrollment,Boarding Student,Stravování Student
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Celková částka příspěvku: {0}
DocType: Item Alternative,Two-way,Obousměrně
DocType: Appraisal,Appraisal,Posouzení
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Vytvořit zaměstnance
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Struktury byly úspěšně přiřazeny
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Přímé výdaje
DocType: Support Search Source,Result Route Field,Pole Výsledek trasy
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Nedostatek zůstatku dovolené pro typ dovolené {0}
DocType: Material Request Plan Item,Actual Qty,Skutečné množství
DocType: Purchase Invoice,Supplier Invoice Date,Datum dodavatelské faktury
DocType: Depreciation Schedule,Finance Book Id,Id finanční knihy
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Aktuální směnný kurz
DocType: Account,Equity,Spravedlnost
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Řádek # {0}: Typ referenčního dokumentu musí být jeden z prodejní objednávky, prodejní faktury nebo položky deníku"
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,Prozkoumejte cyklus prodeje
DocType: Shopify Log,Request Data,Požadovaná data
DocType: Quality Procedure,Quality Procedure,Postup kvality
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},E-mail odeslán dodavateli {0}
,Course wise Assessment Report,Zpráva o hodnocení moudrosti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Automobilový průmysl
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Řádek {0}: Přidělená částka {1} musí být nižší nebo rovna fakturaci zbývající částky {2}
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Setkání učitelů totálních rodičů
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Řádek {0}: Je vyžadována operace proti položce suroviny {1}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Časová známka zaúčtování musí být po {0}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Uveďte prosím úvodní jméno ve vedení {0}
DocType: Employee,You can enter any date manually,Můžete zadat libovolné datum ručně
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Položka odsouhlasení zásob
DocType: Item Group,General Settings,Obecné nastavení
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Datum splatnosti nesmí být před účtováním / datem faktury dodavatele
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Před odesláním zadejte jméno příjemce.
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Zaznamenejte vitality pacienta
DocType: Shopping Cart Settings,Show Configure Button,Zobrazit tlačítko Konfigurovat
DocType: Industry Type,Industry Type,Typ průmyslu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Nelze vybrat typ poplatku jako &#39;On Previous Row Amount&#39; nebo &#39;On Previous Row Total&#39; pro první řádek
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Akcie již existují
DocType: Work Order Item,Available Qty at WIP Warehouse,K dispozici ve skladu WIP Warehouse
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Vyřešte chybu a znovu nahrajte.
DocType: Travel Request,Copy of Invitation/Announcement,Kopie pozvánky / oznámení
DocType: Healthcare Service Unit,Healthcare Service Unit,Jednotka zdravotnické služby
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Celkem (počet)
DocType: Employee,Health Insurance No,Zdravotní pojištění č
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Department Approver,Approver,Schvalovatel
,Sales Order Trends,Trendy prodejní objednávky
DocType: Asset Repair,Repair Cost,náklady na opravu
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,Uveďte prosím společnost Round Off Account ve společnosti
DocType: Payroll Entry,Select Payroll Period,Vyberte Mzdové období
DocType: Price List,Price List Name,Název ceníku
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Odměnu můžete zaslat pouze za platnou částku inkasa
DocType: Pricing Rule,"Higher the number, higher the priority","Vyšší číslo, vyšší prioritu"
DocType: Designation,Required Skills,Požadované dovednosti
DocType: Marketplace Settings,Disable Marketplace,Zakázat tržiště
DocType: Budget,Action if Annual Budget Exceeded on Actual,Akce v případě překročení skutečného ročního rozpočtu
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Návštěvnost nebyla předložena na {0} jako {1} na dovolené.
DocType: Pricing Rule,Promotional Scheme Id,Id propagačního schématu č
apps/erpnext/erpnext/projects/doctype/project/project.py,End date of task <b>{0}</b> cannot be greater than <b>{1}</b> expected end date <b>{2}</b>,Datum ukončení úlohy <b>{0}</b> nemůže být delší než <b>{1}</b> očekávané datum ukončení <b>{2}</b>
DocType: Driver,License Details,Detaily licence
DocType: Cash Flow Mapper,e.g Adjustments for:,např. úpravy pro:
DocType: Selling Settings,Default Quotation Validity Days,Výchozí dny platnosti nabídky
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Bankovní účet, od data a do data jsou povinné"
DocType: Travel Request Costing,Expense Type,Typ nákladů
DocType: Account,Auditor,Auditor
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Potvrzení platby
,Available Stock for Packing Items,Dostupný sklad pro položky balení
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Odstraňte prosím tuto fakturu {0} z formuláře C {1}
DocType: Support Search Source,Query Route String,Řetězec dotazu dotazu
DocType: Customer Feedback Template,Customer Feedback Template,Šablona zpětné vazby od zákazníků
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Citáty vedoucí nebo zákazníky.
DocType: Driver,Transporter,Přepravce
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Platový lístek zaměstnance {0} již vytvořený pro toto období
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},To {0} | {1} {2}
DocType: Leave Block List Date,Block Date,Datum bloku
DocType: Sales Team,Contact No.,Kontaktní číslo.
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Procento nadprodukce pro pracovní příkaz
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Zapsat
DocType: Quotation Lost Reason,Quotation Lost Reason,Citace ztratil důvod
,Employee Billing Summary,Přehled fakturace zaměstnanců
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Výchozí šablony zemí
DocType: Cost Center,Parent Cost Center,Centrum rodičovských nákladů
DocType: Pricing Rule,Apply Rule On Item Group,Použít skupinu pravidel na položku
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,Příklad: Základní matematika
DocType: Expense Claim,Total Amount Reimbursed,Celková částka uhrazená
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Platnost této nabídky skončila.
,Item-wise Sales History,Historie prodeje zboží
DocType: Employee,Personal Email,Osobní email
DocType: Bank Reconciliation Detail,Cheque Date,Datum kontroly
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Předchozí finanční rok není uzavřen
DocType: Lead,Next Contact Date,Další datum kontaktu
DocType: Membership,Membership,Členství
DocType: Buying Settings,Default Buying Price List,Výchozí nákupní ceník
DocType: Asset,Depreciation Method,Metoda odpisování
DocType: Travel Request,Travel Request,Cestovní požadavek
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} vytvořené varianty.
DocType: Healthcare Settings,Avoid Confirmation,Vyhněte se potvrzení
DocType: Serial No,Under AMC,Pod AMC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Sklad je vyžadován v řádku č. {0}, nastavte výchozí sklad pro položku {1} pro společnost {2}"
DocType: Authorization Control,Authorization Control,Řízení autorizace
,Daily Work Summary Replies,Odpovědi na denní práci
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Byli jste pozváni ke spolupráci na projektu: {0}
DocType: Item,Sales Details,Podrobnosti o prodeji
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Dopis hlavy pro tiskové šablony.
DocType: Salary Detail,Tax on additional salary,Daň z příplatku
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Připojte Logo
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter Planned Qty,Pro řádek {0}: Zadejte plánované množství
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Vypočítat poměrný odpisový plán založený na fiskálním roce
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Protokoly pro udržování stavu doručení sms
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Aktuální pracovní příležitosti
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Pravidlo cen je nejprve vybráno na základě pole „Použít na“, kterým může být položka Položka, Skupina položek nebo Značka."
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / upravit daně a poplatky
DocType: Item,Supply Raw Materials for Purchase,Dodávky surovin pro nákup
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Návrh zápisu
DocType: Landed Cost Item,Purchase Receipt Item,Položka příjmu
DocType: Production Plan,Get Sales Orders,Získat zakázky odběratele
DocType: Pricing Rule,Selling,Prodejní
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabránit objednávkám
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Tisk a papírnictví
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Pravidlo přepravy platí pouze pro nákup
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Nebyly nalezeny žádné produkty.
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Řádek {0}: Prosím nastavte na Daňové osvobození Daň z prodejních daní a poplatků
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Posuzovací skupina:
DocType: Tally Migration,Parties,Strany
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Zobrazit rozložený pohled
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Pro zákazníka {} nebyla vybrána žádná poznámka o doručení
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Ukončete
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,"Věrnostní body, které mají vyšší hodnotu než Grand Total, nelze uplatnit."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Návrhář
DocType: QuickBooks Migrator,Default Warehouse,Výchozí sklad
DocType: Company,Default Cash Account,Výchozí hotovostní účet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Zadejte referenční datum
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Položka {0} musí být skladová položka
DocType: POS Profile,Print Format for Online,Formát tisku pro online
,Employee Leave Balance,Zaměstnanec opustit zůstatek
DocType: Projects Settings,Ignore User Time Overlap,Ignorovat překrytí uživatelského času
DocType: Stock Entry,As per Stock UOM,Podle skladem UOM
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Nákladové středisko s existujícími transakcemi nelze převést na skupinu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,nesmí být větší než 100
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please Delivery Note first,Nejdříve prosím dodací list
DocType: Leave Type,Leave Type Name,Nechte název typu
DocType: Homepage Featured Product,Homepage Featured Product,Hlavní stránka Doporučený produkt
DocType: Assessment Plan,Examiner Name,Jméno examinátora
,Hotel Room Occupancy,Obsazenost hotelového pokoje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,Telekomunikace
DocType: Certification Application,Certification Application,Certifikační aplikace
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Obrázek webu by měl být veřejný soubor nebo adresa URL webu
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Vaši dodavatelé
DocType: Appraisal Goal,Weightage (%),Vážení (%)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Mezistátní dodávky
DocType: Fees,Send Payment Request,Odeslat žádost o platbu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} není přidáno do tabulky
apps/erpnext/erpnext/utilities/activation.py,Create Student,Vytvořit studenta
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Ganttův diagram všech úkolů.
DocType: Department,Leave Approvers,Nechte schvalovatele
DocType: BOM,Materials Required (Exploded),Požadované materiály (rozložené)
DocType: Loan,Repay Over Number of Periods,Splatnost přes počet období
DocType: Account,Receivable,Pohledávka
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Cenník musí být použitelný pro nákup nebo prodej
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Znovu odeslat platební e-mail
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Nastavte adresu {0} pro adresu {1}
DocType: Stock Entry,Default Source Warehouse,Výchozí zdrojový sklad
DocType: Timesheet Detail,Bill,Účtovat
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitní číslo role pro studenta {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Dávka {0} položky {1} vypršela.
DocType: Lab Test,Approved Date,Schválené datum
DocType: Item Group,Item Tax,Položka Daň
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Nelze přenést zaměstnance se stavem vlevo
DocType: BOM,Total Cost,Celkové náklady
DocType: Request for Quotation Supplier,Quote Status,Stav nabídky
DocType: Employee Education,Qualification,Kvalifikace
DocType: Complaint,Complaints,Stížnosti
DocType: Item,Is Purchase Item,Je položka nákupu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Potvrzení o nákupu
DocType: Subscription,Trial Period Start Date,Datum zahájení zkušebního období
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Zůstatek kreditu
DocType: Employee Benefit Application,Payroll Period,Mzdové období
apps/erpnext/erpnext/config/buying.py,Supplier database.,Databáze dodavatelů.
DocType: Tax Rule,Tax Type,Typ daně
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Přesunout položku
DocType: Job Opening,Description of a Job Opening,Popis otevírání zakázky
apps/erpnext/erpnext/utilities/activation.py,Create Users,Vytvořit uživatele
DocType: Global Defaults,Current Fiscal Year,Aktuální fiskální rok
DocType: Item,Hub Warehouse,Skladová hala
DocType: Purchase Invoice,Tax Breakup,Daňové porušení
DocType: Job Card,Material Transferred,Převedený materiál
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat položky před {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,Počet sériových čísel a množství musí být stejný
DocType: Company,Exception Budget Approver Role,Výjimka role schvalovatele rozpočtu
DocType: Fee Schedule,In Process,V procesu
DocType: Daily Work Summary Group,Send Emails At,Odeslat e-maily na adrese
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Chyba tržiště
DocType: Salary Slip,Working Days,Pracovní dny
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Chapter,Chapter,Kapitola
DocType: Purchase Receipt Item Supplied,Current Stock,Aktuální sklad
DocType: Employee,History In Company,Historie ve společnosti
DocType: Purchase Invoice Item,Manufacturer,Výrobce
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Střední citlivost
DocType: Compensatory Leave Request,Leave Allocation,Opustit přidělení
DocType: Timesheet,Timesheet,Rozvrh hodin
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Zkratka již použitá pro jinou společnost
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,"Chcete-li získat laboratorní testy, vyberte možnost Pacient"
DocType: Purchase Order,Advance Paid,Advance Plaid
DocType: Supplier Scorecard,Load All Criteria,Načíst všechna kritéria
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Sériová čísla v řádku {0} neodpovídají dodacímu listu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Věřitelé
DocType: Warranty Claim,Raised By,Vychován
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Referenční číslo a referenční datum jsou povinné pro transakci Banky
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,V závislosti na celkovém vynaloženém objemu může existovat víceúrovňový faktor sběru. Konverzní faktor pro vykoupení bude však vždy stejný pro všechny stupně.
DocType: Purchase Invoice Item,Batch No,Dávka č
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Výkonné vyhledávání
DocType: Company,Stock Adjustment Account,Účet pro úpravu zásob
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Hrubý zisk %
DocType: Lead,Request Type,Typ požadavku
DocType: Patient Appointment,Reminded,Připomnělo
DocType: Accounts Settings,Billing Address,fakturační adresa
DocType: Student Leave Application,Mark as Present,Mark as Present
DocType: Landed Cost Voucher,Landed Cost Voucher,Doklad o nákladech na přistání
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Celková pracovní doba by neměla být větší než maximální pracovní doba {0}
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Zákaznické adresy a kontakty
DocType: Project,Task Progress,Průběh úkolů
DocType: Journal Entry,Opening Entry,Otevření vstupu
DocType: Bank Guarantee,Charges Incurred,Vznikly poplatky
DocType: Work Order,Material Transferred for Manufacturing,Materiál převedený na výrobu
DocType: Products Settings,Hide Variants,Skrýt varianty
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Zakázat plánování kapacity a sledování času
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude vypočteno v transakci.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Balance Sheet' account {1}.,{0} je vyžadováno pro účet „Rozvahy“ {1}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} není dovoleno s {1} obchodovat. Změňte prosím společnost.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Podle nákupních nastavení v případě, že je požadavek na nákup vyžadován == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit položku Příjemce pro položku {0}"
DocType: Delivery Trip,Delivery Details,detaily objednávky
DocType: Inpatient Record,Discharge Scheduled,Plánované vybití
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, Kód položky: {1} a zákazník: {2}"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Pozor
DocType: Project User,View attachments,Zobrazit přílohy
DocType: Manufacturing Settings,Allow Production on Holidays,Povolit výrobu na svátky
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Aktualizovat data transakce banky
DocType: Quality Inspection Reading,Reading 4,Čtení 4
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Položka {0} nemá žádné sériové číslo Pouze serializované položky mohou být dodány na základě sériového čísla
DocType: Program Course,Program Course,Programový kurz
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonní náklady
DocType: Patient,Widow,Vdova
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Počet interakcí
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Pravidla vícenásobných cen existují se stejnými kritérii, prosím vyřešte konflikt přiřazením priority. Cenová pravidla: {0}"
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Nákladové středisko a rozpočtování
,Ordered Items To Be Delivered,Objednané položky budou dodány
DocType: Homepage Section Card,Homepage Section Card,Karta sekce Domovská stránka
DocType: Account,Depreciation,Amortizace
DocType: Guardian,Interests,Zájmy
DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřebované množství
DocType: Education Settings,Education Manager,Manažer vzdělávání
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Plánujte protokoly mimo pracovní hodiny pracovní stanice.
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Věrnostní body: {0}
DocType: Healthcare Settings,Registration Message,Registrační zpráva
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,"Vyberte účet, který chcete vytisknout v měně účtu"
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Sériová položka nemůže být zlomkem
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Sklad nelze smazat, protože pro tento sklad existuje záznam o skladové knize."
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Viz minulé citace
apps/erpnext/erpnext/www/all-products/index.html,Prev,Předchozí
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Měrná jednotka
DocType: Lab Test,Test Template,Testovací šablona
DocType: Fertilizer,Fertilizer Contents,Obsah hnojiva
DocType: Quality Meeting Minutes,Minute,Minuta
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Řádek # {0}: Zařízení {1} nelze odeslat, je již {2}"
DocType: Task,Actual Time (in Hours),Aktuální čas (v hodinách)
DocType: Period Closing Voucher,Closing Account Head,Uzavření účtu vedoucího
DocType: Purchase Invoice,Shipping Rule,Pravidlo přepravy
DocType: Shipping Rule,Net Weight,Čistá hmotnost
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Zadejte prosím datum začátku a konce finančního roku
DocType: POS Closing Voucher Invoices,Quantity of Items,Množství položek
DocType: Warehouse,PIN,KOLÍK
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Testování datetime nemůže být před sběrem datetime
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Faktura již byla vytvořena pro všechny fakturační hodiny
DocType: Sales Partner,Contact Desc,Kontaktní formulář
DocType: Purchase Invoice,Pricing Rules,Cenová pravidla
DocType: Hub Tracked Item,Image List,Seznam obrázků
DocType: Item Variant Settings,Allow Rename Attribute Value,Povolit hodnotu Přejmenovat atribut
DocType: Price List,Price Not UOM Dependant,Cena není závislá na UOM
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Čas (v minutách)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Základní
DocType: Loan,Interest Income Account,Účet úrokových výnosů
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidlo přepravy
DocType: Payroll Period Date,Payroll Period Date,Datum výplaty mezd
DocType: Employee,Employment Type,Typ zaměstnání
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Zvolte POS profil
DocType: Support Settings,Get Latest Query,Získejte nejnovější dotaz
DocType: Employee Incentive,Employee Incentive,Motivace zaměstnanců
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Přidání karet nebo vlastních sekcí na domovské stránce
DocType: Homepage,Hero Section Based On,Hero sekce založená na
DocType: Project,Total Purchase Cost (via Purchase Invoice),Celková nákupní cena (prostřednictvím nákupní faktury)
DocType: Staffing Plan Detail,Total Estimated Cost,Celkové odhadované náklady
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodeje, nákupy, výchozí hodnoty účetnictví"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Žádost o platbu ve výši {0} {1} pro částku {2}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Nejprve nastavte kód položky
DocType: Payment Term,Due Date Based On,Datum splatnosti na základě
DocType: Quality Inspection,Incoming,Přicházející
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,Částečně objednáno
DocType: Delivery Note,Customer's Purchase Order No,Objednávka zákazníka č
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Vyberte Alternativní položku
DocType: Employee,Applicable Holiday List,Použitelný seznam dovolených
DocType: Hub Tracked Item,Hub Tracked Item,Položka sledovaná v rozbočovači
DocType: Vehicle Log,Service Details,Podrobnosti o službě
DocType: Program,Is Featured,Doporučené
DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte připomenutí zaměstnanců
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržujte stejnou rychlost v průběhu prodejního cyklu
DocType: Program Enrollment,Transportation,Přeprava
DocType: Patient Appointment,Date TIme,Čas schůzky
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Prosím vyberte množství na řádku
DocType: Employee Benefit Application Detail,Earning Component,Vydělávání komponent
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company first,Nejprve vyberte společnost
DocType: Item,Publish Item to hub.erpnext.com,Publikovat položku na adresu hub.erpnext.com
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Připojit
DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavte rychlost položky dílčí sestavy na základě kusovníku
DocType: Vehicle,Wheels,Kola
DocType: Product Bundle,"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**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For 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.

Note: BOM = Bill of Materials","Agregovaná skupina ** Položky ** do jiné ** Položka **. To je užitečné, pokud balíčkujete určité ** položky ** do balíku a udržujete zásoby balených položek ** a nikoli agregované položky **. Balíček ** Položka ** bude mít položku &quot;Je skladem položka&quot; jako &quot;Ne&quot; a &quot;Je položka prodeje&quot; jako &quot;Ano&quot;. Například: Pokud prodáváte notebooky a batohy samostatně a mají zvláštní cenu, pokud si zákazník koupí obojí, pak notebook + batoh bude nový produktový balíček. Poznámka: BOM = kusovník"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Další záznam o rozpočtu „{0}“ již existuje proti {1} &#39;{2}&#39; a účtu &#39;{3}&#39; pro fiskální rok {4}
DocType: Asset,Purchase Receipt Amount,Částka nákupního dokladu
DocType: Issue,Ongoing,Pokračující
DocType: Service Level Agreement,Agreement Details,Podrobnosti o dohodě
DocType: Purchase Invoice,Posting Time,Čas účtování
DocType: Loyalty Program,Loyalty Program Name,Název věrnostního programu
DocType: Patient,Dormant,Spící
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Od {1}
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Připojit soubor vlastní graf účtů
apps/erpnext/erpnext/config/help.py,Item Variants,Varianty položky
DocType: Maintenance Visit,Fully Completed,Dokončeno
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Datum transakce
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Pro toto období nejsou k dispozici žádná data
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,"Pokud je tento režim vybrán, výchozí účet bude automaticky aktualizován ve faktuře POS."
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Zkratka společnosti nesmí mít více než 5 znaků
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Zrušeno
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,Zákazníci a dodavatelé
,To Produce,K výrobě
DocType: Location,Is Container,Je kontejner
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,výzkum a vývoj
DocType: QuickBooks Migrator,Application Settings,Nastavení aplikace
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order cannot be raised against a Item Template,Výrobní zakázku nelze vznést proti šabloně položky
DocType: Work Order,Manufacture against Material Request,Výroba proti požadavku na materiál
DocType: Blanket Order Item,Ordered Quantity,Objednané množství
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutý sklad je povinný proti odmítnuté položce {1}
,Received Items To Be Billed,"Přijaté položky, které mají být účtovány"
DocType: Salary Slip Timesheet,Working Hours,Pracovní doba
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Platební režim
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Položky objednávky nebyly včas doručeny
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Doba trvání ve dnech
DocType: Customer,Sales Team Details,Podrobnosti o prodejním týmu
DocType: BOM Update Tool,Replace,Nahradit
DocType: Training Event,Event Name,Název události
DocType: SMS Center,Receiver List,Seznam příjemců
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Kr
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,Opravdu chcete tuto událost zrušit?
DocType: Invoice Discounting,Accounts Receivable Credit Account,Účet pohledávek Úvěr
DocType: Naming Series,Prefix,Předpona
DocType: Work Order Operation,Actual Operation Time,Skutečná doba provozu
DocType: Purchase Invoice Item,Net Rate,Čistá sazba
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Čistá změna v hotovosti
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Nastavit sklad pro proceduru {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Bloková faktura
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Účet {0}: Rodičovský účet {1} neexistuje
DocType: HR Settings,Encrypt Salary Slips in Emails,Šifrování mezd v e-mailech
DocType: Supplier Scorecard Scoring Criteria,Score,Skóre
DocType: Delivery Note,Driver Name,Název ovladače
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,"Zvolte prosím jméno osoby, která má být vybita"
DocType: Employee Training,Training,Výcvik
apps/erpnext/erpnext/config/stock.py,Stock Reports,Skladové zprávy
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},Konverzní faktor pro výchozí měrnou jednotku musí být 1 v řádku {0}
DocType: Course Scheduling Tool,Course Scheduling Tool,Nástroj pro plánování kurzu
,Finished Goods,Hotové výrobky
DocType: Sales Invoice Item,Customer Warehouse (Optional),Sklad zákazníka (volitelné)
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Synchronizace kmenových dat
DocType: Lead,Address & Contact,Adresa a kontakt
DocType: Bank Reconciliation,To Date,K datu
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Chyba v některých řádcích
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Laboratorní testy a vitální znaky
apps/erpnext/erpnext/config/accounting.py,Tax Rule for transactions.,Daňové pravidlo pro transakce.
DocType: Stock Settings,Show Barcode Field,Zobrazit pole čárového kódu
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Vital Signs,Fluid,Tekutina
DocType: GST Settings,B2C Limit,Limit B2C
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,Elektronická zařízení
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Nelze najít aktivní období dovolené
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Vytvořit návštěvu údržby
DocType: Healthcare Service Unit Type,Change In Item,Změnit v položce
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Studenti byli zapsáni
DocType: Vehicle Service,Inspection,Inspekce
DocType: Location,Area,Plocha
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Shrnutí pro tento týden a probíhající aktivity
DocType: Asset Maintenance Task,Maintenance Task,Úkol údržby
DocType: Subscription,Current Invoice Start Date,Aktuální datum zahájení faktury
DocType: Purchase Invoice Item,Item,Položka
DocType: Program Enrollment Tool,Get Students From,Získejte studenty z
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Před synchronizací podrobností objednávky vždy synchronizujte své produkty od společnosti Amazon MWS
DocType: Leave Block List,Leave Block List Name,Nechte název seznamu bloků
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Nelze aktualizovat zásoby, faktura obsahuje položku pro odeslání zásilky."
DocType: Asset Maintenance Log,Completion Date,Datum dokončení
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou je měna dodavatele převedena na základní měnu společnosti"
DocType: Leave Control Panel,Leave Control Panel,Nechte ovládací panel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Celková použitelná sazba v položkách položek nákupu musí být stejná jako celkové daně a poplatky
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"V aplikaci Words se zobrazí, jakmile uložíte dodací poznámku."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Dodávky pro osoby povinné k dani
DocType: Bin,Reserved Qty for Production,Rezervované množství pro výrobu
DocType: Asset,Quality Manager,Manažer kvality
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurujte pole položek jako UOM, Skupina položek, Popis a Počet hodin."
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Nové oddělení
DocType: Employee,Job Applicant,Uchazeč o zaměstnání
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Vytvořit faktury
DocType: Purchase Invoice Item,Purchase Order Item,Položka objednávky
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Import a export dat
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,Obraťte se prosím na uživatele s rolí Sales Master Manager {0}
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Typ projektu „Externí“ nelze odstranit
DocType: Account,Temporary,Dočasný
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Popisky sloupců:
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Číslo zaměstnance
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Datum otevření by mělo být před uzavřením
DocType: Packed Item,Parent Detail docname,Podrobnosti o rodičích docname
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail bankovního odsouhlasení
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Mezní hodnota kumulativní transakce
DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Počet intervalů pro pole intervalu, např. Pokud je Interval „Dny“ a Počet účtovacích intervalů je 3, faktury budou generovány každé 3 dny"
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date',&#39;Skutečný začátek&#39; nemůže být větší než &#39;skutečný datum ukončení&#39;
DocType: Payment Entry Reference,Payment Entry Reference,Referenční číslo platby
DocType: Salary Component Account,Salary Component Account,Účet mzdové složky
DocType: Supplier,Default Payable Accounts,Výchozí splatné účty
DocType: Purchase Invoice,In Words,Ve slovech
DocType: Journal Entry Account,Purchase Order,Nákupní objednávka
DocType: Journal Entry,Entry Type,Typ vstupu
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Laboratoř
DocType: Purchase Order,To Bill,Bille
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Náklady na služby
DocType: Manufacturing Settings,Time Between Operations (in mins),Čas mezi operacemi (v minutách)
DocType: GSTR 3B Report,May,Smět
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Účet platební brány nebyl vytvořen, vytvořte jej ručně."
DocType: Opening Invoice Creation Tool,Purchase,Nákup
DocType: Program Enrollment,School House,Školní dům
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Vyberte alespoň jednu doménu.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Denní shrnutí projektu pro {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Všechna území
DocType: Asset Repair,Failure Date,Datum selhání
DocType: Training Event,Attendees,Účastníci
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Naprosto vynikající
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Částka odečtená TDS
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Pro provedení platby je povinen peněžní nebo bankovní účet
DocType: Company,Registration Details,Podrobnosti registrace
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Vypočítaný zůstatek bankovního výpisu
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Na Marketplace se mohou zaregistrovat pouze uživatelé s {0} rolí
apps/erpnext/erpnext/controllers/stock_controller.py,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Sklad {0} není propojen s žádným účtem, uveďte prosím účet ve skladovém záznamu nebo nastavte výchozí účet ve společnosti {1}."
DocType: Inpatient Record,Admission,Přijetí
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,To je založeno na účasti tohoto studenta
DocType: SMS Center,Create Receiver List,Vytvořit seznam příjemců
DocType: Leave Type,Max Leaves Allowed,Povoleno Max
DocType: Salary Detail,Component,Součástka
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Dovolená a účast
DocType: Sales Invoice Timesheet,Billing Amount,Částka fakturace
DocType: BOM Website Item,BOM Website Item,Položka webové stránky kusovníku
DocType: Purchase Invoice,Rounded Total,Zaokrouhlený celkem
DocType: Production Plan,Production Plan,Plán produkce
DocType: Asset Maintenance Log,Actions performed,Provedené akce
DocType: Purchase Invoice,Set Accepted Warehouse,Nastavte Accepted Warehouse
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Pravidla pro uplatnění cen a slev.
DocType: Supplier,Statutory info and other general information about your Supplier,Statutární informace a další obecné informace o dodavateli
DocType: Item Default,Default Selling Cost Center,Středisko výchozích prodejních nákladů
DocType: Sales Partner,Address & Contacts,Adresa a kontakty
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte prosím číslovací řadu pro Docházku pomocí Nastavení&gt; Číslovací řada
DocType: Subscriber,Subscriber,Odběratel
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) není skladem
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Nejdříve vyberte Datum účtování
DocType: Supplier,Mention if non-standard payable account,"Uveďte, zda se jedná o nestandardní účet"
DocType: Training Event,Advance,Záloha
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,"Root Type for ""{0}"" must be one of the Asset, Liability, Income, Expense and Equity","Typ kořene pro &quot;{0}&quot; musí být jeden z aktiv, závazků, výnosů, nákladů a vlastního kapitálu"
DocType: Project,% Complete Method,Kompletní metoda
DocType: Detected Disease,Tasks Created,Úlohy byly vytvořeny
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,Pro tuto položku nebo její šablonu musí být aktivní výchozí rozpiska ({0})
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Sazba Komise
DocType: Service Level,Response Time,Doba odezvy
DocType: Woocommerce Settings,Woocommerce Settings,Nastavení Woocommerce
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Množství musí být kladné
DocType: Contract,CRM,CRM
DocType: Purchase Taxes and Charges,Parenttype,Rodičovský typ
DocType: Tax Rule,Billing State,Stav fakturace
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Množství položky {0} musí být menší než {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Přenos materiálu
DocType: Shipping Rule,Shipping Account,Přepravní účet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Nastavte výchozí šablonu pro Oznámení o ponechání schválení v nastaveních HR.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televize
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0},Kontrola kvality vyžadovaná pro položku {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debet ({0})
DocType: Healthcare Practitioner,Inpatient Visit Charge,Poplatek za hospitalizaci
DocType: Bank Statement Settings,Transaction Data Mapping,Mapování transakčních dat
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Vedení vyžaduje jméno osoby nebo jméno organizace
DocType: Student,Guardians,Strážci
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavte prosím instruktorský systém pojmenování ve výuce&gt; Nastavení vzdělávání
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Vybrat značku ...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Střední příjem
DocType: Shipping Rule,Calculate Based On,Vypočítat na základě
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Čárový kód {0} je již použit v položce {1}
DocType: Lead,Campaign Name,Název kampaně
DocType: Purchase Invoice,Rejected Warehouse,Odmítnutý sklad
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} musí být odesláno
DocType: Expense Claim Advance,Expense Claim Advance,Výplata reklamace
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Úprava zaokrouhlování (měna společnosti)
DocType: Item,Publish in Hub,Publikovat v Hubu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
DocType: GSTR 3B Report,August,srpen
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Nejdříve zadejte prosím Potvrzení o nákupu
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Začátek roku
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Cílová ({})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Prosím nastavte výchozí mzdový účet ve společnosti {0}
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Souhrn prodeje
DocType: Purchase Invoice,In Words (Company Currency),Ve slovech (měna společnosti)
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Uveďte měnu ve společnosti
DocType: Pricing Rule,Price,Cena
DocType: Material Request Item,Min Order Qty,Min
DocType: Agriculture Task,Holiday Management,Holiday Management
apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py,Please enable default incoming account before creating Daily Work Summary Group,Před vytvořením denní souhrnné skupiny práce povolte výchozí příchozí účet
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py,You can only select a maximum of one option from the list of check boxes.,Ze seznamu zaškrtávacích polí můžete vybrat maximálně jednu možnost.
DocType: Program Enrollment,Public Transport,Veřejná doprava
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximální počet vzorků - {0} lze zachovat pro dávku {1} a položku {2}.
DocType: Item,Max Sample Quantity,Max. Množství vzorku
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Zdrojový a cílový sklad musí být odlišný
DocType: Employee Benefit Application,Benefits Applied,Aplikované výhody
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Proti položce žurnálu {0} není žádná nesrovnatelná položka {1}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Zvláštní znaky s výjimkou znaku &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; A &quot;}&quot; nejsou v názvových řadách povoleny"
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Vyžadují se ceny nebo slevové desky
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Nastavte cíl
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Záznam o docházce {0} existuje proti studentovi {1}
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Datum transakce
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Zrušit předplatné
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Čistá částka mzdy
DocType: Account,Liability,Odpovědnost
DocType: Employee,Bank A/C No.,Bankovní číslo A / C
DocType: Inpatient Record,Discharge Note,Poznámka k vybití
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Akce v případě kumulovaného měsíčního rozpočtu překročena na MR
DocType: Asset Movement,Asset Movement,Hnutí aktiv
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Nepodařilo se vytvořit kreditní poznámku automaticky, zrušte zaškrtnutí políčka „Potvrzení o výtisku“ a odešlete znovu"
DocType: Supplier Scorecard,Per Month,Za měsíc
DocType: Routing,Routing Name,Název směrování
DocType: Disease,Common Name,Běžné jméno
DocType: Education Settings,LMS Title,Název LMS
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Správa úvěrů
DocType: Clinical Procedure,Consumable Total Amount,Celková částka spotřebního materiálu
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Povolit šablonu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,Zákaznický LPO
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Snímek webu {0} připojený k položce {1} nelze nalézt
DocType: Asset Maintenance Log,Planned,Plánováno
DocType: Asset,Custodian,Správce
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,"Filtr založený na nákladovém středisku je použitelný pouze v případě, že je jako nákladové středisko vybráno Budget Against"
,Quoted Item Comparison,Porovnání citovaných položek
DocType: Journal Entry Account,Employee Advance,Advance zaměstnanců
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),Vnitrostátní dodávky podléhající přenesení daňové povinnosti (jiné než 1 a 2 výše)
DocType: Quotation,Shopping Cart,Nákupní košík
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Uživatel {0} neexistuje
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Úvěry a zálohy (aktiva)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Řádek {0}: Zkontrolujte, zda se jedná o zálohovou platbu proti účtu {1}, pokud se jedná o zálohu."
DocType: Leave Control Panel,Designation (optional),Označení (volitelné)
DocType: Salary Slip,Total Principal Amount,Celková částka jistiny
DocType: Opportunity,Customer / Lead Address,Adresa zákazníka / zákazníka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Mýdlo a prací prostředek
,Purchase Analytics,Nákup Analytics
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Příležitost
DocType: Employee,Prefered Contact Email,Preferovaný kontaktní e-mail
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Zahájení účetní závěrky
DocType: POS Profile,[Select],[Vybrat]
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Tally Migration,Master Data,Hlavní data
DocType: Certification Application,Yet to appear,Přesto se objeví
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Zákazníci ve frontě
DocType: Supplier,Supplier Details,Detaily dodavatele
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Žádný zisk nebo ztráta směnného kurzu
,GSTR-1,GSTR-1
DocType: Timesheet,Total Billable Hours,Celkový počet zúčtovatelných hodin
DocType: Supplier,Represents Company,Reprezentuje společnost
DocType: POS Profile,Company Address,adresa společnosti
,Lead Name,Jméno vedení
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Nemoci a hnojiva
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Položka {0} musí být subkontraktovaná položka
DocType: Landed Cost Voucher,Purchase Receipt Items,Položky nákupu
DocType: Production Plan,Ignore Existing Projected Quantity,Ignorovat existující předpokládané množství
DocType: Assessment Plan,Supervisor,Dozorce
DocType: Salary Detail,Salary Detail,Detail platu
DocType: Budget,Budget Against,Rozpočet proti
DocType: Student Report Generation Tool,Add Letterhead,Přidat hlavičkový papír
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Šablony kritérií pro hodnocení dodavatelů.
DocType: Asset,Default Finance Book,Výchozí finanční kniha
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Specifikujte společnost
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Celkový procentní podíl příspěvku by měl být roven 100%
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
,Asset Depreciations and Balances,Odpisy majetku a zůstatky
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Nové množství dávky
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Dovoz zboží
DocType: Purchase Order Item Supplied,Raw Material Item Code,Kód položky suroviny
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Faktura nákupu {0} je již odeslána
DocType: Fees,Student Email,E-mail studenta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {2},Rekurze kusovníku: {0} nemůže být rodičem nebo dítětem {2}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Získejte položky ze zdravotnických služeb
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Položka vstupu {0} není odeslána
DocType: Item Attribute Value,Item Attribute Value,Hodnota atributu položky
DocType: Volunteer,Volunteer Skills,Dobrovolnické dovednosti
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Pro tuto skupinu studentů nelze zapsat více než {0} studentů.
DocType: Travel Request,Costing Details,Detaily kalkulace
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Prodejní faktura {0} již byla odeslána
DocType: Journal Entry,Accounting Entries,Účetní zápisy
DocType: Payment Entry,Internal Transfer,Interní převod
DocType: Sales Invoice Item,Stock Details,Podrobnosti o skladě
DocType: Leave Type,Is Carry Forward,Přenáší se
DocType: Lead,Product Enquiry,Poptávka produktu
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Supplier Scorecard,Evaluation Period,Období hodnocení
DocType: Volunteer Skill,Volunteer Skill,Dobrovolnická dovednost
DocType: Purchase Order,Order Confirmation No,Potvrzení objednávky č
,POS,POS
DocType: Training Event,Self-Study,Samostudium
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Výše
DocType: Setup Progress Action,Action Doctype,Akce Doctype
DocType: POS Profile,Allow Print Before Pay,Povolit tisk před zaplacením
DocType: Production Plan,Select Items to Manufacture,Vyberte položky k výrobě
DocType: Leave Application,Leave Approver Name,Opustit jméno schvalovatele
DocType: Shareholder,Shareholder,Akcionář
DocType: Issue,Agreement Status,Stav dohody
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,"Vyberte prosím studentský vstup, který je povinný pro zaplaceného studenta"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Vyberte kusovník
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Plány pro překrývání {0}, chcete pokračovat po přeskočení překrytých slotů?"
DocType: Stock Entry,Customer or Supplier Details,Detaily zákazníka nebo dodavatele
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Debetní účet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Datum ukončení zkušebního období nemůže být před začátkem zkušebního období
DocType: Employee,Rented,Pronajímá se
DocType: Employee Group Table,Employee Group Table,Tabulka skupin zaměstnanců
DocType: Contract,HR Manager,Manažer lidských zdrojů
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,Podrobnosti o dodávkách do zahraničí Dodávky a vnitřní dodávky podléhající zpoplatnění
DocType: Payment Entry,Cheque/Reference No,Kontrolní / referenční č
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Výsledek hodnocení
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Nový kontakt
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Příležitosti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čisté peněžní toky z operací
DocType: Leave Encashment,Leave Encashment,Opustit Encashment
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Zdrojový sklad je povinný pro řádek {0}
DocType: Amazon MWS Settings,After Date,Po datu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC Available (ať už v plné části)
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Řádek {0}: Typ aktivity je povinný.
DocType: Lead,Consultant,Konzultant
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,"Vyberte zaměstnance, který se postará o zaměstnance."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Nelze zrušit aktivum, protože je již {0}"
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Špatné heslo
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Aktualizujte číslo účtu / jméno
DocType: Accounts Settings,Use Custom Cash Flow Format,Použít vlastní formát toku hotovosti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Otevření faktur
DocType: Stock Entry,Send to Warehouse,Odeslat do skladu
DocType: Training Event,Event Status,Stav události
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Celkový dokončený počet musí být větší než nula
DocType: Account,Chargeable,Nabíjecí
DocType: Volunteer,Anytime,Kdykoliv
,Student Batch-Wise Attendance,Student Batch-Wise Docházka
DocType: Normal Test Template,Normal Test Template,Normální testovací šablona
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Strom finančních nákladových středisek.
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",v minutách aktualizováno pomocí „Časového protokolu“
DocType: Bin,Bin,Zásobník
DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktury
DocType: Delivery Trip,Fulfillment User,Plnění Uživatel
DocType: Work Order Operation,Planned End Time,Plánovaný čas ukončení
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Kód oddílu
DocType: Project,Monitor Progress,Sledování pokroku
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Zvolte Číslo šarže
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Mzdové číslo
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Zahrnout UOM
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Záznamy o skladové knize a položky GL jsou přeúčtovány pro vybrané nákupní poukázky
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Aktualizovat formát tisku
DocType: Student,Siblings,Sourozenci
DocType: Purchase Invoice,Hold Invoice,Faktura pro zadržení
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Řádek {0}: Neplatný odkaz {1}
,Profitability Analysis,Analýza ziskovosti
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Nový název účtu
DocType: Employee Benefit Claim,Expense Proof,Důkaz nákladů
DocType: Restaurant Order Entry Item,Served,Sloužil
DocType: Loan,Member,Člen
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Plán servisních jednotek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Drátový převod
DocType: Quality Review Objective,Quality Review Objective,Cíl kontroly kvality
DocType: Bank Reconciliation Detail,Against Account,Proti účtu
DocType: Projects Settings,Projects Settings,Nastavení projektů
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Skutečné množství {0} / Čekání na množství {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: Účet {2} nemůže být Skupinou
DocType: Prescription Duration,Prescription Duration,Doba trvání předpisu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Řádek {0}: Zadání debetu nelze propojit s {1}
DocType: Program,Intro Video,Intro Video
DocType: Purchase Invoice,Is Paid,Je placený
DocType: Account,Debit,Debet
,Item Balance (Simple),Zůstatek položky (jednoduchý)
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Objednávky vám pomohou naplánovat a sledovat vaše nákupy
DocType: Project,Project Type,Typ projektu
DocType: Program Enrollment Tool Student,Student Batch Name,Jméno studentské dávky
,Qty to Receive,Množství pro příjem
DocType: Agriculture Task,Previous Business Day,Předchozí pracovní den
DocType: Travel Request Costing,Sponsored Amount,Sponzorovaná částka
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Před odesláním připomínky vyčkejte 3 dny.
DocType: Sales Invoice Item,Qty as per Stock UOM,Množství podle skladem UOM
DocType: Opening Invoice Creation Tool Item,Quantity,Množství
DocType: Delivery Stop,Estimated Arrival,odhadovaný příjezd
,Trial Balance for Party,Zkušební zůstatek pro stranu
DocType: Employee Separation,Employee Separation Template,Šablona pro oddělení zaměstnanců
DocType: Quality Objective,Unit,Jednotka
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Maximální výše výhody komponenty {0} přesahuje hodnotu {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Rizikový kapitál
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Datum ukončení fiskálního roku by měl být jeden rok od data zahájení fiskálního roku
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Denní připomenutí
DocType: Item,Default Sales Unit of Measure,Výchozí prodejní jednotka měření
apps/erpnext/erpnext/regional/report/gst_itemised_sales_register/gst_itemised_sales_register.js,Company GSTIN,Společnost GSTIN
DocType: Asset Finance Book,Rate of Depreciation,Míra odpisů
DocType: Support Search Source,Post Description Key,Popis klíče klíče
DocType: Loyalty Program Collection,Minimum Total Spent,Minimální útrata
DocType: Supplier Scorecard Period,Period Score,Skóre období
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Nelze vytvořit standardní kritéria. Přejmenujte prosím kritéria
DocType: Travel Itinerary,Arrival Datetime,Příchod Datetime
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Aktivita studentských LMS
DocType: Stock Reconciliation Item,Quantity Difference,Množství Rozdíl
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Řádek # {0}: Přidělená částka nesmí být vyšší než zbývající částka.
DocType: Sales Invoice Timesheet,Timesheet Detail,Podrobnosti časového rozvrhu
DocType: Employee Skill,Proficiency,Odbornost
DocType: SMS Log,Sent To,Odeslána
DocType: Item,Hub Publishing Details,Podrobnosti o publikování rozbočovače
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Student dávky pomáhají sledovat účast, hodnocení a poplatky pro studenty"
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Deklarovaná částka
DocType: Selling Settings,Auto close Opportunity after 15 days,Automatické zavření Příležitost po 15 dnech
DocType: Share Transfer,Issue,Problém
DocType: Volunteer,Availability Timeslot,Dostupnost Timeslot
DocType: Program,Program Abbreviation,Zkratka programu
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Datum zahájení projektu
DocType: Purchase Invoice,Additional DIscount Amount,Další částka DIscount
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebyla nalezena v tabulce &quot;Dodávky surovin&quot; v objednávce {1}
DocType: BOM,Manage cost of operations,Správa nákladů na operace
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Nejste oprávněni nastavit hodnotu Frozen
DocType: Contract,Lapsed,Lapovaný
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Investice
DocType: Inpatient Record,Date of Birth,Datum narození
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Chcete-li se zaregistrovat na Marketplace, musíte být uživatel s rolemi System Manager a Item Manager."
DocType: Item Attribute,Item Attribute Values,Hodnoty atributu položky
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Nejdříve prosím uložte pacienta
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Poloviční den by měl být mezi datem a datem
DocType: Inpatient Record,Expected Discharge,Očekávané vybití
DocType: Travel Request,Travel Type,Typ cesty
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Zákazník je povinen
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Pro položku {0} je zadáno neplatné množství. Množství by mělo být větší než 0.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Jako supervizor
DocType: Payroll Entry,Employees,Zaměstnanci
DocType: Sales Order,Billing Status,Stav fakturace
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Nejprve vyberte kategorii
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,Prohlížeč BOM
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Vytvořit studentské skupiny
DocType: Work Order Operation,In Minutes,V minutách
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Net Pay nemůže být nižší než 0
DocType: Maintenance Schedule,Schedules,Plány
DocType: Employee Training,Employee Training,Školení zaměstnanců
DocType: Loan,Rate of Interest (%) / Year,Úroková míra (%) / rok
DocType: Normal Test Items,Require Result Value,Vyžadovat hodnotu výsledku
DocType: Loan,Loan Type,Typ úvěru
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Kód položky je vyžadován v řádku č. {0}
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikace balíčku pro doručení (pro tisk)
DocType: Assessment Plan,Assessment Name,Název hodnocení
DocType: Travel Itinerary,Departure Datetime,Doba odjezdu Datetime
DocType: Delivery Note Item,From Warehouse,Ze skladu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Částka {0} {1} proti {2} {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Vytvořte variantu
DocType: Contract Template,Fulfilment Terms and Conditions,Podmínky plnění
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Datum zahájení by mělo být větší než datum založení
DocType: Pricing Rule,Price or Product Discount,Cena nebo sleva na výrobek
DocType: Quality Inspection Reading,Reading 1,Čtení 1
DocType: Student Admission Program,Maximum Age,Maximální věk
DocType: Payroll Period,Payroll Periods,Mzdové období
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Přenesené množství
DocType: Marketplace Settings,Marketplace Settings,Nastavení tržiště
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Objednávky nejsou povoleny pro {0} z důvodu postavení karty {1}.
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,Ceník není vybrán
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Pracovní stanice je uzavřena v následujících termínech podle seznamu prázdnin: {0}
DocType: Customer,"Reselect, if the chosen address is edited after save","Znovu vyberte, pokud je vybraná adresa upravena po uložení"
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Výchozí jednotka míry pro položku {0} nemůže být změněna přímo, protože jste již provedli některé transakce s jiným UOM. Budete muset vytvořit novou položku pro použití jiného výchozího uživatelského rozhraní."
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Změna zákaznické skupiny pro vybraného zákazníka není povolena.
DocType: Serial No,Creation Document Type,Typ dokumentu vytvoření
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostupné množství dávky ve skladu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Celkový součet faktur
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,Toto je kořenové území a nelze jej upravovat.
DocType: Patient,Surgical History,Chirurgická historie
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Strom postupů kvality.
DocType: Bank Account,Contact HTML,Kontaktovat HTML
,Employee Information,Informace o zaměstnancích
DocType: Assessment Plan,Examiner,Zkoušející
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Skutečná částka
DocType: Contract,Fulfilled,Splněny
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Řádek {0}: Zadejte umístění položky aktiva {1}
DocType: Project Task,View Timesheet,Zobrazit časový rozvrh
DocType: Purchase Invoice,Taxes and Charges Calculation,Výpočet daní a poplatků
DocType: Setup Progress Action,Action Document,Akční dokument
DocType: Clinical Procedure,Procedure Prescription,Postup Předpis
DocType: Guardian,Guardian Name,Jméno opatrovníka
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Úspěšně smířeno
DocType: Accounting Period,Period Name,Název období
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Vytáhněte položky z dodacího listu
DocType: Content Question,Content Question,Obsah Otázka
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Na skladě:
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Uložte před přiřazením úkolu.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Firma je manaţerská pro firemní účet
DocType: Sales Order Item,Delivery Warehouse,Skladový sklad
DocType: Shopify Settings,Enable Shopify,Povolit Shopify
DocType: Patient,Additional information regarding the patient,Další informace týkající se pacienta
DocType: Landed Cost Voucher,Purchase Receipts,Příjmy z nákupu
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Nový zaměstnanec
DocType: Purchase Invoice,Update Auto Repeat Reference,Aktualizace reference automatického opakování
DocType: Fees,Fees,Poplatky
DocType: Student Group,Student Group Name,Název studentské skupiny
DocType: Supplier Scorecard Scoring Standing,Employee,Zaměstnanec
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Dostupné datum použití by mělo být po datu nákupu
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Definujte stupeň pro práh 0%
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikace používající aktuální klíč nebudou mít přístup, jste si jisti?"
DocType: Quality Meeting,Minutes,Minut
DocType: Quiz Result,Correct,Opravit
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Celková deklarovaná částka
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Materiál
DocType: Appointment Type,Is Inpatient,Je Netrpělivý
DocType: Leave Encashment,Encashment Amount,Částka inkasa
DocType: BOM,Conversion Rate,Míra konverze
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,výkonný ředitel
apps/erpnext/erpnext/projects/doctype/project/project.js,Set tasks in this project as cancelled?,Nastavit úkoly v tomto projektu jako zrušené?
DocType: Bin,Reserved Qty for sub contract,Vyhrazené množství pro subkontrakt
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Vytvořit položku platby
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Odeslat Proof
DocType: Payment Term,Credit Months,Úvěrové měsíce
DocType: Bank Guarantee,Providing,Poskytování
DocType: Sales Invoice,Total Billing Amount,Celková částka fakturace
DocType: Maintenance Visit,Maintenance Visit,Návštěva údržby
DocType: Item,Country of Origin,Země původu
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kritéria pro analýzu zemědělství
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Dodatečná složka mzdy existuje.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Potraviny
DocType: Restaurant Table,Minimum Seating,Minimální sezení
DocType: Vital Signs,Furry,Kožešinový
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud je seskupen podle účtu"
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,Bankovní záznamy
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Crop Cycle,LInked Analysis,LInked analýza
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Platný od data musí být menší než platný datum.
DocType: Additional Salary,Salary Component,Platová složka
DocType: Asset Maintenance Team,Maintenance Team Members,Členové týmu údržby
DocType: Student Admission Program,Minimum Age,Minimální věk
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,K dispozici Prodej
DocType: Purchase Invoice,Taxes and Charges Deducted,Odpočet daně a poplatků
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Vytvořit laboratorní test
DocType: Hotel Settings,Hotel Settings,Nastavení hotelu
DocType: Naming Series,Select Transaction,Vyberte Transakci
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Deklaruj ztracený
DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
DocType: Chart of Accounts Importer,Chart Tree,Strom grafu
DocType: Contract,Contract,Smlouva
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Vyberte více typů programů pro více než jedno sbírkové pravidlo.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} pro {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno Množství) je povinné
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",např. &quot;Základní škola&quot; nebo &quot;Univerzita&quot;
DocType: Pricing Rule,Apply Multiple Pricing Rules,Použít pravidla pro více cen
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Posláno Pozvánka
DocType: Item,No of Months,Počet měsíců
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Sériová čísla vyžadovaná pro serializovanou položku {0}
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Kusovník (BOM)
DocType: Accounts Settings,Allow Stale Exchange Rates,Povolit zastaralé směnné kurzy
DocType: BOM,Website Description,Popis webových stránek
DocType: POS Closing Voucher,Expense Details,Podrobnosti o nákladech
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Od Range musí být menší než To Range
DocType: Homepage,Products to be shown on website homepage,"Produkty, které mají být zobrazeny na domovské stránce webu"
DocType: Tally Migration,Is Master Data Processed,Zpracovává se kmenová data
DocType: Item Price,Quantity  that must be bought or sold per UOM,"Množství, které musí být zakoupeno nebo prodáno za UOM"
DocType: Project,Total Sales Amount (via Sales Order),Celková prodejní částka (prostřednictvím objednávky odběratele)
apps/erpnext/erpnext/utilities/user_progress.py,Box,Box
DocType: QuickBooks Migrator,Default Cost Center,Výchozí nákladové středisko
DocType: Purchase Order Item,Billed Amt,Fakturovaný Amt
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},Nastavte výchozí hodnotu {0} ve společnosti {1}
DocType: Cheque Print Template,Distance from left edge,Vzdálenost od levého okraje
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Bod 4
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Záloha zaplacená proti {0} {1} nemůže být větší než Grand Total {2}
DocType: Account,Income Account,Účet příjmů
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Všechny sklady
DocType: Contract,Signee Details,Podrobnosti o signee
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Procurement
DocType: Item Group,Check this if you want to show in website,"Zaškrtněte toto, pokud chcete zobrazit na webu"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Fiskální rok {0} nebyl nalezen
DocType: Bank Statement Settings,Bank Statement Settings,Nastavení výpisu z účtu
DocType: Quality Procedure Process,Link existing Quality Procedure.,Propojit stávající postup kvality.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Importovat graf účtů ze souborů CSV / Excel
DocType: Appraisal Goal,Score (0-5),Skóre (0-5)
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Atribut {0} vybraný vícekrát v tabulce atributů
DocType: Purchase Invoice,Debit Note Issued,Vydané debetní oznámení
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Vyberte položku, kde je položka &quot;Je skladem položka&quot; &quot;Ne&quot; a &quot;Je položka prodeje&quot; &quot;Ano&quot; a neexistuje žádný jiný produktový balíček"
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Zaměstnanec {0} třídy {1} nemá žádné výchozí zásady pro ponechání
DocType: Leave Policy Detail,Leave Policy Detail,Opustit podrobnosti politiky
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Sklad nebyl nalezen v systému
DocType: Healthcare Practitioner,OP Consulting Charge,OP Poplatek za poradenství
DocType: Bank Statement Transaction Payment Item,Invoices,Faktury
DocType: Currency Exchange,Currency Exchange,Směnárna
DocType: Payroll Entry,Fortnightly,Čtrnáctidenní
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Sériové číslo {0} není skladem
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Požadavek na materiál nebyl vytvořen, protože množství surovin je již k dispozici."
DocType: Woocommerce Settings,Creation User,Vytvoření uživatele
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všech komunikací typu e-mailu, telefonu, chatu, návštěvy atd."
DocType: Asset Settings,Asset Settings,Nastavení aktiv
DocType: Compensatory Leave Request,Worked On Holiday,Pracoval na dovolené
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Musí být vyžadováno umístění nebo zaměstnanec
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Položka {0} bude zrušena
DocType: Course Scheduling Tool,Course End Date,Datum ukončení kurzu
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Opportunity From field is mandatory,Pole Opportunity From je povinné
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Upozornění: Ponechat aplikaci obsahuje následující data bloku
DocType: Asset Maintenance Task,Preventive Maintenance,Preventivní údržba
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Ústav Zkratka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Účet rozdílu musí být účet typu aktiv / pasiv, protože toto odsouhlasení zásob je vstupním záznamem"
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Datum ukončení smlouvy musí být větší než datum připojení
DocType: Employee Grade,Default Leave Policy,Výchozí politika ponechání
DocType: Daily Work Summary Group,Select Users,Vyberte možnost Uživatelé
DocType: Workstation,Net Hour Rate,Čistá hodinová sazba
DocType: Clinical Procedure,Age,Stáří
DocType: Travel Request,Event Details,Podrobnosti události
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,Nasbíral Měsíčně
apps/erpnext/erpnext/projects/doctype/project/project.js,Save the document first.,Nejprve uložte dokument.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Aktualizace nákladů
DocType: Sales Order,Fully Delivered,Plně dodáno
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Zadejte prosím společnost jako první
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
DocType: Dosage Strength,Dosage Strength,Dávková síla
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Vyplňte formulář a uložte jej
DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti zápisu
DocType: Subscription Invoice,Subscription Invoice,Faktura pro předplatné
DocType: Leave Allocation,Total Leaves Encashed,Total Leaves Encashed
DocType: Quality Inspection,Verified By,Ověřeno
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Získejte faktury
DocType: Invoice Discounting,Settled,Usadil
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Znovu otevřít
DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
DocType: Purchase Invoice,Release Date,Datum vydání
DocType: Purchase Invoice,Advances,Zálohy
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Zadejte podmínky pro výpočet částky přepravy
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Technologie
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Řádek lze odkazovat pouze v případě, že typ poplatku je „Na předchozí částku řádku“ nebo „Celkový počet řádků v předchozím řádku“"
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Je-li zaškrtnuto, Ne. Pracovní dny budou zahrnovat svátky, což sníží hodnotu Platu za den"
DocType: Location,Location Name,Název umístění
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatří společnosti {3}
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Zbývající výhody (ročně)
DocType: Asset Finance Book,Depreciation Start Date,Datum zahájení odpisování
DocType: Activity Cost,Billing Rate,Fakturační kurz
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Upozornění: Další {0} # {1} existuje proti položce {2}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Please enable Google Maps Settings to estimate and optimize routes,"Chcete-li odhadnout a optimalizovat trasy, povolte nastavení Map Google"
DocType: Supplier Scorecard Criteria,Max Score,Maximální skóre
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Repayment Start Date cannot be before Disbursement Date.,Datum začátku splácení nemůže být před datem výplaty.
DocType: Support Search Source,Support Search Source,Zdroj vyhledávání podpory
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Finanční služby
DocType: Volunteer,Availability,Dostupnost
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Strom procedur
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Povolit přidávání položek v transakci několikrát
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nebyl odeslán
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Zpětné proplachování surovin z nedokončeného skladu
DocType: Maintenance Team Member,Maintenance Team Member,Člen týmu údržby
apps/erpnext/erpnext/config/accounting.py,Setup custom dimensions for accounting,Nastavení vlastních dimenzí pro účetnictví
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimální vzdálenost mezi řadami rostlin pro optimální růst
DocType: Employee Health Insurance,Health Insurance Name,Jméno zdravotního pojištění
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Aktiva akcií
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Further cost centers can be made under Groups but entries can be made against non-Groups,"Další nákladová střediska mohou být vytvořena v rámci skupin, ale mohou být zadány proti skupinám"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Horní příjem
DocType: Company,Discount Allowed Account,Účet s povolenou slevou
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Restartujte předplatné
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit rychlost, pokud BOM zmínil agianst jakékoliv položky"
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,Přihlaste se prosím jako jiný uživatel a zaregistrujte se na Marketplace
DocType: Asset,Insurance Details,Podrobnosti pojištění
DocType: Subscription,Past Due Date,Datum splatnosti
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,No GST No. found for the Company.,Pro společnost nebylo nalezeno žádné číslo GST.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Z Pin Code
DocType: Contract,Signed On,Podepsáno
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Účetní záznam pro {2} lze provést pouze v měně: {3}
DocType: Assessment Criteria,Assessment Criteria,Kritéria hodnocení
DocType: Lab Test Template,Is Billable,Je fakturovatelný
DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,"Kompenzační dny žádostí o dovolenou, které nejsou v platné dovolené"
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Součet bodů za všechny cíle by měl být 100. Je to {0}
DocType: BOM,Scrap Items,Položky šrotu
DocType: Special Test Template,Result Component,Výsledek Komponenta
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Uveďte prosím základní a HRA komponent ve společnosti
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} nepatří společnosti {1}
DocType: Attendance Request,Half Day Date,Datum půl dne
DocType: Delivery Note,Billing Address Name,Název fakturační adresy
,GST Itemised Purchase Register,GST Itemized Purchase Register
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Alternativní položka
DocType: Certification Application,Name of Applicant,Jméno žadatele
DocType: Leave Type,Earned Leave,Zasloužená dovolená
DocType: GSTR 3B Report,June,červen
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Řádek {0}: Pro položku {1} je vyžadováno nákladové středisko
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Může být schválen {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jednotka měření {0} byla zadána více než jednou do tabulky faktoru konverzí
DocType: Purchase Invoice Item,Net Rate (Company Currency),Čistá sazba (měna společnosti)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,Všechny kusovníky
DocType: Department,Days for which Holidays are blocked for this department.,"Dny, pro které jsou pro toto oddělení blokovány svátky."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Nelze odeslat, Zaměstnanci jsou povinni označit účast"
DocType: BOM,Quality Inspection Template,Šablona kontroly kvality
DocType: Plant Analysis,Result Datetime,Výsledek Datetime
DocType: Purchase Taxes and Charges,Valuation,Ocenění
,Student Monthly Attendance Sheet,Student Měsíční docházkový list
DocType: Academic Term,Term End Date,Datum ukončení termínu
DocType: Pricing Rule Detail,Child Docname,Dětské jméno
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Služby
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Nelze nastavit množství menší než přijaté množství
DocType: Purchase Order Item,Supplier Part Number,Číslo dílu dodavatele
DocType: Lab Test Template,Standard Selling Rate,Standardní prodejní kurz
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Nastavte prosím aktivní menu pro restauraci {0}
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,"Chcete-li přidat uživatele do služby Marketplace, musíte být uživatel s rolemi System Manager a Item Manager."
DocType: Asset Finance Book,Asset Finance Book,Finanční správa majetku
DocType: Quality Goal Objective,Quality Goal Objective,Cíl Cíle kvality
DocType: Employee Transfer,Employee Transfer,Převod zaměstnanců
,Sales Funnel,Prodejní nálevka
DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
DocType: Accounts Settings,Accounts Frozen Upto,Účty Zmrazené nahoru
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Není co editovat.
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations",Operace {0} delší než jakákoli dostupná pracovní doba v pracovní stanici {1} rozdělte operaci do více operací
DocType: Item Variant Settings,Do not update variants on save,Neaktualizujte varianty při ukládání
DocType: Grading Scale Interval,Threshold,Práh
DocType: Timesheet,% Amount Billed,Vyúčtovaná částka v%
DocType: Warranty Claim,Resolved By,Vyřešeno do
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Přidejte uživatele do své organizace, kromě vás."
DocType: Global Defaults,Default Company,Standardní společnost
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Hotovostní účet bude použit pro vytvoření prodejní faktury
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Zakázka odběratele {0} je {1}
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Zpoždění platby (dny)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Zadejte podrobnosti o odpisech
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Očekávaný termín dodání by měl být po datu objednávky odběratele
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neplatný atribut
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Vyberte položku BOM proti položce {0}
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Typ faktury
DocType: Price List,Price List Master,Ceník Master
,Lost Opportunity,Ztracená příležitost
DocType: Maintenance Visit,Maintenance Date,Datum údržby
DocType: Volunteer,Afternoon,Odpoledne
DocType: Vital Signs,Nutrition Values,Hodnoty výživy
DocType: Vital Signs,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 / 101,3 ° F nebo trvalá teplota&gt; 38 ° C / 100,4 ° F)"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC Reversed
DocType: Project,Collect Progress,Sbírejte průběh
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Energie
,Items To Be Requested,"Položky, které mají být požadovány"
DocType: Soil Analysis,Ca/K,Ca / K
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Pracovní příkaz již vytvořen pro všechny položky s kusovníkem
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Fakturovaná částka
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Zadaná hodnota aktuálního kilometru by měla být větší než počáteční kilometr vozidla {0}
DocType: Employee Transfer Property,Employee Transfer Property,Převod majetku zaměstnance
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Probíhající aktivity
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,Seznam několika vašich zákazníků. Mohou to být organizace nebo jednotlivci.
DocType: Bank Guarantee,Bank Account Info,Informace o bankovním účtu
DocType: Quality Goal,Weekday,Všední den
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Název Guardian1
DocType: Salary Component,Variable Based On Taxable Salary,Proměnná na základě zdanitelného platu
DocType: Accounting Period,Accounting Period,Účetní období
DocType: Company,Standard Working Hours,Standardní pracovní doba
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Na skladě
DocType: Amazon MWS Settings,Market Place Account Group,Skupina tržních účtů
DocType: Stock Reconciliation Item,Before reconciliation,Před smířením
DocType: Fee Component,Fees Category,Kategorie poplatků
DocType: Sales Order,%  Delivered,% Dodáno
DocType: Sales Invoice,Redemption Cost Center,Středisko zpětného odkupu
DocType: Vital Signs,Respiratory rate,Dechová frekvence
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Povinné pole - Get Students From
DocType: Item Group,Item Classification,Klasifikace položky
DocType: Asset,Is Existing Asset,Je existující aktivum
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit návštěvy materiálu {0} před zrušením této návštěvy údržby
DocType: Workstation,Workstation Name,Název pracovní stanice
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Řádek # {0}: Stav musí být {1} pro Invoice Discounting {2}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Přenos materiálu
DocType: Delivery Note,% Installed,% Instalován
DocType: Agriculture Task,Agriculture Task,Úkol zemědělství
DocType: Dosage Form,Dosage Form,Forma dávkování
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Nejprve vyberte program
DocType: Project,Expected Start Date,Očekávané datum zahájení
DocType: Share Transfer,Share Transfer,Přenos akcií
apps/erpnext/erpnext/config/hr.py,Leave Management,Správa dovolené
DocType: Loan Application,Total Payable Interest,Úroky celkem
DocType: Employee,Current Address,Současná adresa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Nelze {0} {1} {2} bez záporné faktury
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Transakce není povolena proti zastavenému pracovnímu příkazu {0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Sklady s existující transakcí nelze převést na účet.
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odpočet daně pro nepotvrzený důkaz osvobození od daně
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Datum aktualizace Datum aktualizace
DocType: Delivery Trip,Delivery Stops,Přerušení dodávek
DocType: Setup Progress,Setup Progress,Nastavení Pokrok
,Ordered Items To Be Billed,Objednané položky k vyúčtování
DocType: Taxable Salary Slab,To Amount,Částka
DocType: Purchase Invoice,Is Return (Debit Note),Is Return (Debet Note)
apps/erpnext/erpnext/config/desktop.py,Getting Started,Začínáme
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Spojit
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Nelze změnit datum zahájení fiskálního roku a datum ukončení fiskálního roku po uložení fiskálního roku.
DocType: Production Plan,Get Material Request,Získat požadavek na materiál
DocType: C-Form Invoice Detail,Invoice No,Faktura číslo
DocType: Pricing Rule,Max Qty,Max
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Řádek {0}: Přidělená částka {1} musí být nižší nebo rovna částce částky platby {2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Kusů
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Hub User,Hub User,Uživatel rozbočovače
DocType: Lab Test Template,No Result,Žádný výsledek
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Porovnání transakcí s fakturami
DocType: Sales Invoice,Commission,Komise
DocType: Sales Invoice Item,Sales Order Item,Položka zakázky odběratele
DocType: Maintenance Schedule Detail,Actual Date,Aktuální datum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro sériové číslo {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Řádek {0}: Kurz je povinný
DocType: Purchase Invoice,Select Supplier Address,Vyberte adresu dodavatele
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Zadejte prosím tajné rozhraní API pro spotřebitele
DocType: Program Enrollment Fee,Program Enrollment Fee,Poplatek za zápis programu
DocType: Serial No,Warranty Expiry Date,Datum vypršení záruky
DocType: Hotel Room Pricing,Hotel Room Pricing,Ceny hotelových pokojů
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Zdanitelné dodávky (jiné než nulové, s nulovým ratingem a osvobozené od daně)"
DocType: Issue,Resolution By,Rozlišení By
DocType: Loyalty Program,Customer Territory,Zákaznické území
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Poslední sdělení
DocType: Timesheet,Total Billed Hours,Celkový počet účtovaných hodin
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Chybí aktuální faktura {0}
DocType: Healthcare Settings,Patient Registration,Registrace pacienta
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Faktura dodavatele neexistuje v nákupní faktuře {0}
DocType: Service Day,Workday,Pracovní den
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Žádné položky přidány do košíku
DocType: Target Detail,Target Qty,Cíl Qty
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items",Pro sloučení musí být pro obě položky stejné vlastnosti
DocType: Drug Prescription,Drug Prescription,Lék na předpis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,Budovy
DocType: Student Applicant,Application Date,Datum aplikace
DocType: Assessment Result,Result,Výsledek
DocType: Leave Block List,Leave Block List Allowed,Nechte seznam bloků povolen
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Řádek # {0}: Rychlost nesmí být větší než rychlost používaná v {1} {2}
DocType: Purchase Order Item,Blanket Order,Objednávka deky
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Účast zaměstnanců {0} je již označena
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Posouzení Výsledek záznamu {0} již existuje.
DocType: Purchase Invoice,Rounding Adjustment,Úprava zaokrouhlování
DocType: Quality Review Table,Quality Review Table,Tabulka kvality
DocType: Member,Membership Expiry Date,Datum ukončení členství
DocType: Asset Finance Book,Expected Value After Useful Life,Očekávaná hodnota po užitečné životnosti
DocType: GSTR 3B Report,November,listopad
DocType: Loan Application,Rate of Interest,Úroková míra
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Položka platby bankovního výpisu
DocType: Restaurant Reservation,Waitlisted,Waitlisted
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Musíte povolit Nákupní košík
DocType: HR Settings,Leave Status Notification Template,Ponechte šablonu oznámení o stavu
DocType: Salary Slip,Leave Without Pay,Odejít bez placení
DocType: Clinical Procedure Item,Actual Qty (at source/target),Skutečné množství (u zdroje / cíle)
DocType: Purchase Invoice,Tax ID,DIČ
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Viz minulé objednávky
DocType: Stock Reconciliation Item,Current Qty,Aktuální množství
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},Konverzní faktor UOM je vyžadován v řádku {0}
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Daňová tabulka detailů je převzata z položky master jako řetězec a uložena v tomto poli. Používá se pro daně a poplatky
DocType: Appraisal Goal,Key Responsibility Area,Oblast klíčových odpovědností
DocType: Purchase Receipt Item,Sample Quantity,Vzorové množství
DocType: Journal Entry Account,Expense Claim,Náklady reklamace
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Datum zahájení a datum uzavření by měly být ve stejném fiskálním roce
DocType: Soil Texture,Silt Composition (%),Slabé složení (%)
DocType: Tax Withholding Rate,Tax Withholding Rate,Srážková sazba daně
DocType: Restaurant,Default Tax Template,Výchozí šablona daně
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,Převod aktiv
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead%
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Invoice {0} first,Nejprve prosím zrušte nákupní fakturu {0}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Kompletní úloha
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Vyberte možnost Možný dodavatel
DocType: POS Profile,Customer Groups,Skupiny zákazníků
DocType: Hub Tracked Item,Hub Category,Kategorie rozbočovače
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Nabídky jsou návrhy, nabídky, které jste zaslali svým zákazníkům"
DocType: Quality Inspection Reading,Reading 5,Čtení 5
DocType: Shopping Cart Settings,Display Settings,Nastavení obrazovky
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Nastavte počet odpisů rezervovaných
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,S čím potřebuješ pomoci?
DocType: Journal Entry,Printing Settings,Nastavení tisku
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Bankovnictví
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Nákup faktur Advance
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Purchase Invoice Item,PR Detail,PR Detail
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Fakturační adresa je stejná jako adresa pro odesílání
DocType: Account,Cash,Hotovost
DocType: Employee,Leave Policy,Opustit politiku
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Adresa studenta
DocType: GST Account,CESS Account,Účet CESS
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Nákladové středisko je vyžadováno pro účet &#39;Zisk a ztráta&#39; {2}. Nastavte prosím pro společnost výchozí výrobní středisko.
apps/erpnext/erpnext/accounts/doctype/account/account.py,"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",Při vytváření účtu pro podřízenou společnost {0} nebyl nalezen nadřazený účet {1}. Vytvořte prosím rodičovský účet v odpovídajícím certifikátu pravosti
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Hlavní kniha
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Připomenutí pro aktualizaci GSTIN Sent
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Vyberte dny
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Další Kontakt By nemůže být stejný jako hlavní e-mailová adresa
DocType: Packing Slip,To Package No.,Na číslo balíčku
DocType: Course,Course Name,Název kurzu
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Pro aktivum {0} je vyžadováno sériové číslo
DocType: Asset,Maintenance,Údržba
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Ověřit prodejní cenu položky proti kupní ceně nebo míře ocenění
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Byly vytvořeny následující pracovní příkazy:
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,IFSC Code,Kód IFSC
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Režim platby
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po výši slevy
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Získejte Dodavatelé
DocType: Purchase Invoice Item,Valuation Rate,Míra ocenění
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Výchozí nastavení pro Nákupní košík
DocType: Quiz,Score out of 100,Skóre ze 100
DocType: Manufacturing Settings,Capacity Planning,Plánovaní kapacity
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Přejděte na stránky Instruktoři
DocType: Activity Cost,Projects,Projekty
DocType: Item Barcode,Barcode Type,Typ čárového kódu
DocType: Employee Incentive,Incentive Amount,Incentivní částka
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na možnost Nastavit jako výchozí."
DocType: C-Form,II,II
DocType: Cashier Closing,From Time,Od času
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Zpráva Podrobnosti o variantě
,BOM Explorer,BOM Explorer
DocType: Currency Exchange,For Buying,Pro nákup
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Sloty pro {0} nejsou přidány do plánu
DocType: Target Detail,Target Distribution,Distribuce cíle
DocType: Staffing Plan,Staffing Plan Details,Podrobnosti o personálním plánu
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatný. Měna účtu musí být {1}
DocType: Pricing Rule,Rule Description,Popis pravidla
DocType: Delivery Trip,Total Estimated Distance,Celková odhadovaná vzdálenost
DocType: Opportunity Lost Reason,Lost Reason,Ztracený důvod
DocType: Depreciation Schedule,Make Depreciation Entry,Vytvořit odpisový záznam
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Sériová čísla {0} nepatří k místu {1}
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit zmrazené položky
DocType: Employee,Health Concerns,Obavy o zdraví
DocType: Company,Company Info,firemní informace
DocType: Activity Cost,Activity Cost,Náklady na činnost
DocType: Journal Entry,Payment Order,Platební příkaz
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Ceny
,Item Delivery Date,Datum doručení položky
DocType: Quality Goal,January-April-July-October,Leden-duben-červenec-říjen
DocType: Purchase Order Item,Warehouse and Reference,Sklad a reference
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na účet
DocType: Soil Texture,Clay Composition (%),Složení jílu (%)
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,Číslo kusovníku pro hotovou dobrou položku
DocType: Journal Entry,User Remark,Uživatelská poznámka
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Vaše objednávka je k dodání!
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer","Typ platby musí být typu Receive, Pay a Internal Transfer"
DocType: HR Settings,Payroll Settings,Nastavení mezd
DocType: GST HSN Code,GST HSN Code,Kód GST HSN
DocType: Period Closing Voucher,Period Closing Voucher,Poukaz na uzavření období
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Název Guardian2
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Zadejte prosím účet výdajů
DocType: Employee,Resignation Letter Date,Datum odstoupení
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Upload Attendance,Attendance To Date,Doposud
DocType: Invoice Discounting,Loan Start Date,Datum zahájení úvěru
DocType: Workstation,Consumable Cost,Náklady na spotřební materiál
DocType: Leave Type,Encashment,Inkaso
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Příjmy z jiných zdrojů
DocType: Crop,Produced Items,Vyrobené položky
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',Stav schválení musí být „Schváleno“ nebo „Odmítnuto“
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Zobrazit nyní
DocType: Item Price,Valid Upto,Platné Nahoru
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Odkaz Doctype musí být jeden z {0}
DocType: Payment Request,Transaction Currency,Měna transakce
DocType: Loan,Repayment Schedule,Splátkový kalendář
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Vytvořte položku skladu vzorku
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Nastavit jako Otevřít
DocType: Job Card,Requested Qty,Požadované množství
DocType: POS Profile,Apply Discount On,Použít slevu na
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Vyhrazeno pro subdodavatele
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Varianta položky {0} existuje se stejnými atributy
DocType: Member,Membership Type,Typ členství
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,"Ukáží studentovi, že je přítomen ve Zprávě o měsíční účasti studentů"
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Minimální věk (dny)
DocType: Shopify Settings,Delivery Note Series,Série dodacích listů
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Povinné pole - akademický rok
DocType: Vehicle Log,Fuel Price,Cena paliva
DocType: Travel Itinerary,Mode of Travel,Způsob cestování
DocType: Special Test Items,Special Test Items,Speciální zkušební položky
DocType: Purchase Invoice,Edit Posting Date and Time,Upravit datum a čas účtování
DocType: Sales Order,Not Billed,Neúčtováno
DocType: Employee Transfer,Employee Transfer Detail,Detail převodu zaměstnanců
DocType: Project,Task Completion,Dokončení úkolu
DocType: Shopify Webhook Detail,Webhook ID,ID Webhook
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Cestovní výdaje
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Budoucí data nejsou povolena
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Řádek {0}: Nastavte prosím způsob platby v platebním rozvrhu
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Akademické období:
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Parametr kvality zpětné vazby
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Vyberte možnost Použít slevu na
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}: ,Řádek # {0}:
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Celkové platby
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Zadejte prosím účet pro změnu částky
DocType: Tax Withholding Account,Tax Withholding Account,Daňový srážkový účet
DocType: Account,Stock Received But Not Billed,"Zásoba přijata, ale není účtován"
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Přidejte účet do kořenové společnosti Company -% s
DocType: Sample Collection,Collected By,Shromážděný
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na vytvoření automatické žádosti o materiál
DocType: Asset Repair,Downtime,Přerušení
DocType: Cost Center,Cost Center Number,Číslo nákladového střediska
DocType: Driver,Applicable for external driver,Použitelné pro externí řidiče
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Začněte
DocType: Sales Invoice,Payment Due Date,Datum splatnosti platby
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Pokud má tato položka varianty, nelze ji vybrat v objednávkách odběratele atd."
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Byly vytvořeny následující plány kurzů
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Timesheet created:,Vytvořený časový rozvrh:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otevřít kusovník {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Převedeno
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Úvěr na účet musí být splatný účet
DocType: Item,Item Attribute,Atribut položky
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Cíl a postup
DocType: Asset,Frequency of Depreciation (Months),Frekvence odpisů (měsíců)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Nemovitost
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Návštěva učitelů rodičů
DocType: Employee Grade,Employee Grade,Zaměstnanecký stupeň
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Celkový počet {0} pro všechny položky je nula, může se stát, že byste měli změnit „Distribuční poplatky založené na“"
DocType: Sales Invoice Timesheet,Time Sheet,Rozvrh hodin
DocType: Hotel Room Reservation,Late Checkin,Pozdní Checkin
DocType: Project,Costing and Billing,Kalkulace nákladů a fakturace
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Celkem Odchozí
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Výchozí dohoda o úrovni služeb již existuje.
DocType: Packing Slip,If more than one package of the same type (for print),Pokud je více než jeden balíček stejného typu (pro tisk)
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,"Chcete-li získat záznamy, vyberte společnost a datum účtování"
DocType: Healthcare Practitioner,Default Currency,Výchozí měna
DocType: Sales Invoice,Packing List,Seznam balení
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Tajemník
DocType: Travel Itinerary,Gluten Free,Bezlepkový
DocType: Hub Tracked Item,Hub Node,Uzel rozbočovače
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,ID zaměstnance
DocType: Salary Structure Assignment,Salary Structure Assignment,Přiřazení mzdové struktury
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Daňové uzávěrky POS
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Akce Inicializováno
DocType: POS Profile,Applicable for Users,Platí pro uživatele
DocType: Training Event,Exam,Zkouška
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Byl nalezen nesprávný počet položek hlavní knihy. Možná jste v transakci vybrali nesprávný účet.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Prodejní potrubí
,Leaderboard,Žebříček
DocType: Account,Inter Company Account,Mezipodnikový účet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Uzavřený příkaz nelze zrušit. Zrušit pro zrušení.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} neexistuje
DocType: Job Opening,Planned number of Positions,Plánovaný počet pozic
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,Stav údržby musí být zrušen nebo dokončen k odeslání
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Vyberte prosím zákazníka
DocType: Account,Round Off,Zaokrouhlit
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Podmínky budou aplikovány na všechny vybrané položky.
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Konfigurovat
DocType: Hotel Room,Capacity,Kapacita
DocType: Installation Note Item,Installed Qty,Instalované množství
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Dávka {0} položky {1} je zakázána.
DocType: Hotel Room Reservation,Hotel Reservation User,Uživatel rezervačního systému
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday has been repeated twice,Pracovní den byl opakován dvakrát
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Skupina položek neuvedená v hlavní položce položky pro položku {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Chyba názvu: {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Území je vyžadováno v POS profilu
DocType: Purchase Invoice Item,Service End Date,Datum ukončení služby
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Citát
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Kurz musí být stejný jako {0} {1} ({2})
DocType: Service Level,Holiday List (ignored during SLA calculation),Seznam prázdnin (ignorováno při výpočtu SLA)
DocType: Student Admission Program,Student Admission Program,Studentský přijímací program
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Rodičovský účet {1} nemůže být hlavní knihou
DocType: Sales Order,% of materials billed against this Sales Order,% materiálů účtovaných proti této zakázce odběratele
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Účet platební brány v plánu {0} se liší od účtu platební brány v tomto požadavku na platbu
DocType: Stock Entry Detail,Subcontracted Item,Subdodavatelská položka
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Datum zahájení úvěru a doba úvěru jsou povinné pro uložení slevy na faktuře
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,"Účty standardních pohledávek, které mají být použity, nejsou-li nastaveny v položce Patient to book."
DocType: Student Attendance Tool,Students HTML,Studenti HTML
DocType: Student Guardian,Student Guardian,Student Guardian
DocType: GoCardless Settings,GoCardless Settings,Nastavení GoCardless
DocType: Delivery Note,Transport Receipt Date,Datum přijetí zásilky
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Zobrazit položky otevření
DocType: Vital Signs,Heart Rate / Pulse,Srdeční frekvence / puls
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Všechny hodnotící skupiny
DocType: Asset,Asset Name,Název aktiva
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Může existovat pouze jedna podmínka pravidla přepravy s hodnotou 0 nebo prázdnou hodnotou pro hodnotu „To Value“
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Optimizing routes.,Optimalizace tras.
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Tax / Shipping Title
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,K dnešnímu dni nemůže být stejný nebo menší než od data
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Přidal jste
DocType: Assessment Result,Total Score,Celkové skóre
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu v šabloně daně z prodeje a poplatků, vyberte ji a klikněte na tlačítko níže."
DocType: Budget,Cost Center,Nákladové středisko
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejního týmu by mělo být 100
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}","Nelze dodat sériové číslo {0} z položky {1}, protože je vyhrazeno k vyplnění objednávky odběratele {2}"
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,"Položka Platba byla změněna poté, co jste ji vytáhli. Prosím, znovu ho vytáhněte."
DocType: Employee,Bio / Cover Letter,Bio / průvodní dopis
DocType: Stock Ledger Entry,Stock Value Difference,Rozdíl hodnoty akcií
DocType: Academic Year,Academic Year Name,Název akademického roku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Bankovní účty
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Platební doba v řádku {0} je možná duplikát.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Odblokovat fakturu
DocType: Pricing Rule,Percentage,Procento
DocType: Sensitivity Test Items,Sensitivity Test Items,Položky testu citlivosti
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Vytvoření motivačních programů založených na zákaznících.
,Purchase Register,Nákupní rejstřík
DocType: Depreciation Schedule,Schedule Date,Plán Datum
DocType: Packing Slip,Package Weight Details,Podrobnosti o hmotnosti balení
DocType: Job Applicant,Job Opening,Zahájení práce
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Aktuální cena
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) proti objednávce {1} nemůže být větší než celkový součet ({2})
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Varianty položek aktualizovány
DocType: Item,Batch Number Series,Sériové číslo série
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Otevřené projekty
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Import Dodací listy z Shopify na zásilku
DocType: QuickBooks Migrator,Token Endpoint,Koncový bod tokenu
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,Seznam několika dodavatelů. Mohou to být organizace nebo jednotlivci.
DocType: Amazon MWS Settings,MWS Credentials,Požadavky na MWS
DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavení nákupního košíku
DocType: Sales Invoice Item,Enable Deferred Revenue,Povolit odložené příjmy
apps/erpnext/erpnext/config/help.py,Managing Projects,Správa projektů
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Zpráva odeslána
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},Stejná položka byla zadána vícekrát. {0}
DocType: Pricing Rule,Margin,Okraj
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; není ve fiskálním roce {2}
DocType: Fee Schedule,Fee Structure,Struktura poplatků
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Varianty atributů
DocType: Employee,Confirmation Date,Datum potvrzení
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Nastavte prosím výchozí seznam dovolené pro zaměstnance {0} nebo společnost {1}
DocType: Job Applicant Source,Job Applicant Source,Zdroj žadatele o zaměstnání
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otevření nástroje pro tvorbu faktur
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Účet {0} neexistuje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Ignorovat existující objednané množství
DocType: Material Request Item,Lead Time Date,Datum dodací lhůty
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Přehled pohledávek
DocType: Asset,Available-for-use Date,Datum k dispozici pro použití
DocType: HR Settings,Employee record is created using selected field. ,Záznam zaměstnance je vytvořen pomocí vybraného pole.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Řádek # {0}: Typ referenčního dokumentu musí být jeden z objednávek, nákupní faktury nebo položky deníku"
DocType: Payment Entry,Type of Payment,Typ platby
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,"Nechte pole prázdné, abyste mohli provést objednávky pro všechny dodavatele"
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,"Položka {0} byla ignorována, protože se nejedná o skladovou položku"
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",&quot;Položka poskytovaná zákazníkem&quot; nemůže mít sazbu ocenění
DocType: Soil Texture,Clay,Jíl
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} má v současné době {1} postavení dodavatele a nákupní objednávky tohoto dodavatele by měly být vydávány s opatrností.
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Pokud se jedná o variantu jiné položky, pak se z šablony nastaví popis, obrázek, cena, daně atd., Pokud to není výslovně uvedeno"
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Celkový cíl
DocType: Location,Longitude,Zeměpisná délka
DocType: Accounts Settings,Determine Address Tax Category From,Určete kategorii daně z adresy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Identifikace rozhodovacích činitelů
DocType: Stock Entry Detail,Reference Purchase Receipt,Referenční doklad o nákupu
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Získejte Faktury
DocType: Tally Migration,Is Day Book Data Imported,Je importována data denní knihy
,Sales Partners Commission,Komise obchodních partnerů
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Právní
DocType: Loan Application,Required by Date,Požadováno podle data
DocType: Quiz Result,Quiz Result,Výsledek kvízu
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Zavřít Úvěr
DocType: Lead,From Customer,Od zákazníka
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimální částka faktury
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Příbuzný
DocType: Drug Prescription,Description/Strength,Popis / síla
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Pracovní příkaz nelze vznést proti šabloně položky
DocType: Employee External Work History,Salary,Plat
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastavit stav
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Vstupní dodávky od ISD
,Vehicle Expenses,Náklady na vozidlo
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Nastavte prosím možnost Použít další slevu
DocType: Closed Document,Closed Document,Uzavřený dokument
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Vyberte týdenní den mimo den
DocType: Leave Type,Applicable After (Working Days),Použitelné po (pracovní dny)
DocType: Timesheet Detail,Hrs,Hrs
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritéria pro hodnocení dodavatelů
DocType: Amazon MWS Settings,FR,FR
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Parametr kvality šablony zpětné vazby
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Datum připojení musí být větší než datum narození
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum faktury
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Vytvořte laboratorní testy na prodejní faktuře
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Pro položku {0} nebyla nalezena žádná aktivní BOM. Dodání sériovým číslem nelze zajistit
DocType: Employee Education,Post Graduate,Postgraduální
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Účet {0} byl zadán vícekrát
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Platit proti nároku nárok
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,Hlavní částka
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Hlavní
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Sériové číslo {0} neexistuje
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Vyberte prosím Program
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Rozvrh Vypuštění
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Nastavit skladovatelnost položek ve dnech, nastavit dobu použitelnosti na základě výrobního data plus životnost"
DocType: Bank Reconciliation,Get Payment Entries,Získání položek platby
DocType: Amazon MWS Settings,Max Retry Limit,Maximální limit opakování
DocType: Woocommerce Settings,Endpoint,Koncový bod
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je vyžadováno v řádku {0} v tabulce daní pro typ {1}
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Směnárna musí být platná pro nákup nebo prodej.
DocType: Cheque Print Template,Cheque Width,Zkontrolujte šířku
DocType: Woocommerce Settings,Secret,Tajemství
DocType: Restaurant Order Entry,Current Order,Aktuální objednávka
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,Položka musí být přidána pomocí tlačítka „Získat položky z nákupních dokladů“
,Delay Days,Dny zpoždění
DocType: Company,Default Income Account,Účet výchozích příjmů
DocType: Patient Appointment,Get prescribed procedures,Získejte předepsané postupy
DocType: Lead,Market Segment,Segment trhu
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Nastaveno jako dokončeno
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Dokončené množství nemůže být větší než „Množství k výrobě“
apps/erpnext/erpnext/config/support.py,Service Level.,Úroveň služby.
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
DocType: Fiscal Year,Year Start Date,Rok Datum zahájení
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hour Rate / 60) * Aktuální provozní doba
DocType: C-Form,Received Date,Obdržené datum
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,Finanční / účetní rok.
DocType: Pricing Rule,Pricing Rule,Pravidlo cen
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Volitelný seznam dovolené není nastaven na dobu dovolené {0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Nastavte ID uživatele pole v záznamu zaměstnance nastavit zaměstnance role
apps/erpnext/erpnext/support/doctype/issue/issue.js,Time To Resolve,Čas k vyřešení
DocType: Training Event,Training Event,Tréninková akce
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normální klidový krevní tlak u dospělých je přibližně 120 mmHg systolický a 80 mmHg diastolický, zkráceně &quot;120/80 mmHg&quot;"
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,"Pokud je mezní hodnota nulová, systém načte všechny položky."
DocType: Item,Copy From Item Group,Kopírovat ze skupiny položek
,Bank Remittance,Bankovní převod
apps/erpnext/erpnext/stock/stock_ledger.py,"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","Pro položku {0}, která je nutná k provedení účetních zápisů pro {1} {2}, nebyla nalezena míra ocenění. Pokud položka funguje v položce {1} jako nulová hodnota, uveďte to v tabulce položek {1}. V opačném případě vytvořte příchozí transakci transakce pro danou položku nebo zmeňte kurz ocenění v záznamu položky a poté zkuste odeslat / zrušit tento záznam"
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Poloviční den by měl být mezi dnem a dnem
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Záznam o akruálním tarifu pro platy od {0} do {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Příjem materiálu
DocType: Employee Transfer,Re-allocate Leaves,Znovu přidělte listy
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},Datum by mělo být v rámci fiskálního roku. Předpokládané datum = {0}
DocType: Employee Promotion,Employee Promotion Details,Podrobnosti o propagaci zaměstnance
DocType: Project User,Project Status,Stav projektu
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Účet s existující transakcí nelze odstranit
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,Toto je skupina dodavatelů root a nelze ji upravovat.
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Nelze najít cestu pro
DocType: Item Customer Detail,Item Customer Detail,Detail zákazníka
DocType: Grant Application,Assessment  Mark (Out of 10),Značka hodnocení (z 10)
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
DocType: Lab Test,LabTest Approver,Schvalovací program LabTest
DocType: Task,Is Milestone,Je milník
DocType: Program Enrollment Tool,Get Students,Získejte studenty
DocType: Program Enrollment,Self-Driving Vehicle,Vozidlo s vlastním pohonem
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Položka {0} musí být pevnou položkou aktiv
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Pronájem kanceláře
DocType: Asset,In Maintenance,V Údržbě
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nelze změnit vlastnosti varianty po transakci s akciemi. Budete k tomu muset provést novou položku.
DocType: Purchase Invoice,Unpaid,Neplacené
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Aktualizovat název / číslo účtu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Internovat
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Zobrazit pouze POS
DocType: Cashier Closing,Custody,Péče
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,Od Datum nemůže být větší než Datum
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Podle vaší přidělené mzdové struktury nemůžete žádat o dávky
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Nastavení výchozích hodnot se nezdařilo
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Číslo účtu {0} již bylo použito v účtu {1}
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-mail mzdy skluzu na zaměstnance na základě preferovaného e-mailu vybraného v zaměstnance
DocType: Company,Asset Depreciation Cost Center,Nákladové středisko odpisů aktiv
DocType: Lead,Address Desc,Adresa Popis
DocType: Woocommerce Settings,Enable Sync,Povolit synchronizaci
DocType: Student Applicant,Approved,Schválený
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Od data by mělo být v rámci fiskálního roku. Za předpokladu od data = {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,Nastavte skupinu dodavatelů v Nastavení nákupu.
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Dočasné otevírání účtu
DocType: Purchase Invoice,Cash/Bank Account,Hotovostní / bankovní účet
DocType: Quality Meeting Table,Quality Meeting Table,Tabulka kvality setkání
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termín Datum zahájení nemůže být starší než datum začátku akademického roku, na který je termín navázán (akademický rok {}). Opravte data a zkuste to znovu."
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Rozsah stárnutí 1
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Doklady o osvobození od daně
DocType: Purchase Invoice,Price List Currency,Ceník Měna
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Dávka:
DocType: Purchase Invoice,Total Advance,Celková záloha
DocType: Employee,Emergency Phone,Nouzový telefon
DocType: Inpatient Occupancy,Check Out,Překontrolovat
DocType: Invoice Discounting,Loan Period,Období úvěru
DocType: Loyalty Program,Conversion Factor,Faktor konverze
DocType: BOM Operation,Operating Cost(Company Currency),Provozní náklady (měna společnosti)
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení nákupního košíku online, jako jsou přepravní pravidla, ceník atd."
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Upravit podrobnosti publikování
DocType: Soil Texture,Soil Texture Criteria,Kritéria textury půdy
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Vybrat oddělení ...
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Měna by měla být stejná jako měna Ceníku: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Řádek # {0}: Specifikujte sériové číslo položky {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimální přípustná hodnota
DocType: Stock Entry,Source Warehouse Address,Adresa zdrojového skladu
DocType: Compensatory Leave Request,Compensatory Leave Request,Žádost o kompenzační dovolenou
DocType: Lead,Mobile No.,Mobilní číslo
DocType: GSTR 3B Report,July,červenec
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Způsobilé ITC
DocType: Fertilizer,Density (if liquid),Hustota (je-li kapalina)
DocType: Employee,External Work History,Historie zahraniční práce
DocType: Quality Inspection,Outgoing,Odchozí
DocType: Email Digest,Add Quote,Přidat nabídku
DocType: Inpatient Record,Discharge,Vybít
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Rozvrh kurzu
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Detail položky Moudrá daň
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Dodávky do držáků UIN
apps/erpnext/erpnext/hooks.py,Request for Quotations,Žádost o nabídky
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Měna nemůže být změněna po zadávání pomocí jiné měny
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,Nelze nastavit množství menší než dodané množství
apps/erpnext/erpnext/config/accounting.py,Bank/Cash transactions against party or for internal transfer,Bankovní / hotovostní transakce proti straně nebo pro interní převod
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Zakázaná šablona nesmí být výchozí šablonou
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Mark Absent
DocType: Salary Component,Statistical Component,Statistická složka
DocType: Bin,Reserved Quantity,Rezervované množství
DocType: Vehicle,Insurance Company,Pojišťovna
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Note: Item {0} entered multiple times,Poznámka: Položka {0} zadaná vícekrát
DocType: Plant Analysis,Collection Datetime,Datetime
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Celkem bylo dosaženo
DocType: Course Topic,Topic,Téma
DocType: Employee Promotion,Promotion Date,Datum promo akce
DocType: Tax Withholding Category,Account Details,Detaily účtu
DocType: POS Profile,Allow user to edit Rate,Povolit uživateli upravit sazbu
DocType: Healthcare Settings,Result Emailed,Výsledek Emailed
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Zobrazit vede
DocType: Fee Validity,Visited yet,Ještě navštívili
DocType: Purchase Invoice,Terms,Podmínky
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Vyplacená částka nemůže být vyšší než částka úvěru {0}
DocType: Share Balance,Issued,Vydáno
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Plán Vstupné
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Zatím nebyly přidány žádné kontakty.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Vytvořit formát tisku
DocType: Asset,Policy number,Číslo zásady
DocType: GL Entry,Against Voucher,Proti kupónu
DocType: Bank Statement Transaction Payment Item,Payment Reference,Odkaz na platbu
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Studentské mobilní číslo
DocType: Cheque Print Template,Cheque Print Template,Zkontrolujte šablonu tisku
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Za kolik utracených = 1 věrnostního bodu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest: ,Email Digest:
DocType: Accounts Settings,Show Inclusive Tax In Print,Zobrazit inkluzivní daň v tisku
DocType: Student Report Generation Tool,Include All Assessment Group,Zahrnout všechny hodnotící skupiny
DocType: Employee Benefit Application,Employee Benefits,Zaměstnanecké výhody
apps/erpnext/erpnext/controllers/status_updater.py,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument má limit {0} {1} pro položku {4}. Děláte další {3} proti stejné {2}?
DocType: Leave Type,Is Optional Leave,Je volitelný
DocType: Cash Flow Mapping,Is Finance Cost,Je finanční náklady
DocType: Vehicle,Doors,Dveře
DocType: Shopify Settings,Customer Settings,Nastavení zákazníka
DocType: Purchase Invoice Item,Include Exploded Items,Zahrnout rozložené položky
DocType: Assessment Plan,Evaluate,Vyhodnotit
DocType: Purchase Invoice Item,Is Free Item,Je volná položka
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Celkem přítomen
DocType: Item,Is Item from Hub,Je položka z rozbočovače
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Postup kvality.
DocType: Share Balance,No of Shares,Počet akcií
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Počet není k dispozici pro {4} ve skladu {1} v době odeslání záznamu ({2} {3})
DocType: Quality Action,Preventive,Preventivní
DocType: Support Settings,Forum URL,Adresa URL fóra
apps/erpnext/erpnext/config/hr.py,Employee and Attendance,Zaměstnanec a docházka
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Známky života
DocType: Academic Term,Academics User,Uživatel akademik
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Získejte položky z kusovníku
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Sériové číslo je povinné pro položku {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Získejte položky z receptů
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},"{0} {1} nelze zrušit, protože sériové číslo {2} nepatří do skladu {3}"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Zobrazit objednávky
DocType: Staffing Plan Detail,Number Of Positions,Počet poloh
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Vejít
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Pokud je platba označena, importujte prodejní fakturu ze služby Shopify"
DocType: Certification Application,Certification Status,Stav certifikace
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Zdroj je vyžadován pro zdroj {0}
DocType: Employee,Encashment Date,Datum inkasa
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,Vyberte Datum dokončení pro vyplněný Protokol údržby
DocType: Quiz,Latest Attempt,Poslední pokus
DocType: Leave Block List,Allow Users,Povolit uživatelům
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart Of Accounts,Graf účtů
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Customer is mandatory if 'Opportunity From' is selected as Customer,"Zákazník je povinen, pokud je jako Zákazník vybrána možnost Opportunity From"
DocType: Customer,Primary Address,primární adresa
DocType: Room,Room Name,Název místnosti
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,DIČ:
DocType: Serial No,Creation Document No,Dokument o vytvoření č
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Promítnuto
DocType: Purchase Invoice Item,Rejected Qty,Odmítnuto Počet
DocType: Pricing Rule,Free Item,Volná položka
DocType: Salary Component,Is Payable,Je splatná
DocType: Clinical Procedure Template,Allow Stock Consumption,Povolit spotřebu zásob
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademický termín s tímto &#39;akademickým rokem&#39; {0} a &#39;pojmenováním&#39; {1} již existuje. Upravte tyto položky a zkuste to znovu.
DocType: Payment Entry,Initiated,Zahájeno
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Deka objednávky od zákazníků.
DocType: Sales Order Item,Used for Production Plan,Používá se pro výrobní plán
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Rozsah stárnutí 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Časové záznamy jsou vyžadovány pro kartu {0}
DocType: Expense Claim,Vehicle Log,Protokol vozidla
DocType: Grading Scale,Grading Scale Intervals,Intervaly odstupňování stupnice
DocType: Accounts Settings,Report Settings,Nastavení přehledu
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Profil prodejního místa
DocType: Lab Test Groups,Lab Test Groups,Laboratorní testovací skupiny
DocType: Stock Settings,Default Valuation Method,Výchozí metoda oceňování
DocType: Item,Safety Stock,Bezpečnostní sklad
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Nastavení tisku bylo aktualizováno v příslušném formátu tisku
DocType: Support Settings,Issues,Problémy
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Aplikace pro studenty
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Extra velké
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Zůstatek účtu
DocType: Lead,Industry,Průmysl
DocType: Payment Entry,Cheque/Reference Date,Kontrolní / referenční datum
DocType: Asset Movement,Stock Manager,Skladový manažer
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,"Žádné položky, které mají být přijaty, jsou zpožděné"
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Udělte informace.
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Pokud je skupina podle skupiny nastavena na hodnotu Společnost
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizace byla dočasně zakázána, protože bylo překročeno maximální opakování"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} je zrušeno nebo zastaveno
DocType: Asset Maintenance Log,Has Certificate,Má certifikát
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Vyhledávání podle kódu položky, sériového čísla, čísla šarže nebo čárového kódu"
DocType: Item Price,Multiple Item prices.,Ceny více položek.
DocType: Request for Quotation,Request for Quotation,Žádost o nabídku
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuální míra ocenění
DocType: Tax Rule,Shipping County,Přepravní kraj
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Analýza vnímání
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Položka {0} není aktivní nebo bylo dosaženo konce životnosti
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Jediná varianta
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Řádek # {0}: Typ referenčního dokumentu musí být jeden z nároků na výdaje nebo záznam deníku
DocType: Purchase Invoice,Print Language,Jazyk tisku
DocType: Pricing Rule,Pricing Rule Help,Nápověda pro tvorbu cen
DocType: Shareholder,Contact List,Seznam kontaktů
DocType: Employee,Better Prospects,Lepší vyhlídky
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Plán údržby není generován pro všechny položky. Klikněte na odkaz Generovat plán
DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
DocType: Inpatient Record,Patient Encounter,Setkání pacientů
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Definovat různé typy úvěrů
DocType: Supplier,Supplier Type,Typ dodavatele
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Shromážděno celkem: {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kreditní karta
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavení Scorecard dodavatele
DocType: Amazon MWS Settings,Amazon MWS Settings,Nastavení Amazon MWS
DocType: Program Enrollment,Walking,Chůze
DocType: SMS Log,Requested Numbers,Požadovaná čísla
DocType: Woocommerce Settings,Freight and Forwarding Account,Nákladní a zasílatelský účet
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Vyberte společnost
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Řádek {0}: {1} musí být větší než 0
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Nahrajte hlavu dopisu a logo. (můžete je upravit později).
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Vytvořit samostatnou položku platby proti nároku
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Nenašli jste žádnou položku s názvem {0}
DocType: Student,Nationality,Národnost
DocType: BOM Item,Scrap %,Šrot%
DocType: Item,Inspection Criteria,Kritéria kontroly
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Nastavení společnosti se nezdařilo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Debet Na účet musí být účet rozvahy
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Číslo objednávky
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je spojeno s {2}, ale účet ve skupině je {3}"
DocType: Purchase Invoice,Items,Položky
DocType: C-Form,I,Já
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Work-in-Progress Warehouse is required before Submit,Před odesláním je třeba sklad Work-in-Progress Warehouse
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Prodejní objednávka {0} má rezervaci pro položku {1}, pouze {1} můžete doručit pouze proti {0}. Sériové číslo {2} nelze doručit"
DocType: Quality Goal,Monitoring Frequency,Sledování Frekvence
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Konečný zůstatek
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Náklady prodaného aktiva
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Odmítnutý počet nemůže být zadán v nákupním návratu
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
DocType: GSTR 3B Report,JSON Output,Výstup JSON
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Přírůstek nemůže být 0
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,Musí být předložen kusovník {0}
DocType: Amazon MWS Settings,Synch Orders,Objednávky synchronizace
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Výplata půjčky
DocType: Item,Delivered by Supplier (Drop Ship),Dodáno dodavatelem (Drop Ship)
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Objednat
DocType: Employee,Place of Issue,Místo vydání
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
,Gross and Net Profit Report,Zpráva o hrubém a čistém zisku
DocType: Appraisal Template,Appraisal Template Title,Název šablony hodnocení
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Vytvořené pracovní příkazy: {0}
DocType: Packed Item,To Warehouse (Optional),Do skladu (volitelné)
DocType: Appointment Type,Physician,Lékař
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Dokud
DocType: Leave Policy,Leave Policy Details,Opustit podrobnosti o zásadách
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Příklad:</b> SAL- {first_name} - {date_of_birth.year} <br> Tím se vygeneruje heslo jako SAL-Jane-1972
apps/erpnext/erpnext/config/accounting.py,To make recurring documents,Opakované dokumenty
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Ref,PDC / LC Ref
DocType: Naming Series,Update Series Number,Aktualizujte číslo série
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Pokud nechcete zvážit dávkové zpracování, ponechte tuto možnost nezaškrtnutou."
DocType: Assessment Plan Criteria,Maximum Score,Maximální skóre
DocType: Website Filter Field,Website Filter Field,Pole Filtr webových stránek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Zkušební doba
DocType: Travel Request,Require Full Funding,Vyžadovat plné financování
DocType: Batch,Manufacturing Date,Datum výroby
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Seskupte své studenty v sériích
DocType: Payroll Entry,Bimonthly,Dvouměsíční
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Odpisy Zlikvidovány z důvodu vyřazení majetku
DocType: Maintenance Visit,Purposes,Účely
apps/erpnext/erpnext/hooks.py,Shipments,Zásilky
DocType: Program Enrollment Tool,New Academic Term,Nový akademický termín
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Nic není zahrnuto v hrubém vyjádření
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Název nového skladu
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Zobrazit položky vrácení
DocType: Soil Texture,Soil Type,Typ zeminy
DocType: Loyalty Program,Multiple Tier Program,Program vícenásobné úrovně
DocType: BOM Update Tool,The BOM which will be replaced,"Kusovník, který bude nahrazen"
DocType: Patient,Risk Factors,Rizikové faktory
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Vyhrazeno k prodeji
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,Předpisy
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,Účty vznesené na zákazníky.
DocType: Training Event,Seminar,Seminář
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Kredit ({0})
DocType: Payment Request,Subscription Plans,Plány předplatného
DocType: GSTR 3B Report,March,březen
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Rozdělené dávky
DocType: School House,House Name,Název domu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Výjimka {0} nemůže být menší než nula ({1})
DocType: Vehicle,Petrol,Benzín
DocType: Customer,Bypass credit limit check at Sales Order,Obejít kontrolu limitu kreditu na zakázce odběratele
DocType: Employee External Work History,Employee External Work History,Historie externí práce zaměstnanců
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Schvalovatel výdajů povinného v nárocích na výdaje
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Volitelný. Nastaví výchozí měnu společnosti, není-li uvedena."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Částka měsíčního splácení nesmí být vyšší než částka úvěru
DocType: Leave Allocation,Allocation,Přidělení
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid attachment {0},Upozornění: Neplatná příloha {0}
DocType: Vehicle,License Plate,Poznávací značka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplacená částka nesmí být vyšší než celková záporná částka {0}
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,"Skladové množství, které má být zahájeno, není ve skladu k dispozici. Chcete zaznamenat převod akcií"
DocType: Bank Guarantee,Clauses and Conditions,Ustanovení a podmínky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Vyberte prosím správný účet
DocType: Content Activity,Content Activity,Obsahová aktivita
DocType: Pricing Rule Detail,Pricing Rule Detail,Detail cenového pravidla
DocType: Loan,Monthly Repayment Amount,Částka měsíčního splácení
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Dodací položka pro nákup
DocType: Leave Control Panel,Employment Type (optional),Typ zaměstnání (volitelné)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Neplatná hodnota {0} pro transakci mezi společnostmi.
DocType: Asset Movement,From Employee,Od zaměstnance
DocType: Attendance,Attendance Date,Datum docházky
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Došlo k chybám.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Spotřební zboží
DocType: Email Digest,Add/Remove Recipients,Přidat nebo odebrat příjemce
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Částka daně po výši slevy (měna společnosti)
DocType: Account,Capital Work in Progress,Probíhající kapitálová práce
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Procházet kusovník
DocType: Cash Flow Mapping,Select Maximum Of 1,Vyberte Maximum Of 1
DocType: Stock Settings,Batch Identification,Identifikace šarže
DocType: Pricing Rule Brand,Pricing Rule Brand,Značka cenového pravidla
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,Jedná se o kořenového prodejce a nelze jej upravovat.
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Datum výplaty nemůže být kratší než datum nástupu zaměstnance
DocType: Fee Validity,Max number of visit,Maximální počet návštěv
DocType: Item,Serial Nos and Batches,Sériová čísla a šarže
DocType: HR Settings,Password Policy,Zásady hesla
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Došlo k chybám při tvorbě rozvrhu kurzu
DocType: Student Attendance Tool,Batch,Dávka
DocType: Amazon MWS Settings,ERPNext Integrations,Integrace ERPNext
DocType: Batch,Source Document Name,Název zdrojového dokumentu
DocType: Restaurant,Invoice Series Prefix,Předpona série faktur
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-Výše
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Měna pro {0} musí být {1}
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Od data musí být před To Date
DocType: Delivery Settings,Dispatch Notification Attachment,Příloha oznámení o odeslání
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková částka platby v splátkovém kalendáři musí být rovna celkovému / zaokrouhlenému součtu
,Itemwise Recommended Reorder Level,Itemwise Doporučená úroveň pořadí
DocType: Course Activity,Video,Video
DocType: Salary Slip Loan,Salary Slip Loan,Výplata půjčky
DocType: Account,Balance Sheet,Rozvaha
DocType: Email Digest,Payables,Závazky
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Poplatek byl vytvořen
,Customer Acquisition and Loyalty,Získávání a věrnost zákazníků
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Jméno studentské skupiny je povinné v řádku {0}
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Hlavní měnový kurz.
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Stav musí být {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",U karty {0} můžete zadat pouze položku typu položky &quot;Převod materiálu pro výrobu&quot;
DocType: Asset,Insurance Start Date,Datum zahájení pojištění
DocType: Target Detail,Target Detail,Detail cíle
DocType: Packing Slip,Net Weight UOM,Čistá hmotnost UOM
DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (měna společnosti)
DocType: Bank Statement Transaction Settings Item,Mapped Data,Namapovaná data
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Cenné papíry a vklady
DocType: Promotional Scheme Price Discount,Discount Type,Typ slevy
DocType: Hotel Settings,Default Taxes and Charges,Standardní daně a poplatky
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,To je založeno na transakcích s tímto dodavatelem. Podrobnosti naleznete v níže uvedené časové ose
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Maximální výše příspěvku zaměstnance {0} přesahuje {1}
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Enter Start and End Date for the Agreement.,Zadejte datum začátku a konce smlouvy.
DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
DocType: Loyalty Point Entry,Purchase Amount,Částka nákupu
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Nelze nastavit jako ztracený jako zakázka odběratele.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Platní složka pro výplatní listinu založenou na časovém rozvrhu.
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Jméno dodavatele
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Povolit vícenásobnou spotřebu materiálu proti zakázce
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Otevřete novou letenku
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Nahlásit problém
DocType: Support Search Source,Link Options,Možnosti propojení
DocType: Selling Settings,Sales Update Frequency,Frekvence prodejní aktualizace
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Kód PIN
apps/erpnext/erpnext/config/crm.py,Newsletters,Informační bulletiny
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,Licence
DocType: Employee Tax Exemption Declaration,Other Incomes,Ostatní příjmy
DocType: Job Card,Job Started,Úloha byla spuštěna
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Po uložení nastavte opakování
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,Aspoň jedna položka by měla být zadána se záporným množstvím v návratovém dokumentu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Důvod pro Hold
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.js,HSN/SAC,HSN / SAC
DocType: Homepage,"URL for ""All Products""",Adresa URL pro všechny produkty
DocType: Lead,Organization Name,Název organizace
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Platné od a platné upto pole jsou pro kumulativní povinné
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Řádek # {0}: Číslo šarže musí být stejné jako {1} {2}
DocType: Employee,Leave Details,Podrobnosti nechte
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Transakce akcií před {0} jsou zmrazeny
DocType: Driver,Issuing Date,Datum vydání
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Žadatel
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Nákladové středisko {2} nepatří společnosti {3}
DocType: Certification Application,Not Certified,Není certifikováno
DocType: Work Order,Check if material transfer entry is not required,"Zkontrolujte, zda není nutný vstup pro přenos materiálu"
DocType: BOM,Raw Material Cost,Náklady na suroviny
DocType: Project,Second Email,Druhý email
DocType: Vehicle Log,Service Detail,Detail služby
DocType: Manufacturing Settings,Default 10 mins,Výchozí 10 minut
DocType: Subscription Plan,Billing Interval,Interval fakturace
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Celkový debet musí být roven celkovému kreditu. Rozdíl je {0}
DocType: Supplier,Name and Type,Jméno a typ
DocType: Cheque Print Template,Cheque Height,Zkontrolujte výšku
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Zadejte datum uvolnění.
DocType: Loyalty Program,Loyalty Program Help,Nápověda k věrnostnímu programu
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Quality Meeting,Agenda,Denní program
DocType: Quality Action,Corrective,Nápravné
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Skupina vytvořená
DocType: Bank Account,Address and Contact,Adresa a kontakt
DocType: Payment Term,Day(s) after invoice date,Den (y) po datu faktury
DocType: Woocommerce Settings,API consumer secret,Tajemství API spotřebitele
DocType: Shift Assignment,Shift Assignment,Posunutí přiřazení
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: Issue,First Responded On,První odpověď byla zapnuta
DocType: Work Order Operation,Estimated Time and Cost,Odhadovaný čas a náklady
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Return / Credit Note
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Vyberte položku Výchozí dodavatel
DocType: Water Analysis,Appearance,Vzhled
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Poukaz #
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
apps/erpnext/erpnext/config/projects.py,Define Project type.,Definovat Typ projektu.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Instalace předvoleb se nezdařilo
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Kořenová společnost
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Výchozí cena aktivity existuje pro typ aktivity - {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Cílová lokace
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Počet objednávek
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Registrace pacienta faktury
DocType: Training Event Employee,Training Event Employee,Zaměstnanec vzdělávací akce
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Ztratíte záznamy o dříve vytvořených fakturách. Opravdu chcete tento odběr restartovat?
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobnosti šablony mapování peněžních toků
apps/erpnext/erpnext/config/hr.py,Recruitment and Training,Nábor a školení
DocType: Drug Prescription,Interval UOM,Interval UOM
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od měny a do měny nemůže být stejné
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Léčiva
DocType: Employee,HR-EMP-,HR-EMP-
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} je zrušeno nebo zavřeno
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Řádek {0}: Záloha proti zákazníkovi musí být kreditem
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Seskupit podle kupónu (Konsolidováno)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Nastavit výchozí účet v Typu nároku na reklamaci {0}
,BOM Search,Hledání kusovníku
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Stát odeslání
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Pokračujte v konfiguraci
DocType: Item Alternative,Item Alternative,Položka Alternativa
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Vyberte lékaře ve zdravotnictví ...
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},Zaměstnanec {0} již podal přihlášku {1} pro mzdové období {2}
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Zadání platby nebude vytvořeno, protože nebylo zadáno „Hotovostní nebo bankovní účet“"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Non GST Inward Supplies
DocType: Detected Disease,Disease,Choroba
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,Je vyžadováno „To Date“
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Kapitálové vybavení
DocType: Bank Statement Settings,Statement Headers,Záhlaví prohlášení
DocType: Packing Slip,Gross Weight UOM,Hrubá hmotnost UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,"Zkontrolujte možnost Více měn, abyste povolili účty s jinou měnou"
DocType: Loan,Repay Fixed Amount per Period,Splácení pevné částky za období
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Zobrazit atributy variant
DocType: GL Entry,Credit Amount,Výše kreditu
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Celková částka kreditu
DocType: Support Search Source,Post Route Key List,Seznam klíčů po trase
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} není v žádném aktivním fiskálním roce.
DocType: Quality Action Resolution,Problem,Problém
DocType: Training Event,Conference,Konference
DocType: Mode of Payment Account,Mode of Payment Account,Způsob platebního účtu
DocType: Leave Encashment,Encashable days,Započaté dny
DocType: Healthcare Settings,Collect Fee for Patient Registration,Sbírejte poplatek za registraci pacienta
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Zakázat šablonu
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filtrovat zaměstnance podle (volitelné)
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} bylo úspěšně odesláno
DocType: Workstation,Wages per hour,Mzdy za hodinu
DocType: Item,Max Discount (%),Max. Sleva (%)
DocType: Employee,Salary Mode,Platový režim
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Výše {0} nastavená v této žádosti o platbu se liší od vypočtené částky všech platebních plánů: {1}. Před odesláním dokumentu se ujistěte, že je to správné."
DocType: Opportunity,Contact Info,Kontaktní informace
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Odkaz na transakci č. {0} ze dne {1}
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Měna je vyžadována pro ceník {0}
DocType: Program,Program Name,Název programu
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,Toto je účet uživatele root a nelze jej upravovat.
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',„Očekávaný datum zahájení“ nemůže být větší než „očekávaný datum ukončení“
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategorie prohlášení o výjimce pro zaměstnance
DocType: Work Order,Item To Manufacture,Položka k výrobě
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,V množství
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Is Fixed Asset&quot; nelze zrušit, protože proti položce existuje záznam o aktivech"
DocType: Salary Component,Flexible Benefits,Flexibilní výhody
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Opustit oznámení o schválení
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Celková skutečná částka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Strana je povinná
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Zkontrolovat vše
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Je-li neomezené vypršení platnosti pro věrnostní body, ponechte dobu trvání vypršení platnosti prázdnou nebo 0."
DocType: Attendance Request,Explanation,Vysvětlení
DocType: Journal Entry Account,Exchange Rate,Směnný kurz
DocType: Task,Total Costing Amount (via Time Sheet),Celková částka kalkulace nákladů (prostřednictvím časového výkazu)
DocType: Tax Rule,Billing County,Fakturační kraj
DocType: Lead Source,Lead Source,Zdroj olova
DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán na adresu:
DocType: Batch,Source Document Type,Typ zdrojového dokumentu
DocType: Project,Frequency To Collect Progress,Frekvence pro sběr pokroku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Vedoucí marketingu a prodeje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Vytvořena dodavatelská nabídka {0}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Všechny transakce související s touto společností byly úspěšně smazány!
DocType: Purchase Taxes and Charges,On Net Total,Celkem
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Držet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Ve sloupci „Proti zápisu do deníku“ nelze zadat aktuální poukázku
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Nejdříve vyberte společnost a typ strany
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Jít do
,Work Orders in Progress,Probíhají pracovní příkazy
DocType: Payment Reconciliation,To Invoice Date,Do data faktury
DocType: Staffing Plan Detail,Vacancies,Volná místa
DocType: Purchase Order Item,Last Purchase Rate,Poslední nákupní sazba
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Náklady na prodej
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,"Účty standardního příjmu, které mají být použity, nejsou-li stanoveny ve zdravotnickém pracovišti k účtování poplatků za jmenování."
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Skupina studentů je již aktualizována.
DocType: Driver,Fleet Manager,Správce vozového parku
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Nejste oprávněni schvalovat listy na Blokových datech
,Purchase Invoice Trends,Kupujte trendy faktur
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řádek množství
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Pro aktuální fiskální rok nebyly nalezeny žádné srážkové údaje.
DocType: Travel Itinerary,Taxi,Taxi
DocType: Contract,Inactive,Neaktivní
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Skutečné množství na skladě
DocType: Student Sibling,Student Sibling,Student Sibling
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Přejít na Pokoje
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Vytvořit záznamy zaměstnanců
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Objednané množství: Množství objednané k nákupu, ale nepřijaté."
DocType: Patient,Patient ID,ID pacienta
DocType: Employee,Permanent Address Is,Trvalá adresa je
DocType: Hotel Room Reservation,Guest Name,Jméno hosta
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Akumulované hodnoty ve skupině
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Životopis
,BOM Stock Calculated,Skladové zásoby vypočítány
DocType: Employee Transfer,New Employee ID,ID nového zaměstnance
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,Vzor daně pro prodejní transakce.
DocType: Currency Exchange,To Currency,Do měny
DocType: Course Schedule,Instructor Name,Jméno instruktora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Výzkum
DocType: Additional Salary,Employee Name,jméno zaměstnance
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Docházku nelze označit pro budoucí data
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min
DocType: Work Order,Manufactured Qty,Vyrobené množství
DocType: Patient,Alcohol Current Use,Současné užívání alkoholu
DocType: Leave Application,Total Leave Days,Celkové dny dovolené
DocType: Asset Repair,Repair Status,Stav opravy
DocType: Territory,Territory Manager,oblastní manažer
DocType: Lab Test,Sample ID,ID vzorku
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košík je prázdný
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Musí být odeslána aktiva {0}
,Absent Student Report,Absent Student Report
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Zahrnuto v hrubém zisku
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
DocType: Travel Request Costing,Funded Amount,Financovaná částka
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebylo odesláno, takže akci nelze dokončit"
DocType: Subscription,Trial Period End Date,Datum ukončení zkušebního období
DocType: BOM Update Tool,The new BOM after replacement,Nový kusovník po výměně
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Bod 5
DocType: Employee,Passport Number,Číslo pasu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Dočasné otevření
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Pravidla cen jsou dále filtrována na základě množství.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Hodnocení {0} vytvořeno pro zaměstnance {1} v daném časovém období
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Odchylka
DocType: Sales Order,Partly Delivered,Částečně dodáno
DocType: Item,Maintain Stock,Udržovat zásoby
DocType: Job Card,Started Time,Čas spuštění
apps/erpnext/erpnext/config/hr.py,Shifts and Fleet Management,Posuny a správa vozového parku
DocType: Item,Average time taken by the supplier to deliver,"Průměrná doba, kterou dodavatel dodá"
DocType: Stock Entry,Per Transferred,Per Transferred
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (pouze koncept)"
DocType: Upload Attendance,Get Template,Získat šablonu
DocType: Agriculture Task,Next Business Day,Následující pracovní den
DocType: Payment Reconciliation,Receivable / Payable Account,Účet pohledávek / závazků
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Současně nelze kreditovat a debetovat stejný účet
DocType: Agriculture Analysis Criteria,Weather,Počasí
,Welcome to ERPNext,Vítejte v ERPNext
DocType: Payment Reconciliation,Maximum Invoice Amount,Maximální částka faktury
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Reklamace nákladů pro protokol vozidla {0}
DocType: Healthcare Settings,Patient Encounters in valid days,Setkání pacientů v platné dny
,Student Fee Collection,Kolekce studentských poplatků
DocType: Selling Settings,Sales Order Required,Požadavek na prodejní objednávku
DocType: Stock Entry Detail,Serial No / Batch,Sériové číslo / dávka
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Výpis z účtu
DocType: Job Offer Term,Offer Term,Termín nabídky
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Účet {0} nepatří společnosti: {1}
DocType: Tally Migration,Tally Migration,Tally Migrace
DocType: Item,"Purchase, Replenishment Details","Podrobnosti o nákupu, doplňování"
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",Po nastavení bude tato faktura pozastavena do stanoveného data
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat pro položku {0}, protože má varianty"
DocType: Lab Test Template,Grouped,Seskupeno
DocType: GSTR 3B Report,January,leden
DocType: Course Assessment Criteria,Course Assessment Criteria,Kritéria hodnocení kurzu
DocType: Certification Application,INR,INR
DocType: Job Card Time Log,Completed Qty,Dokončeno množství
DocType: Agriculture Task,Start Day,Den zahájení
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Nastavení platební brány GoCardless
DocType: Asset Category Account,Depreciation Expense Account,Účet odpisů
DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní plán Prodejní zakázka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Množství hotového výrobku <b>{0}</b> a pro množství <b>{1}</b> se nesmí lišit
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Zobrazit laboratorní testy
DocType: Article,Instructor,Instruktor
DocType: Shopping Cart Settings,Show Public Attachments,Zobrazit veřejné přílohy
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Pole budou zkopírována pouze v době vytvoření.
DocType: Delivery Note,Vehicle No,Vozidlo č
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Položka Platba je již vytvořena
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Více variant
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Vyberte soubor csv
DocType: Serial No,Serial No Details,Podrobnosti o sériovém čísle
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Umístění zdroje a cíle nemůže být stejné
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Zobrazit zaměstnance
DocType: Payment Entry,Writeoff,Odepsat
DocType: Issue,ISS-.YYYY.-,ISS-.YYYY.-
DocType: Payment Order,Payment Request,Žádost o platbu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Vybraný ceník by měl mít zaškrtnuté pole nákupu a prodeje.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,"Nelze převést na skupinu, protože je vybrán typ účtu."
DocType: Company,Exchange Gain / Loss Account,Účet zúčtování / ztráty
DocType: Project Template,Project Template,Šablona projektu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Řadit množství
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Exportujte sestavu a vytiskněte ji pomocí tabulky.
DocType: Payroll Entry,Salary Slips Submitted,Předložené platové lístky
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,Pro dodavatele
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Účetní položky již byly provedeny v měně {0} pro společnost {1}. Vyberte prosím pohledávku nebo závazný účet s měnou {0}.
DocType: Asset Value Adjustment,New Asset Value,Nová hodnota aktiv
DocType: Volunteer,Volunteer Type,Typ dobrovolníka
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Vytištěno
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Grant listy
DocType: Vehicle,Vehicle Value,Hodnota vozidla
,Project Billing Summary,Přehled fakturace projektu
DocType: Asset,Receipt,Účtenka
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Chcete-li získat rozvrh, klikněte na tlačítko Generovat plán"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,Sazba TDS%
DocType: Training Event,Contact Number,Kontaktní číslo
DocType: POS Closing Voucher,POS Closing Voucher,Uzavírací poukaz POS
DocType: Quality Inspection Template,Quality Inspection Template Name,Název šablony kontroly kvality
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Přidáno {0} uživatelů
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Non-Group,Převést na Non-Group
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Nastavit jako ztracený
DocType: Journal Entry Account,Payroll Entry,Zadávání mezd
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen záznam měny pro {1} až {2}.
DocType: Delivery Note,Transporter Name,Název transportéru
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Plánované množství: Množství, pro které byl pracovní příkaz zvýšen, ale čeká na jeho výrobu."
DocType: Item,Has Variants,Má varianty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Burzy cenných papírů a komodit
DocType: Purchase Invoice Item,Deferred Expense,Odložený náklad
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,ID platového skluzu
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,ID členství
,Sales Register,Obchodní rejstřík
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Zadejte prosím platné číslo „Od případu č.“
DocType: Customer,Primary Address and Contact Detail,Podrobnosti primární adresy a kontaktu
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,To je založeno na transakcích s tímto zákazníkem. Podrobnosti naleznete v níže uvedené časové ose
DocType: Hotel Room,Hotels,Hotely
DocType: Shipping Rule,Valid for Countries,Platné pro země
,Territory Target Variance Based On Item Group,Územní cílová varianta založená na skupině položek
DocType: Rename Tool,Rename Tool,Přejmenovat nástroj
DocType: Loan Application,Total Payable Amount,Celková splatná částka
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Přidat všechny dodavatele
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Řádek {0}: Měna kusovníku # {1} by se měla rovnat vybrané měně {2}
DocType: Pricing Rule,Product,Produkt
apps/erpnext/erpnext/controllers/item_variant.py,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Hodnota {0} pro atribut {1} neexistuje v seznamu platných hodnot atributů položky pro položku {2}
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotek [{1}] (# Form / Item / {1}) nalezených v [{2}] (# Form / Warehouse / {2})
DocType: Vital Signs,Weight (In Kilogram),Hmotnost (v kilogramech)
DocType: Department,Leave Approver,Opustit schvalující osobu
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakce
DocType: Issue,Resolution Details,Podrobnosti o rozlišení
DocType: Sales Invoice Item,Delivery Note Item,Položka dodacího listu
DocType: QuickBooks Migrator,Connected to QuickBooks,Připojeno k QuickBooks
DocType: Item,Shelf Life In Days,Skladovatelnost ve dnech
apps/erpnext/erpnext/config/buying.py,Key Reports,Klíčové zprávy
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Možný dodavatel
,Issued Items Against Work Order,Vydané položky proti pracovnímu příkazu
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Vytvoření faktury {0}
DocType: Student,Joining Date,Datum připojení
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Žádající stránky
DocType: Purchase Invoice,Against Expense Account,Proti účtu výdajů
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Nelze vytvořit službu Delivery Delivery z konceptů dokumentů.
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Vedete k nabídce
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Zkontrolujte, zda student bydlí v hostelu ústavu."
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} se objeví vícekrát v řádku {2} &amp; {3}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Vytvoření platebních položek ......
DocType: Production Plan,Total Planned Qty,Celkový plánovaný počet
DocType: Subscription Plan,Cost,Náklady
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Typ jednotky zdravotní péče
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Zadejte prosím alespoň 1 fakturu do tabulky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Prodejní objednávka {0} není odeslána
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Účast byla úspěšně označena.
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Předprodej
apps/erpnext/erpnext/config/projects.py,Project master.,Vedoucí projektu.
DocType: Daily Work Summary,Daily Work Summary,Souhrn denní práce
DocType: Asset,Partially Depreciated,Částečně znehodnoceno
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,„Dny od posledního příkazu“ musí být větší nebo rovné nule
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Pro výchozího dodavatele (volitelné)
DocType: Employee,Leave Encashed?,Opustit Encashed?
DocType: Certified Consultant,Discuss ID,Diskutujte o ID
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set GST Accounts in GST Settings,Nastavte GST účty v nastavení GST
DocType: Quiz,Latest Highest Score,Poslední nejvyšší skóre
DocType: Supplier,Billing Currency,Fakturační měna
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Aktivita studenta
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Povinné je buď cílové množství nebo cílové množství
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je nyní výchozí fiskální rok. Aktualizace se projeví aktualizací prohlížeče.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Z adresy 2
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Z výše uvedených dodávek uvedených v odst. 3.1 písm. A) jsou uvedeny podrobnosti o mezistátních dodávkách poskytnutých neregistrovaným osobám, osobám povinným k dani a držitelům UIN"
DocType: Company,Default Inventory Account,Výchozí účet zásob
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Datum konce roku nesmí být starší než datum zahájení roku. Opravte data a zkuste to znovu.
DocType: Target Detail,Target  Amount,Cílová částka
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Hotelové pokoje typu {0} nejsou k dispozici na {1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Příjmy nového zákazníka
DocType: Landed Cost Item,Applicable Charges,Platné poplatky
,Point of Sale,Místě prodeje
DocType: Authorization Rule,Approving User  (above authorized value),Schválení uživatele (nad autorizovanou hodnotou)
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Částka {0} {1} byla převedena z {2} na {3}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Zákazník {0} nepatří do projektu {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Z názvu strany
DocType: Asset Maintenance Log,Maintenance Status,Stav údržby
DocType: Production Plan Item,Pending Qty,Čekající množství
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,nebo
DocType: Sales Order,Not Delivered,Nedoručeno
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,"Typ dovolené {0} nelze přidělit, protože je volno bez placení"
DocType: GL Entry,Debit Amount,Částka debetu
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Pro položku {0} již existuje záznam
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Dílčí sestavy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Pokud bude nadále platit více pravidel pro určování cen, uživatelé budou požádáni, aby nastavili prioritu ručně, aby vyřešili konflikt."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, když je kategorie pro „Ocenění“ nebo „Ocenění a Celkem“"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,Vyžaduje se kusovník a výrobní množství
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti {1}
DocType: Quality Inspection Reading,Reading 6,Čtení 6
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Vyžaduje se pole společnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Spotřeba materiálu není nastavena ve výrobním nastavení.
DocType: Assessment Group,Assessment Group Name,Název skupiny hodnocení
DocType: Purchase Invoice Item,Manufacturer Part Number,Označení výrobce
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Splatné mzdy
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},Řádek # {0}: {1} nemůže být záporný pro položku {2}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Zůst
DocType: Question,Multiple Correct Answer,Více správných odpovědí
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Věrnostní body = Kolik základní měny?
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Poznámka: Nedostatek zůstatku dovolené pro typ dovolené {0}
DocType: Clinical Procedure,Inpatient Record,Záznam pacienta
DocType: Sales Invoice Item,Customer's Item Code,Kód zákazníka
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Změnit kód položky
DocType: Student Group Instructor,Student Group Instructor,Student Group Instructor
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Transaction Type,typ transakce
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Dům pronajmout data by měla být nejméně 15 dnů od sebe
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Zobrazit formulář
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,"Míra ocenění je povinná, je-li zadáno otevírání akcií"
DocType: Employee,Exit Interview Details,Ukončení podrobností rozhovoru
DocType: Sales Invoice,Accounting Details,Účetní údaje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušen před zrušením této objednávky odběratele
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
DocType: Customer,Mention if non-standard receivable account,Uveďte v případě nestandardního účtu pohledávek
DocType: Lab Test,Prescription,Předpis
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Nastaven jako uzavřený
DocType: Asset,Opening Accumulated Depreciation,Otevření akumulovaných odpisů
DocType: Soil Texture,Sand Composition (%),Složení písku (%)
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Importovat data denní knihy
DocType: Asset,Asset Owner Company,Majitel společnosti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Nákladové středisko je povinno si rezervovat nárok na náklady
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} platná sériová čísla pro položku {1}
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Nelze propagovat zaměstnance se stavem vlevo
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Vypršení platnosti (ve dnech)
DocType: Supplier Scorecard Standing,Notify Other,Upozornit ostatní
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company,Vyberte společnost
,Item-wise Purchase Register,Pořadový nákupní seznam
DocType: Employee,Reason For Leaving,Důvod k odchodu
DocType: Salary Slip,Earning & Deduction,Zisk a odpočet
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Doporučení zaměstnance
,Qty to Order,Množství na objednávku
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Žádost o koupi.
DocType: Bin,Moving Average Rate,Průměrná rychlost pohybu
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Šablona daně pro nákupní transakce.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Pošli SMS
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Neoverená data Webhook
apps/erpnext/erpnext/config/help.py,Human Resource,Lidské zdroje
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} bylo změněno. Obnovte prosím.
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Zůstatek zásob v dávce {0} bude pro položku {2} ve skladu {3} záporný {1}
,Asset Depreciation Ledger,Účetnictví odpisů aktiv
DocType: Location,Tree Details,Podrobnosti o stromě
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Vytvořte chybějícího zákazníka nebo dodavatele.
DocType: Vital Signs,Blood Pressure (diastolic),Krevní tlak (diastolický)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,Podle pravidel 42 a 43 pravidel CGST
DocType: Item,Show in Website (Variant),Zobrazit na webových stránkách (varianta)
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,Nastavte prosím ID e-mailu pro odeslání žádosti o platbu
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generujte balicí pásky pro balíčky, které mají být dodány. Slouží k oznámení čísla balení, obsahu balení a jeho hmotnosti."
DocType: SMS Log,No of Requested SMS,Počet požadovaných SMS
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Bankovní a platební styk
DocType: Instructor,Instructor Log,Instructor Log
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Maximální dávka zaměstnance {0} převyšuje {1} součtem {2} dávky pro-rata komponenty a předchozí nárokované částky
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Zadejte prosím platnou e-mailovou adresu
apps/erpnext/erpnext/config/retail.py,Retail Operations,Maloobchodní operace
DocType: Company,Phone No,Telefonní číslo
,Reqd By Date,Reqd Podle data
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Zrušte zaškrtnutí všech
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Na místo
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Výchozí sklad ve skladu
DocType: Fees,Include Payment,Zahrnout platbu
DocType: Crop,Byproducts,Vedlejší produkty
DocType: Assessment Result,Student,Student
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Spravovat strom skupiny zákazníků.
DocType: Payment Entry,Payment From / To,Platba z / do
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Sériové číslo {0} bylo zadáno více než jednou
DocType: Website Item Group,Website Item Group,Skupina položek webových stránek
DocType: Amazon MWS Settings,CA,CA.
DocType: Serial No,Under Warranty,V záruce
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Datum účtování faktury
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Dodací list
DocType: Education Settings,Attendance Freeze Date,Datum zmrazení docházky
DocType: Warranty Claim,Item and Warranty Details,Podrobnosti o položce a záruce
DocType: Job Card,Time Logs,Časové záznamy
DocType: Hotel Room,Extra Bed Capacity,Kapacita přistýlky
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistý výplata (ve slovech) bude viditelná, jakmile uložíte výplatní pásku."
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,"Funkci váženého skóre nelze vyřešit. Ujistěte se, že vzorec je platný."
DocType: Asset,Asset Owner,Vlastník aktiv
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro sklad Položka {0} v řádku {1}
DocType: Stock Entry,Total Additional Costs,Celkové dodatečné náklady
DocType: Marketplace Settings,Last Sync On,Poslední synchronizace zapnuta
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Nastavte alespoň jeden řádek v tabulce Daně a poplatky
DocType: Asset Maintenance Team,Maintenance Team Name,Název týmu údržby
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Graf nákladových středisek
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Přejděte do části Uživatelé
DocType: Pricing Rule,Item Code,Kód položky
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',&#39;Otevírací&#39;
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange Gain / Loss
DocType: Accounts Settings,Make Payment via Journal Entry,Proveďte platbu prostřednictvím zápisu do deníku
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Uživatel neuplatnil pravidlo na faktuře {0}
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Platební podmínky založené na podmínkách
DocType: Purchase Order,% Received,% Přijato
DocType: Sales Order Item,Work Order Qty,Počet pracovních objednávek
DocType: Job Card,WIP Warehouse,WIP Warehouse
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},ID uživatele není nastaveno pro zaměstnance {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available qty is {0}, you need {1}","Dostupné množství je {0}, které potřebujete {1}"
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Uživatel {0} byl vytvořen
DocType: Stock Settings,Item Naming By,Pojmenování položky podle
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Objednáno
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,Toto je skupina uživatelů root a nelze ji upravovat.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Požadavek na materiál {0} je zrušen nebo zastaven
DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané množství
DocType: Cash Flow Mapper,Cash Flow Mapper,Mapovač peněžních toků
DocType: Soil Texture,Sand,Písek
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Zaměstnanec se nemůže hlásit sám sobě.
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Objednávka byla změněna na synchronizaci
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Výchozí jednotka míry pro variantu &#39;{0}&#39; musí být stejná jako v šabloně &#39;{1}&#39;
DocType: Blanket Order,Purchasing,Nákup
DocType: Driver,Cellphone Number,Mobilní číslo
DocType: Salary Slip,Gross Pay,Hrubá mzda
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Balíček cen pokojů
DocType: Pricing Rule,Is Cumulative,Je kumulativní
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Tvůj vozík je prázdný
,Daily Timesheet Summary,Denní přehled časového rozvrhu
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Nový postup kvality
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Subdodávky
DocType: Fee Schedule Program,Total Students,Celkový počet studentů
apps/erpnext/erpnext/utilities/user_progress_utils.py,Local,Místní
DocType: Chapter Member,Leave Reason,Nechte důvod
DocType: Salary Component,Condition and Formula,Stav a vzorec
DocType: Quality Goal,Objectives,Cíle
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plat již zpracovaný pro období mezi {0} a {1}, doba ponechání aplikace nemůže být mezi tímto rozsahem dat."
DocType: BOM Item,Basic Rate (Company Currency),Základní sazba (měna společnosti)
DocType: BOM Scrap Item,BOM Scrap Item,Položka kusovníku
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Sériové číslo
DocType: Activity Type,Default Billing Rate,Výchozí sazba fakturace
DocType: Vital Signs,Coated,Potažené
DocType: Patient Appointment,More Info,Více informací
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Kusovník
DocType: Purchase Invoice,Inter Company Invoice Reference,Referenční faktura mezi společnostmi
DocType: Crop Cycle,Cycle Type,Typ cyklu
DocType: Employee Separation,Exit Interview Summary,Ukončete souhrnný rozhovor
,Item Variant Details,Podrobnosti o variantě položky
DocType: Contract,Partially Fulfilled,Částečně splněno
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Do {0}
DocType: GST Settings,GST Accounts,Účty GST
DocType: C-Form,Total Invoiced Amount,Celková částka fakturované částky
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Zakáže vytváření časových protokolů proti zakázkám práce. Operace nesmí být sledovány podle pracovního řádu
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Pro transakce není povolen výběr skupiny uzlů
DocType: Subscriber,Subscriber Name,Jméno účastníka
DocType: Purchase Order,Customer Mobile No,Zákazník Mobile č
DocType: Bank Guarantee,Receiving,Příjem
DocType: Account,Is Group,Je skupina
DocType: Healthcare Practitioner,Contacts and Address,Kontakty a Adresa
DocType: Warehouse,Warehouse Name,Název skladu
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,Návštěvnost není předložena pro {0} jako je svátek.
DocType: Leave Type,Rounding,Zaokrouhlení
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,Nepřípustné ITC
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} vytvořeno
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte hlavu účtu banky, kde byl uložen šek."
DocType: Service Level,Support and Resolution,Podpora a řešení
DocType: Account,Bank,banka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Přijmout ve skladu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Odeslat e-maily dodavatele
DocType: Lab Test Groups,Add new line,Přidat nový řádek
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Duplicitní skupina položek nalezená v tabulce skupin položek
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Roční plat
DocType: Supplier Scorecard,Weighting Function,Funkce vážení
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Chyba při vyhodnocení vzorce kritérií
,Lab Test Report,Laboratorní protokol
DocType: BOM,With Operations,S operacemi
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,"Lidé, kteří učí ve vaší organizaci"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Účet {0} nepatří společnosti {1}
DocType: Item,Has Expiry Date,Datum vypršení platnosti
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Součet hodnot hodnotících kritérií musí být {0}.
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Vlastnost již byla přidána
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Expense Claim Account,Expense Claim Account,Účet reklamace výdajů
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Pro zápis do deníku nejsou k dispozici žádné splátky
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivní student
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Vstup do skladu
DocType: Employee Onboarding,Activities,Aktivity
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Minimálně jeden sklad je povinný
,Customer Credit Balance,Zůstatek kreditu zákazníka
DocType: BOM,Operations,Operace
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Vytvořit výplatní pásy
,Monthly Attendance Sheet,Měsíční docházkový list
DocType: Vital Signs,Reflexes,Reflexy
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","Požadovaná položka služby, typ, četnost a částka výdajů"
DocType: Supplier Scorecard Period,Variables,Proměnné
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Věrnostní program nalezený pro zákazníka. Vyberte prosím ručně.
DocType: Patient,Medication,Léky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Vyberte Věrnostní program
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Suroviny
DocType: Sales Order,Fully Billed,Plně účtováno
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},Nastavte prosím cenu hotelového pokoje na {}
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Identifikujte / vytvořte účet (Ledger) pro typ - {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Celková částka úvěru / debetu by měla být stejná jako položka vloženého deníku
DocType: Purchase Invoice Item,Is Fixed Asset,Je pevná aktiva
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,K názvu strany
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Tato položka je variantou {0} (šablony).
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. Obvykle se používá k synchronizaci systémových hodnot a toho, co ve vašich skladech skutečně existuje."
DocType: Cashier Closing,Net Amount,Čistá částka
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Prodejní ceník
DocType: Amazon MWS Settings,IT,TO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} musí být záporný v návratovém dokumentu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Vyberte prosím platné datum
DocType: Agriculture Task,End Day,Konec dne
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,"Potvrďte prosím, jakmile dokončíte školení"
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Přejděte na Hlavičkové papíry
DocType: Leave Block List Allow,Allow User,Povolit uživateli
DocType: Sales Order,% of materials delivered against this Sales Order,% materiálu dodaného proti této zakázce odběratele
DocType: Purpose of Travel,Purpose of Travel,Účel cesty
DocType: Healthcare Settings,Appointment Confirmation,Potvrzení schůzky
DocType: Shopping Cart Settings,Orders,Objednávky
DocType: HR Settings,Retirement Age,Duchodovy vek
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Promítané množství
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Smazání není pro zemi {0} povoleno
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},Řádek # {0}: Hodnota {1} je již {2}
DocType: Delivery Note,Installation Status,Stav instalace
DocType: Item Attribute Value,Attribute Value,Hodnota atributu
DocType: Sales Invoice,Base Change Amount (Company Currency),Základní částka změny (měna společnosti)
DocType: Leave Allocation,Unused leaves,Nepoužité listy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Pro položku Typ výroby musí být zadána hotová položka {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,&#39;Záznamy&#39; nemohou být prázdné
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,Přejděte na Kurzy
DocType: Fee Schedule,Fee Breakup for each student,Poplatek za porušení pro každého studenta
DocType: Item,Will also apply for variants,Platí také pro varianty
DocType: Shopify Settings,Shared secret,Sdílené tajemství
DocType: POS Profile,Write Off Cost Center,Odpisové středisko nákladů
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Loyalty Point Entry Redemption,Redeemed Points,Uplatněné body
DocType: GoCardless Mandate,Mandate,Mandát
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Vytvořit více
DocType: Supplier Scorecard,Scoring Standings,Bodování
DocType: Support Search Source,Result Title Field,Výsledek Název pole
DocType: Leave Allocation,New Leaves Allocated,Nové listy přidělené
DocType: Homepage,Homepage,Domovská stránka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Kompenzační Vypnuto
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Otevírání faktur
DocType: Vehicle Service,Engine Oil,Motorový olej
DocType: Job Applicant,Applicant Name,Jméno žadatele
DocType: Serial No,Delivery Document No,Dodací doklad č
DocType: Hub Users,Hub Users,Uživatelé rozbočovače
DocType: Bin,Actual Quantity,Skutečné množství
DocType: Payment Term,Credit Days,Kreditní dny
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,Id projektu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Elektronika
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Datum splatnosti je povinné
DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
,Completed Work Orders,Dokončené pracovní příkazy
DocType: Loyalty Program,Help Section,Sekce nápovědy
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Datum účasti nesmí být kratší než datum nástupu zaměstnance
DocType: BOM,Total Cost(Company Currency),Celkové náklady (měna společnosti)
DocType: Subscription,Net Total,Čistý součet
DocType: Procedure Prescription,Referral,Doporučení
DocType: Vehicle,Model,Modelka
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Specifikujte z / do rozsahu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Quantity to Manufacture must be greater than 0.,Množství k výrobě musí být větší než 0.
DocType: Maintenance Visit,Maintenance Time,Doba údržby
DocType: Asset,Naming Series,Pojmenování série
DocType: Contract,Contract Terms,Smluvní podmínky
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Povinné je buď cílové množství nebo cílové množství.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Neplatné číslo {0}
DocType: Item,FIFO,FIFO
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.YYYY.-
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků
DocType: Employee Benefit Application,Max Benefits (Yearly),Max. Výhody (ročně)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Vytvořit požadavek na materiál
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Podrobnosti o primární adrese
DocType: Project Template Task,Duration (Days),Délka (dny)
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Tabulka šablony zpětné vazby zákazníka
DocType: Purchase Invoice Item,Price List Rate,Ceníková sazba
DocType: Budget,Action if Annual Budget Exceeded on PO,"Opatření v případě, že roční rozpočet překročen o PO"
DocType: POS Profile,Campaign,Kampaň
DocType: POS Profile,Accounting,Účetnictví
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Na tomto území nastavte rozpočty skupinových položek. Můžete také zahrnout sezónnost nastavením Distribuce.
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Datum zahájení pojištění by mělo být kratší než datum ukončení pojištění
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,Probíhají položky {0}
DocType: Item,Foreign Trade Details,Podrobnosti o zahraničním obchodu
DocType: Quality Review Table,Yes/No,Ano ne
DocType: Tally Migration,Is Master Data Imported,Je importována kmenová data
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Položka Řádek daně {0} musí mít účet typu daně nebo příjmu nebo nákladů nebo účtovatelné položky
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} není platné číslo šarže pro položku {1}
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,Další informace
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Kreditní poznámka {0} byla vytvořena automaticky
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Ve frontě pro nahrazení kusovníku. Může to trvat několik minut.
DocType: Lab Test,Result Date,Výsledek Datum
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Hlavní měnový kurz.
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Nejnovější cena aktualizována ve všech kusovníků
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Série byla úspěšně aktualizována
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Vyberte kód položky
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Pro vybranou položku je vyžadován výchozí sklad
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Žádná položka se sériovým číslem {0}
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Typ a strana strany je povinná pro účet {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Účetní
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},Platební poukaz POS alreday existuje pro {0} mezi datem {1} a {2}
apps/erpnext/erpnext/config/help.py,Navigating,Navigace
DocType: Authorization Rule,Customer / Item Name,Název zákazníka / položky
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nové sériové číslo nemůže mít sklad. Sklad musí být nastaven skladovým vstupem nebo nákupním dokladem
DocType: Issue,Via Customer Portal,Přes Zákaznický portál
DocType: Work Order Operation,Planned Start Time,Plánovaný čas spuštění
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} je {2}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet účtovaných odpisů nesmí být větší než celkový počet odpisů
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Knihovna akcií
DocType: Journal Entry,Accounts Payable,Závazky
DocType: Job Offer,Select Terms and Conditions,Vyberte smluvní podmínky
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Datum ukončení nemůže být před datem příštího kontaktu.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Zboží je již přijato proti vnějšímu vstupu {0}
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorie osvobození od daně
DocType: Sales Invoice,Debit To,Debetovat
DocType: Company,Date of Establishment,Datum založení
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Typ dovolené je šílenství
DocType: Sales Invoice,Sales Taxes and Charges Template,Prodejní daně a poplatky šablona
DocType: Purchase Receipt,Return Against Purchase Receipt,Return Against Purchase Receipt
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Studentská skupina:
DocType: Cheque Print Template,Cheque Size,Zkontrolujte velikost
,Consolidated Financial Statement,Konsolidovaná účetní závěrka
DocType: Cheque Print Template,Scanned Cheque,Naskenovaná kontrola
DocType: Restaurant Reservation,Reservation End Time,Čas ukončení rezervace
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,V hodnotě
DocType: Job Opening,Staffing Plan,Personální plán
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materiál převedený na výrobu
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Vyhrazeno pro výrobu
DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neevidovaných fondů
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Požadavek na materiál č
DocType: Payment Reconciliation,Unreconciled Payment Details,Podrobnosti o nesrovnaných platbách
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Hodnoty RFQ nejsou povoleny pro {0} z důvodu postavení karty {1}
DocType: Bank Guarantee,Validity in Days,Platnost ve dnech
DocType: Price List,Applicable for Countries,Platí pro země
DocType: Supplier,Individual,Individuální
DocType: Clinical Procedure Template,Clinical Procedure Template,Šablona klinického postupu
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Čistá hodnota aktiv
DocType: Sales Invoice,Redemption Account,Účet zpětného odkupu
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Strom skupin položek.
DocType: BOM,Show Items,Zobrazit položky
DocType: Journal Entry,Paid Loan,Placený úvěr
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Opravdu chcete toto aktivum vyřadit?
DocType: Production Plan Sales Order,Sales Order Date,Datum prodejní objednávky
DocType: Workstation,Operating Costs,Provozní náklady
DocType: Supplier Quotation Item,Lead Time in days,Dodací lhůta ve dnech
DocType: Loan,Repay from Salary,Splácení z platu
DocType: Discounted Invoice,Discounted Invoice,Zvýhodněná faktura
DocType: Leave Block List Allow,Leave Block List Allow,Opustit seznam bloků Povolit
DocType: Serial No,AMC Expiry Date,Datum vypršení AMC
DocType: Asset,Number of Depreciations Booked,Počet rezervovaných odpisů
DocType: Student Group Creation Tool,Student Group Creation Tool,Nástroj pro vytvoření studentské skupiny
,Purchase Order Items To Be Billed,"Položky objednávky, které mají být fakturovány"
DocType: Leave Period,Holiday List for Optional Leave,Dovolená pro volitelnou dovolenou
apps/erpnext/erpnext/config/accounting.py,Default settings for accounting transactions.,Výchozí nastavení pro účetní operace.
DocType: Purchase Invoice,Scan Barcode,Skenování čárového kódu
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Aktualizovat číslo nákladového střediska
DocType: Purchase Invoice Item,Service Start Date,Datum zahájení služby
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Nábytek a svítidla
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Váha kritérií musí přidat až 100%
DocType: Authorization Rule,Average Discount,Průměrná sleva
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Sleva musí být nižší než 100%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Akumulované odpisy k
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Proměnná skóre scorecard dodavatele
DocType: Cheque Print Template,Message to show,Zpráva k zobrazení
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Žádní studenti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Dočasné účty
DocType: Invoice Discounting,Bank Charges,Bankovní poplatky
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Převedené zboží
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Podrobnosti o primárním kontaktu
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zaškrtnuto, musí být seznam přidán na každé oddělení, kde má být použit."
DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,Parametr {0} je neplatný
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Žádný popis není uveden
DocType: Accounting Period,Closed Documents,Uzavřené dokumenty
DocType: Project,Gross Margin,Hrubá marže
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Účet přecenění směnného kurzu
DocType: Quotation,Quotation To,Citace
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Položka nastavení výpisu z účtu
DocType: Naming Series,Setup Series,Setup Series
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Znovu načíst propojenou analýzu
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Množství musí být menší nebo rovné {0}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Out Množství
DocType: Payment Request,Outward,Vnější
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Do výše uvedené tabulky zadejte zákazky odběratele
DocType: Invoice Discounting,Bank Charges Account,Účet bankovních poplatků
DocType: Journal Entry,Get Outstanding Invoices,Získejte nezaplacené faktury
DocType: Opportunity,Opportunity From,Příležitost Od
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Detaily cíle
DocType: Item,Customer Code,Zákaznický kód
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Zadejte nejprve položku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Seznam webových stránek
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,Neplatný GSTIN! Zadaný vstup neodpovídá formátu GSTIN.
DocType: Item Reorder,Re-order Qty,Re-order Qty
DocType: Asset,Maintenance Required,Vyžaduje se údržba
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Název dokumentu
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Vedoucí Vlastník nemůže být stejný jako Vedoucí
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","např. Banka, Hotovost, Kreditní karta"
DocType: Item,Serial Number Series,Sériové číslo
apps/erpnext/erpnext/config/accounting.py,Bank Statement Transaction Entry List,Seznam vstupů transakce výpisu z účtu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Poštovní náklady
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Řízení
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Zobrazení logů věrnostních bodů přiřazených zákazníkovi.
DocType: Item,If subcontracted to a vendor,Pokud se jedná o subdodavatele
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Navštivte fóra
DocType: C-Form,C-Form,C-forma
DocType: Asset Maintenance,Maintenance Team,Tým údržby
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} na půl dne Dovolená {1}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Kombinovaná částka faktury se musí rovnat 100%
DocType: Patient,Occupational Hazards and Environmental Factors,Pracovní rizika a faktory životního prostředí
DocType: Volunteer,Volunteer,Dobrovolník
DocType: Lab Test,Custom Result,Vlastní výsledek
DocType: Issue,Opening Date,Datum otevření
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,Vybrané kusovníky nejsou pro stejnou položku
DocType: Delivery Note,Delivery To,Doručit
DocType: Bank Statement Transaction Settings Item,Bank Data,Bankovní data
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Naplánováno Upto
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Udržujte fakturační hodiny a pracovní hodiny stejné na časovém rozvrhu
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Vedení stopy podle zdroje olova.
DocType: Clinical Procedure,Nursing User,Ošetřovatelský uživatel
DocType: Support Settings,Response Key List,Seznam klíčových odpovědí
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Stárnutí založené na
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Zůstatek
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sklad, kde udržujete zásoby zamítnutých položek"
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Maloobchodní
,Maintenance Schedules,Plány údržby
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladové středisko do knihy, protože má podřízené uzly"
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Zadejte alespoň jeden atribut v tabulce Atributy
DocType: Company,Create Chart Of Accounts Based On,Vytvořit graf účtů na základě
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktura {0} musí být zrušena před zrušením této prodejní objednávky
DocType: Item,Default Purchase Unit of Measure,Výchozí měrná jednotka nákupu
DocType: Location,Location Details,Podrobnosti o poloze
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Základní sazba (podle skladem UOM)
DocType: Travel Request Costing,Travel Request Costing,Kalkulace požadavku na cestování
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Vytvořit prodejní fakturu
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Od Času nemůže být větší než Čas.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,To Date nemůže být menší než From Date
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Správa stromu území.
DocType: GL Entry,Voucher Type,Typ poukázky
,Serial No Service Contract Expiry,Zánik smlouvy Serial No Service
DocType: Certification Application,Certified,Certifikováno
DocType: Purchase Invoice Item,Manufacture,Výroba
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} vyrobených položek
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Žádost o platbu pro {0}
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Dny od posledního řádu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Nastavit výchozí platební nebo bankovní účet v režimu platby {0}
DocType: Student Group,Instructors,Instruktoři
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Mark Present
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků mohou být tyto kódy použity v tiskových formátech, jako jsou faktury a dodací listy"
DocType: Amazon MWS Settings,Enable Amazon,Povolit Amazon
DocType: Loan,Total Interest Payable,Celkové úroky
DocType: Topic,Topic Content,Obsah tématu
DocType: Sales Invoice,Company Address Name,Název adresy společnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Zboží v tranzitu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,V této objednávce můžete uplatnit pouze maximální počet bodů {0}.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Nastavte účet ve skladu {0}
DocType: Quality Action,Resolution,Rozlišení
DocType: Sales Invoice,Loyalty Points Redemption,Vykoupení věrnostních bodů
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Celková zdanitelná hodnota
DocType: Patient Appointment,Scheduled,Naplánováno
DocType: Sales Partner,Partner Type,Typ partnera
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Dovoz služeb
DocType: Employee Education,School/University,Škola / univerzita
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: Konverzní faktor UOM je povinný
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Referenční číslo
DocType: Work Order,Additional Operating Cost,Dodatečné provozní náklady
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor sběru (= 1 LP)
DocType: Serial No,Delivery Document Type,Typ dodacího dokumentu
DocType: Products Settings,Attributes,Atributy
DocType: Bank Guarantee,Bank Guarantee,Bankovní záruka
DocType: Territory,Territory Name,Název území
DocType: Item Price,Minimum Qty ,Minimální množství
DocType: Supplier Scorecard,Per Week,Za týden
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozornit na novou žádost o nabídky
DocType: Account,Tax,Daň
DocType: Delivery Stop,Visited,Navštívil
DocType: Loyalty Program,Auto Opt In (For all customers),Automatická volba (pro všechny zákazníky)
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je měna zákazníka převedena na základní měnu zákazníka"
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,"Platí, pokud je společnost individuální nebo vlastnická"
DocType: Restaurant,Restaurant,Restaurace
DocType: Delivery Stop,Address Name,Název adresy
DocType: Employee Promotion,Employee Promotion,Propagace zaměstnanců
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Pro zápis do deníku nebyly vybrány žádné splátky
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastavit hodnotu faktury pro B2C. B2CL a B2CS vypočtené na základě této fakturační hodnoty.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nelze odečíst, když je kategorie pro „Ocenění“ nebo „Vaulace a Celkem“"
DocType: Quality Goal,Revised On,Upraveno dne
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please enter Root Type for - {0},Zadejte typ kořene pro - {0}
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,"Položka, na kterou odkazuje {0} - {1}, je již fakturována"
DocType: Driver,Suspended,Pozastaveno
DocType: Asset Category Account,Accumulated Depreciation Account,Účet kumulovaných odpisů
DocType: Journal Entry Account,Credit in Company Currency,Úvěr v měně společnosti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Zábava a volný čas
DocType: Email Digest,New Sales Invoice,Nová prodejní faktura
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Čistý zisk
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Další prodejní osoba {0} existuje se stejným ID zaměstnance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Uzavření (Dr)
DocType: Loyalty Point Entry,Loyalty Program Tier,Věrnostní program Tier
DocType: Purchase Invoice,Total Taxes and Charges,Celkové daně a poplatky
DocType: Amazon MWS Settings,JP,JP
DocType: Work Order Operation,Operation Description,Popis operace
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Položky transakce banky
DocType: HR Settings,Leave Approval Notification Template,Ponechte šablonu oznámení o schválení
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Typ dokumentu
DocType: Email Digest,New Purchase Invoice,Nová nákupní faktura
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Požadované množství: Množství požadované pro nákup, ale není objednáno."
DocType: Purchase Invoice,Supplier Name,Jméno dodavatele
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Chcete-li načíst položku Serial No Item pro položku {0}, klikněte prosím na odkaz Generovat plán."
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Náklady na dodané položky
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Spotřebováno
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Právní subjekt / dceřiná společnost se samostatnou účtovou osnovou patřící organizaci.
DocType: BOM,Show In Website,Zobrazit na webových stránkách
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pravidla cen jsou pak filtrována na základě Zákazníka, Zákaznické skupiny, Území, Dodavatele, Typu dodavatele, Kampaně, Prodejního partnera atd."
DocType: Payment Request,Payment Request Type,Typ požadavku na platbu
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Pole Pro akcionáře nemůže být prázdné
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro používání Point-of-Sale
DocType: Purchase Order,Purchase Order Pricing Rule,Pravidlo pro cenu objednávky
DocType: Expense Claim,Expenses,Náklady
DocType: Employee,Cheque,Kontrola
DocType: Purchase Invoice,Currency and Price List,Měna a ceník
DocType: Shopify Settings,Shop URL,Adresa URL obchodu
DocType: Asset Movement,Source Location,Zdroj Umístění
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Zadaná hodnota musí být kladná
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Povolení nákladového střediska v rozvaze
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Účast
DocType: Training Event,Internet,Internet
DocType: Monthly Distribution,Monthly Distribution Percentages,Měsíční procenta distribuce
DocType: Delivery Settings,Dispatch Notification Template,Šablona oznámení o odeslání
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Celkem (bez daně)
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapování peněžních toků
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Cash Flow Mapper,Section Leader,Vedoucí sekce
,Budget Variance Report,Zpráva o rozdílech v rozpočtu
DocType: Asset,Gross Purchase Amount,Hrubá částka nákupu
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Poloviční den je povinný
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Odebrané položky bez změny množství nebo hodnoty.
DocType: Loan,Applicant Type,Typ žadatele
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Na adresu 2
DocType: Purchase Receipt,Range,Rozsah
DocType: Budget,BUDGET,ROZPOČET
DocType: Journal Entry,Depreciation Entry,Odpis Vstup
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Ceník (měna společnosti)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Nezaplaceno a nedoručeno
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Byla vytvořena prodejní faktura {0}
DocType: Quality Review Table,Objective,Objektivní
DocType: Inpatient Record,Admission Scheduled,Plánované přijetí
DocType: Purchase Order Item,To be delivered to customer,K dodání zákazníkovi
DocType: Attendance Request,On Duty,Ve službě
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,Proměnná
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Řádek {0}: Vyžaduje se datum zahájení odpisu
DocType: Options,Option,Volba
DocType: Healthcare Settings,Out Patient SMS Alerts,Výstrahy pacienta SMS
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Prodejní účet
DocType: Weather,Weather Parameter,Parametr počasí
DocType: Leave Control Panel,Allocate,Přidělit
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Detail plánu údržby
DocType: BOM Update Tool,BOM Update Tool,Nástroj pro aktualizaci BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Výpovědní lhůta
,Lead Owner Efficiency,Účinnost vedoucího vlastníka
DocType: SMS Center,Total Characters,Celkový počet znaků
DocType: Patient,Alcohol Past Use,Alkohol minulé použití
DocType: Patient,Divorced,Rozvedený
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automatické přidělení záloh (FIFO)
DocType: Leave Type,Is Compensatory,Je kompenzační
,Employees working on a holiday,Zaměstnanci pracující na dovolené
DocType: Healthcare Practitioner,Mobile,"mobilní, pohybliví"
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Časové rozvrhy pomáhají sledovat čas, náklady a fakturaci za aktivity provedené vaším týmem"
DocType: Delivery Stop,Order Information,Informace o objednávce
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Mezisoučet
DocType: Invoice Discounting,Invoice Discounting,Diskontování faktur
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Č
DocType: Stock Settings,Freeze Stock Entries,Záznamy zmrazení zásob
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Položka {0} nebyla nalezena
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Zadali jste duplicitní položky. Opravte to a zkuste to znovu.
DocType: Purchase Invoice Item,Rate,Hodnotit
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Ukládání {0}
DocType: SMS Center,Total Message(s),Celkový počet zpráv
DocType: Purchase Invoice,Accounting Dimensions,Účetní rozměry
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Skupina podle účtu
DocType: Quotation,In Words will be visible once you save the Quotation.,V aplikaci Words budou viditelné po uložení nabídky.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Množství k výrobě
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Řádek # {0}: Nelze nastavit rychlost, pokud je částka vyšší než fakturovaná částka pro položku {1}."
DocType: Work Order Operation,Actual Start Time,Skutečný čas spuštění
DocType: Antibiotic,Laboratory User,Uživatel laboratoře
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Online aukce
DocType: Fee Schedule,Fee Creation Status,Stav vytvoření poplatku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Software
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Objednávka odběratele k platbě
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,To je založeno na transakcích proti tomuto lékaři.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Přiřazení struktur ...
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Podrobnosti o provedených operacích.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Operation Time must be greater than 0 for Operation {0},Doba provozu musí být větší než 0 pro provoz {0}
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion musí mít alespoň jednu správnou volbu
DocType: Shareholder,Folio no.,Folio č.
DocType: Inpatient Record,A Negative,Negativní
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} je povinné pro položku {1}
,Production Analytics,Analytika výroby
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavit dodavatele pro položku {1}
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Evidence
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},Případ č. Již používán. Zkuste to z případu č. {0}
DocType: Chapter Member,Website URL,URL stránky
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Typ zprávy je povinný
DocType: Vehicle,Policy No,Politika č
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Odpovědi
DocType: Supplier Scorecard Scoring Variable,Variable Name,Název proměnné
DocType: Rename Tool,Utilities,Utility
DocType: Job Card,Total Completed Qty,Celkem dokončeno Množství
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Žádné položky s kusovníky k výrobě
DocType: Purchase Order Item,Blanket Order Rate,Sazba deku
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledujte samostatné výnosy a náklady pro vertikální produkty nebo divize.
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Upozornění: Neplatný certifikát SSL k příloze {0}
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Count
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Jako examinátor
DocType: Company,Default Expense Claim Payable Account,Výchozí splatný účet
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-.
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Vyhledávání dokumentů
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,Datum ukončení nesmí být menší než datum zahájení
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Žádné položky s kusovníku.
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Jednotka jednotky.
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Citáty
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Nelze vygenerovat Secret
DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a součet
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Činnost člena
DocType: Upload Attendance,Import Attendance,Importovat účast
DocType: POS Profile,Account for Change Amount,Účet pro změnu částky
,Item Price Stock,Položka Cena Sklad
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.","Požadavek na nabídku je zakázán pro přístup z portálu, pro další nastavení nastavení portálu."
DocType: Bank Statement Settings Item,Mapped Header,Namapované záhlaví
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Položka Kód, sklad, množství na řádku"
DocType: Payment Order Reference,Bank Account Details,Detaily bankovního účtu
DocType: Homepage,Homepage Slideshow,Domovská stránka Prezentace
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Částečně sponzorováno, vyžadují částečné financování"
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Platba {0} od {1} do {2}
,Serial No Status,Stav sériového čísla
DocType: Donor,Donor,Dárce
DocType: BOM,Item UOM,Položka UOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Řádek {0}: vyberte pracovní stanici proti operaci {1}
DocType: Stock Settings,Default Return Warehouse,Default Return Warehouse
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} musí být odesláno
DocType: Project,Estimated Cost,Odhadované náklady
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/config/non_profit.py,Member information.,Informace o členech.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Zpětný záznam deníku
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,"Nastavte prodejní cíl, který chcete dosáhnout pro vaši společnost."
DocType: Lab Test Template,Special,Speciální
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,"Vyhrazené množství pro subdodávky: Množství surovin, aby se subcotracted položky."
DocType: Patient Encounter,In print,V tisku
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Nelze načíst informace pro {0}.
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Fakturační měna se musí rovnat výchozí měně společnosti nebo měně účtu strany
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Zadejte ID zaměstnance této prodejní osoby
apps/erpnext/erpnext/config/accounting.py,Create Opening Sales and Purchase Invoices,Vytvořit otevírací prodej a nákupní faktury
DocType: Disease,Treatment Period,Období léčby
apps/erpnext/erpnext/config/settings.py,Setting up Email,Nastavení e-mailu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Částka debetní částky
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou je měna Ceníku převedena na základní měnu zákazníka"
apps/erpnext/erpnext/hooks.py,Certification,Osvědčení
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
DocType: Journal Entry,Print Heading,Tisk nadpisu
DocType: Grant Application,Withdrawn,Stáhnuto
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Nejdříve vyberte společnost
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Období aplikace nemůže být napříč dvěma alokačními záznamy
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Hodnotit:
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Zaměstnanec {0} nemá žádnou maximální částku
DocType: Employee Skill Map,Employee Skills,Zaměstnanecké dovednosti
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Jméno studenta:
DocType: SMS Log,Sent On,Odesláno
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Prodejní faktura
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time can't be greater than Resolution Time,Doba odezvy nemůže být větší než doba rozlišení
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pro studentskou skupinu založenou na kurzu bude kurz validován pro každého studenta ze zapsaných předmětů v programu.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Dodávky uvnitř státu
DocType: Employee,Create User Permission,Vytvořit oprávnění uživatele
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Sestavu uložte znovu a znovu sestavte nebo aktualizujte
DocType: C-Form Invoice Detail,Territory,Území
DocType: C-Form,Quarter,Čtvrťák
DocType: Purchase Invoice,Grand Total (Company Currency),Celkový součet (měna společnosti)
DocType: Prescription Dosage,Prescription Dosage,Dávkování na předpis
DocType: Salary Slip,Hour Rate,Hodinová sazba
DocType: Location,Latitude,Zeměpisná šířka
DocType: Expense Claim Detail,Expense Date,Datum výdajů
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Zobrazit podrobnosti platby
DocType: Company,Default Payable Account,Výchozí platební účet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Sériové číslo {0} nepatří do žádného skladu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Skupina podle stran
DocType: Volunteer,Evening,Večer
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Výměna zisku / ztráty
DocType: Payment Request,Make Sales Invoice,Vytvořit prodejní fakturu
DocType: Opening Invoice Creation Tool,Create Missing Party,Vytvořit chybějící stranu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Množství {0} by nemělo být větší než počet pracovních příkazů {1}
DocType: Landed Cost Voucher,Additional Charges,Další poplatky
DocType: Assessment Result Tool,Assessment Result Tool,Nástroj pro hodnocení výsledku
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Student Applicant,Application Status,Stav přihlášky
DocType: Journal Entry,Total Amount in Words,Celková částka ve slovech
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ","Sledujte prodejní kampaně. Sledujte potenciální zákazníky, nabídky, zakázky odběratele atd. Z kampaní a změřte návratnost investic."
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Chybějící směnné kurzy měny pro {0}
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina cenových položek
DocType: Quality Inspection Reading,Reading 8,Čtení 8
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Od fiskálního roku
DocType: Tally Migration,Tally Creditors Account,Účet věřitelů
DocType: Student Report Generation Tool,Print Section,Tisk sekce
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Toto je kořenové oddělení a nelze jej upravovat.
,Project Quantity,Množství projektu
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky prodeje nebo nákupu.
DocType: Sales Invoice,Customer PO Details,Podrobnosti o objednávce zákazníka
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Pacient nebyl nalezen
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,"Odstraňte položku, pokud se na tuto položku nevztahují poplatky"
apps/erpnext/erpnext/selling/doctype/customer/customer.py,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Skupina zákazníků existuje se stejným jménem, prosím, změňte jméno zákazníka nebo přejmenujte skupinu zákazníků"
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The 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.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **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.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. 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).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardní vzor daně, který lze použít pro všechny obchodní transakce. Tato šablona může obsahovat seznam daňových hlav a také další náklady / příjmy hlavy jako &quot;doprava&quot;, &quot;pojištění&quot;, &quot;manipulace&quot; atd. #### Poznámka Zde definovaná sazba daně bude standardní sazbou daně pro všechny ** Položky **. Pokud existují ** Položky **, které mají různé sazby, musí být přidány do ** Položka Daň ** ** v ** Položka ** master. #### Popis sloupců 1. Typ výpočtu: - Toto může být na ** Čistý součet ** (což je součet základní částky). - ** Na předchozí řádek celkem / částka ** (pro kumulativní daně nebo poplatky). Pokud vyberete tuto možnost, bude daň použita jako procento z předchozího řádku (v daňové tabulce) částky nebo celkem. - ** Skutečnost ** (jak je uvedeno). 2. Vedoucí účtu: Účetní kniha, pod kterou bude tato daň zaúčtována 3. Nákladové středisko: Pokud je daň / poplatek příjmem (např. Přepravou) nebo nákladem, musí být zaúčtován proti nákladovému středisku. 4. Popis: Popis daně (která bude vytištěna na fakturách / kottech). 5. Sazba: Sazba daně. 6. Částka: Částka daně. 7. Celkem: Kumulativní součet k tomuto bodu. 8. Zadejte řádek: Pokud na základě &quot;Předchozí řádek celkem&quot; můžete vybrat číslo řádku, které bude použito jako základ pro tento výpočet (výchozí je předchozí řádek). 9. Je tato daň zahrnuta do základní sazby ?: Pokud toto zkontrolujete, znamená to, že tato daň nebude zobrazena pod tabulkou položek, ale bude zahrnuta do základní sazby v tabulce hlavních položek. To je užitečné tam, kde chcete dát paušální cenu (včetně všech daní) zákazníkům."
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Datum musí být větší než od data
DocType: Customer Group,Parent Customer Group,Rodičovská skupina zákazníků
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Ceny nebudou zobrazeny, pokud není nastaven Ceník"
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,ERPNext Nastavení
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Časový výkaz pro výrobu.
DocType: Student Language,Student Language,Jazyk studenta
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Nastavte prosím Platební plán
DocType: Travel Request,Name of Organizer,Jméno organizátora
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Nastavte účty týkající se odpisů v kategorii aktiv {0} nebo společnosti {1}
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Zkontrolujte rozměry kót pro tisk
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Máte-li jakékoli dotazy, obraťte se na nás."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Potvrzení o nákupu {0} není odesláno
DocType: Task,Total Expense Claim (via Expense Claim),Celkový nárok na výdaje (prostřednictvím nároku na výdaje)
DocType: Quality Goal,Quality Goal,Cíl kvality
DocType: Support Settings,Support Portal,Portál podpory
apps/erpnext/erpnext/projects/doctype/project/project.py,End date of task <b>{0}</b> cannot be less than <b>{1}</b> expected start date <b>{2}</b>,Datum ukončení úlohy <b>{0}</b> nemůže být kratší než <b>{1}</b> očekávané datum zahájení <b>{2}</b>
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Zaměstnanec {0} je na dovolené {1}
DocType: Employee,Held On,Zapnuto
DocType: Healthcare Practitioner,Practitioner Schedules,Plány praktikujících
DocType: Project Template Task,Begin On (Days),Začátek dne (dny)
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Pokud je tato možnost povolena, systém vytvoří materiál i v případě, že jsou suroviny k dispozici"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Pracovní příkaz byl {0}
DocType: Inpatient Record,Admission Schedule Date,Termín přijetí Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Úprava hodnoty aktiv
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Dodávky pro neregistrované osoby
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,Všechny práce
DocType: Appointment Type,Appointment Type,Typ schůzky
DocType: Manufacturing Settings,Allow Overtime,Povolit přesčasy
DocType: Sales Invoice Item,Available Qty at Warehouse,K dispozici ve skladu
DocType: Sales Invoice Item,Sales Invoice Item,Položka prodejní faktury
DocType: Additional Salary,HR,HR
DocType: Student Report Generation Tool,Assessment Terms,Podmínky hodnocení
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Přírůstek pro atribut {0} nemůže být 0
DocType: Leave Control Panel,Carry Forward,Převádět
DocType: Dependent Task,Dependent Task,Závislý úkol
DocType: Allowed To Transact With,Allowed To Transact With,Povoleno Transakci S
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Staňte se prodávajícím
DocType: Bank Reconciliation,Bank Reconciliation,Bankovní vyúčtování
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Typy činností pro časové záznamy
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,Pokladní faktury POS
DocType: Inpatient Record,AB Negative,AB Negative
DocType: Company,Budget Detail,Detail rozpočtu
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normální referenční rozsah pro dospělého je 16–20 dechů / minutu (RCP 2012)
DocType: Production Plan,Sales Orders,Objednávky odběratele
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Vytvořit záznam deníku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Zajištěné půjčky
DocType: Share Transfer,To Shareholder,Pro akcionáře
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Plán údržby
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",Kapitoly / název_kapitoly ponechají po uložení kapitoly automaticky prázdné.
DocType: Shopping Cart Settings,Payment Success Url,Adresa URL úspěchu platby
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dodaná částka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt nemůže být větší než Max Amt
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Struktura platu nenalezena pro zaměstnance {0} a datum {1}
DocType: Healthcare Settings,Invoice Appointments Automatically,Schvalování faktur automaticky
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,Vyplňte prosím všechny údaje pro vygenerování výsledku vyhodnocení.
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Varianta ({})
DocType: Healthcare Settings,Patient Name,Jméno pacienta
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Vaše organizace
DocType: Contract,Fulfilment Details,Podrobnosti o plnění
DocType: Project,Total Billed Amount (via Sales Invoices),Celková fakturovaná částka (prostřednictvím prodejních faktur)
apps/erpnext/erpnext/utilities/user_progress.py,Kg,Kg
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Jmenování bylo zrušeno
DocType: Healthcare Settings,Reminder Message,Zpráva připomenutí
DocType: Repayment Schedule,Balance Loan Amount,Částka zůstatku úvěru
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Správa stromu prodejních osob.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,Tento měsíc je více prázdnin než pracovních dnů.
DocType: Item,Default BOM,Výchozí kusovník
DocType: BOM,Operating Cost (Company Currency),Provozní náklady (měna společnosti)
DocType: Item Price,Item Price,Cena položky
DocType: Payment Entry,Party Name,Název strany
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Vyberte prosím zákazníka
DocType: Program Enrollment Tool,New Program,Nový program
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix",Číslo nového nákladového střediska bude jako předpona zahrnuto do názvu nákladového střediska
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Vyberte zákazníka nebo dodavatele.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Platnost do data nemůže být před datem transakce
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit kusovník, protože je propojen s jinými kusovníky"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Místo dodání (stát / UT)
DocType: Job Opening,Job Title,Pracovní pozice
DocType: Fee Component,Fee Component,Poplatek
apps/erpnext/erpnext/config/accounting.py,C-Form records,Záznamy C-Form
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Platba byla zrušena. Další podrobnosti naleznete v účtu GoCardless
DocType: Crop Cycle,Less than a year,Méně než rok
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Pracovní příkaz {0} musí být předložen
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,Filtr celkem Zero Qty
DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,V tabulce Faktury nebyly nalezeny žádné záznamy
DocType: Chart of Accounts Importer,Chart of Accounts Importer,Dovozce účtové osnovy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Položka nebo sklad pro řádek {0} neodpovídá požadavku na materiál
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,Částka IGST
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Poznámky k doručení {0} byly aktualizovány
DocType: Travel Itinerary,Lodging Required,Požadováno ubytování
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Celkové příjmy
DocType: Student Group Student,Student Group Student,Studentská studentská skupina
DocType: Customer,Buyer of Goods and Services.,Kupující zboží a služeb.
DocType: Vehicle,Vehicle,Vozidlo
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Množství ({0}) nemůže být zlomkem v řádku {1}
DocType: Retention Bonus,Bonus Amount,Částka bonusu
DocType: Stock Reconciliation Item,Amount Difference,Rozdíl množství
DocType: Asset Maintenance,Maintenance Tasks,Úkoly údržby
DocType: HR Settings,Stop Birthday Reminders,Zastavte připomenutí narozenin
DocType: Payment Gateway Account,Payment Account,Platební účet
DocType: Stock Settings,Stock Frozen Upto,Skladem Zmrazené Upto
DocType: Item,Default Material Request Type,Výchozí typ požadavku na materiál
DocType: Clinical Procedure Item,Clinical Procedure Item,Položka klinického postupu
DocType: Finance Book,Finance Book,Finanční knihy
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Od Datetime
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},Měna ceníku {0} musí být {1} nebo {2}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Otevřené příkazy
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Připustit
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Celkem {0} ({1})
DocType: Certified Consultant,GitHub ID,ID GitHub
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Z adresy 1
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Celkový počet hodin: {0}
DocType: Employee Transfer,Transfer Date,Datum převodu
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Pokud je zdrojem dotazu kampaň, zadejte název kampaně"
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tato položka je šablona a nelze ji použít v transakcích. Atributy položek budou zkopírovány do variant, pokud není nastavena možnost No Copy"
DocType: Cheque Print Template,Regular,Pravidelný
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Maximální sleva na položku {0} je {1}%
DocType: Production Plan,Not Started,Nezačal
DocType: Disease,Treatment Task,Úkol pro ošetření
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Row {0}: user has not applied rule <b>{1}</b> on the item <b>{2}</b>,Řádek {0}: uživatel nepoužil pravidlo <b>{1}</b> na položku <b>{2}</b>
DocType: Landed Cost Voucher,Landed Cost Help,Pomoc s náklady na přistání
DocType: Supplier Scorecard,Scoring Criteria,Kritéria hodnocení
DocType: Bank Statement Transaction Entry,Matching Invoices,Odpovídající faktury
DocType: Donor,Donor Name,Jméno dárce
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Vyberte možnost Vlastnost
DocType: Homepage,Homepage Section,Domovská stránka
DocType: Assessment Result,Grade,Školní známka
DocType: Production Plan Material Request,Production Plan Material Request,Požadavek na výrobní plán materiálu
DocType: Request for Quotation Supplier,Send Email,Poslat e-mailem
DocType: Item,Retain Sample,Zachovat vzorek
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Řádek # {0} (Tabulka plateb): Částka musí být záporná
,Warehouse wise Item Balance Age and Value,Warehouse moudrý Item Balance Age and Value
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Hrubá hmotnost balení. Obvykle čistá hmotnost + hmotnost obalového materiálu. (pro tisk)
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorní testování datetime
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline by Stage,Prodejní potrubí podle etapy
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Síla studentské skupiny
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Zadání transakce výpisu z účtu
DocType: Purchase Order,Get Items from Open Material Requests,Získejte položky z otevřených požadavků na materiál
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskální rok ** představuje finanční rok. Všechny účetní položky a ostatní významné transakce jsou sledovány proti ** fiskálnímu roku **.
DocType: Procedure Prescription,Procedure Name,Název procedury
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Přidat obchodní partnery
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Celkový počet
DocType: Payment Entry Reference,Outstanding,Vynikající
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Podání žádosti o osvobození od daně z příjmů zaměstnanců
DocType: Contract Fulfilment Checklist,Requirement,Požadavek
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Nebyla nalezena žádná aktivní nebo výchozí struktura mzdy pro zaměstnance {0} pro zadaná data
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Množství by mělo být větší než 0
DocType: Purchase Order Item,Supplier Quotation Item,Položka nabídky dodavatele
DocType: Appraisal,Appraisal Template,Šablona hodnocení
DocType: Item,Hub Category to Publish,Kategorie Hub pro publikování
DocType: Staffing Plan Detail,Current Openings,Aktuální otvory
apps/erpnext/erpnext/config/crm.py,Customer Database.,Databáze zákazníků.
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As On Date,Datum zahájení
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Dodací doklad {0} není odeslán
DocType: Appraisal Template Goal,Appraisal Template Goal,Cíl Hodnocení Cíl
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Uzavírání (Cr)
DocType: Restaurant Reservation,Restaurant Reservation,Rezervace restaurace
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Částka poslední objednávky
apps/erpnext/erpnext/config/desktop.py,Learn,Učit se
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Není povolen vícenásobný výchozí způsob platby
DocType: Crop Cycle,This will be day 1 of the crop cycle,To bude den 1 cyklu plodin
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} není spojeno s {2} {3}
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Účet nákladů nebo rozdílů je povinný pro položku {0}, protože ovlivňuje celkovou hodnotu akcií"
DocType: Purchase Invoice,Price List Exchange Rate,Ceník Směnný kurz
DocType: Purchase Invoice Item,Amount (Company Currency),Částka (měna společnosti)
DocType: Driver,Driver,Řidič
DocType: GST Account,CGST Account,Účet CGST
DocType: Loan,Disbursement Date,Datum vyplacení
apps/erpnext/erpnext/templates/pages/projects.html,New task,Nová úloha
DocType: Customer Feedback Table,Customer Feedback Table,Tabulka zpětné vazby zákazníků
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} není zapsáno do kurzu {2}
DocType: Asset Value Adjustment,Difference Amount,Částka rozdílu
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Šeky a vklady jsou zúčtovány nesprávně
DocType: Journal Entry,Cash Entry,Hotovostní vstup
DocType: GST Settings,GST Settings,Nastavení GST
,Item-wise Sales Register,Obchodní rejstřík
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Položka má varianty.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Rozdíl Částka musí být nulová
DocType: Fee Schedule,Institution,Instituce
DocType: Patient,Tobacco Current Use,Současné užívání tabáku
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Nastavte svůj
DocType: Payment Entry Deduction,Payment Entry Deduction,Odpočet vstupu platby
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Řádek # {0}: Dávka {1} má pouze {2} qty. Vyberte jinou dávku, která má k dispozici {3} qty, nebo rozdělte řádek do více řádků, aby bylo možné doručit / vydat z několika dávek"
DocType: Patient Appointment,Procedure,Postup
,Total Stock Summary,Celkový souhrn zásob
DocType: Purchase Invoice,Additional Discount,Dodatečná sleva
DocType: Healthcare Settings,Patient Name By,Jméno pacienta By
DocType: Healthcare Service Unit Type,Rate / UOM,Míra / UOM
DocType: Job Offer,Job Offer Terms,Podmínky nabídky práce
DocType: GL Entry,Debit Amount in Account Currency,Částka debetu v měně účtu
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} se musí objevit pouze jednou
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Účet výdajů / rozdílů ({0}) musí být účtem „Zisk nebo ztráta“
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Řádek č. {0}: Částka nemůže být větší než nárok na nevyřízenou částku proti nároku {1}. Částka čekající na vyřízení je {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Vážné peníze
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Všechny hodnotící karty dodavatele.
DocType: Sales Invoice,Terms and Conditions Details,Podrobnosti o podmínkách
DocType: Exchange Rate Revaluation,Get Entries,Získat položky
DocType: Vehicle Service,Service Item,Položka služby
DocType: Sales Invoice,Customer's Purchase Order,Objednávka zákazníka
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Chyba syntaxe ve vzorci nebo podmínce: {0}
DocType: Agriculture Analysis Criteria,Agriculture User,Zemědělství Uživatel
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Zadejte prosím Reqd podle data
DocType: Company,Total Monthly Sales,Celkový měsíční prodej
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Procentní měsíční distribuce
DocType: Stock Reconciliation,Reconciliation JSON,Smíření JSON
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Žádná položka s čárovým kódem {0}
DocType: Asset,Scrapped,Vyřazeno
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Doručení
DocType: Student Admission Program,Application Fee,Poplatek za žádost
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Zákazky odběratele nejsou k dispozici pro výrobu
DocType: Website Attribute,Attribute,Atribut
DocType: Rename Tool,Rename Log,Přejmenovat protokol
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,&#39;Na základě&#39; a &#39;Skupina By&#39; nemůže být stejné
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Ageing Warehouse-wise,Zobrazit Aging Warehouse-moudrý
DocType: Sales Invoice,Write Off Outstanding Amount,Odepsání nezaplacené částky
DocType: Payroll Entry,Employee Details,Podrobnosti o zaměstnancích
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Start Time can't be greater than End Time for {0}.,Čas spuštění nemůže být větší než Konec pro {0}.
DocType: Pricing Rule,Discount Amount,Výše slevy
DocType: Healthcare Service Unit Type,Item Details,Podrobnosti o položce
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Duplicitní daňové prohlášení {0} pro období {1}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Od dodacího listu
DocType: Holiday,Holiday,Dovolená
DocType: Cheque Print Template,Line spacing for amount in words,Řádkování pro množství ve slovech
DocType: Item Group,Item Group Defaults,Výchozí nastavení skupiny položek
DocType: Salary Component,Abbr,Abbr
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Reklamace záruky proti sériovému číslu
apps/erpnext/erpnext/config/desktop.py,Quality,Kvalitní
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} není skladem Položka
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodané náklady na suroviny
DocType: Employee,Permanent Address,Permanentní adresa
DocType: Asset,Booked Fixed Asset,Rezervovaný dlouhodobý majetek
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Vaše vstupenky
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Vytvořit nabídku dodavatele
DocType: Item,Inspection Required before Purchase,Kontrola je nutná před nákupem
DocType: Payment Entry,Payment Ordered,Platební příkaz
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Zdá se, že je problém s konfigurací serveru GoCardless serveru. Nebojte se, v případě selhání bude částka vrácena na váš účet."
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platby není nakonfigurován. Zkontrolujte prosím, zda byl účet nastaven na režim plateb nebo na profil POS."
DocType: Email Digest,Purchase Orders Items Overdue,Položky splatnosti nákupních objednávek
DocType: BOM,Inspection Required,Kontrola je nutná
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je zrušeno, takže akci nelze dokončit"
DocType: Project Template Task,Project Template Task,Úloha šablony projektu
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Kruhová referenční chyba
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: účet typu Zisk a ztráta {2} není povolen při otevírání vstupů
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Listing of Item ve více skupinách
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Účet s existující transakcí nelze převést na účet
DocType: POS Profile,Display Items In Stock,Zobrazit položky na skladě
DocType: Issue,Service Level,Úroveň služby
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Ostatní dodávky v zahraničí (Nil hodnoceno, výjimka)"
,TDS Payable Monthly,Měsíční splatnost TDS
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Před výběrem strany vyberte prosím datum účtování
,GST Purchase Register,GST Nákupní registr
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Automaticky přidat daně a poplatky z šablony daně z položky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Možnosti skladu
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Časový plán časového plánu zdravotnictví
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Klepnutím sem přidejte položky
DocType: Payment Schedule,Invoice Portion,Část faktury
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Daňová kategorie pro převažující daňové sazby.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Nerozdělený zisk
DocType: Grant Application,Requested Amount,Požadovaná částka
DocType: Salary Detail,Additional Amount,Dodatečná částka
DocType: Quiz,Quiz Configuration,Konfigurace kvízu
DocType: Mode of Payment,General,Všeobecné
DocType: Email Digest,Annual Expenses,Roční výdaje
apps/erpnext/erpnext/projects/doctype/project/project.py,Expected End Date can not be less than Expected Start Date,Datum očekávaného konce nemůže být menší než očekávaný datum zahájení
DocType: Global Defaults,Disable In Words,Zakázat ve slovech
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Čistá mzda nemůže být záporná
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Počet interakcí
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Řádek {0} # Položka {1} nemůže být převedena více než {2} proti objednávce {3}
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Shift,Posun
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Zpracování účtové osnovy a smluvních stran
DocType: Stock Settings,Convert Item Description to Clean HTML,Převést Popis položky na Vyčistit HTML
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Všechny skupiny dodavatelů
,Final Assessment Grades,Závěrečné hodnocení
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,"Úlohu {0} nelze zavřít, protože není závislý úkol {1} zavřený."
DocType: Promotional Scheme,Promotional Scheme Price Discount,Sleva na promo akce
DocType: Installation Note,Installation Note,Poznámka k instalaci
DocType: Student Admission,Application Form Route,Trasa formuláře žádosti
DocType: Work Order,Planned Operating Cost,Plánované provozní náklady
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Barva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} není v seznamu volitelných dovolených
DocType: Student Report Generation Tool,Show Marks,Zobrazit značky
DocType: Salary Component,Max Benefit Amount (Yearly),Max. Částka užitku (ročně)
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Řádek odpisů {0}: Další datum odpisu nemůže být před datem nákupu
DocType: Loyalty Program,Customer Group,Zákaznická skupina
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Datum zahájení fiskálního roku by měl být o jeden rok dřívější než konec účetního období
,BOM Items and Scraps,Položky kusovníku a zápisky
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Vysoká citlivost
DocType: Pricing Rule,Apply Discount on Rate,Použijte slevu na sazbu
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",Automaticky aktualizovat náklady na kusovník pomocí Plánovače na základě nejnovějšího kurzu / cenové sazby / poslední nákupní ceny surovin.
DocType: Tally Migration,Tally Company,Společnost Tally
DocType: Quiz Question,Quiz Question,Kvíz Otázka
DocType: Task Depends On,Task Depends On,Úkol závisí na
,Lead Id,Vedoucí Id
DocType: Subscription Plan Detail,Subscription Plan Detail,Detail předplatného plánu
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Vytvořeno {0} scorecard pro {1} mezi:
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Tento týden je shrnutí
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Kód pravidla pro stanovení ceny
DocType: Water Analysis,Storage Temperature,Teplota skladování
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Přímý příjem
apps/erpnext/erpnext/controllers/trends.py,Amt,Amt
,Sales Analytics,Analytika prodeje
DocType: Project,Total Billable Amount (via Timesheets),Celková zúčtovatelná částka (prostřednictvím výkazů)
DocType: Setup Progress Action,Domains,Domény
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required",Není dovoleno konfigurovat šablonu Lab Test podle potřeby
DocType: Item,Default Unit of Measure,Výchozí jednotka měření
DocType: Serial No,Distinct unit of an Item,Odlišná jednotka položky
DocType: Amazon MWS Settings,Synch Products,Synchronizace produktů
DocType: Supplier Scorecard Scoring Variable,Path,Cesta
DocType: Project Task,Task ID,ID úlohy
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Otevření (Dr)
DocType: Project,% Completed,% Dokončeno
DocType: Customer,Commission Rate,Sazba Komise
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Centrální daň
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Celková nezaplacená částka
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Maximální částka osvobození
DocType: Subscription Plan,Based on price list,Na základě ceníku
DocType: Stock Entry Detail,Additional Cost,Dodatečné náklady
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Závěrečný účet {0} musí být typu Liability / Equity
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Nastavení společnosti
DocType: Inpatient Occupancy,Check In,Zaškrtněte
apps/erpnext/erpnext/config/buying.py,Customer and Supplier,Zákazník a dodavatel
DocType: Issue,Support Team,Tým podpory
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Účet {0}: Nelze přiřadit jako nadřazený účet
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Položka Pevné aktiva musí být skladová položka.
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Nové číslo dávky (volitelné)
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Ganttův diagram
DocType: Employee Benefit Application Detail,Max Benefit Amount,Max
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} na dovolené {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,Opravdu chcete tento vyřazený majetek obnovit?
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Registrační poplatek nemůže být Zero
DocType: Item Tax Template,Item Tax Template,Šablona položky daně
DocType: Fiscal Year,Auto Created,Automatické vytvoření
DocType: Quality Objective,Quality Objective,Cíle kvality
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Vedení účtu v položce Odpovědnost nebo Vlastní kapitál, ve kterém bude Zisk / Ztráta zaúčtována"
DocType: GL Entry,Credit Amount in Account Currency,Částka kreditu v měně účtu
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Činnost zaměstnanců na palubě
DocType: Healthcare Service Unit,Parent Service Unit,Jednotka rodičovské služby
DocType: Sales Invoice,Include Payment (POS),Zahrnout platbu (POS)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Landed Cost Item,Receipt Document,Dokument příjmu
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Období hodnocení dodavatelů
DocType: Employee Grade,Default Salary Structure,Výchozí mzdová struktura
DocType: Exchange Rate Revaluation,Total Gain/Loss,Celkový zisk / ztráta
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Student je již zapsán.
DocType: Product Bundle,Parent Item,Rodičovská položka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Zprostředkování
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Pro zásilku {0} vytvořte potvrzení o koupi nebo nákupní fakturu
,Product Bundle Balance,Produkt Balíček Balance
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Název společnosti nemůže být společnost
DocType: Maintenance Visit,Breakdown,Zhroutit se
DocType: Inpatient Record,B Negative,B Negativní
DocType: Issue,Response By,Odpověď By
DocType: Purchase Invoice,Credit To,Kredit
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Tuto pracovní objednávku odešlete k dalšímu zpracování.
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovní záruky
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Dodáno: {0}
DocType: Quality Meeting Table,Under Review,V části Kontrola
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Zemědělství (beta)
,Average Commission Rate,Průměrná míra provize
DocType: Sales Invoice,Customer's Purchase Order Date,Datum objednávky zákazníka
apps/erpnext/erpnext/config/buying.py,All Contacts.,Všechny kontakty.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Použité listy
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Pole Od akcionáře nemůže být prázdné
DocType: Brand,Brand Defaults,Výchozí hodnoty značky
DocType: Task,Depends on Tasks,Záleží na úkolech
DocType: Healthcare Settings,Healthcare Settings,Nastavení zdravotní péče
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Studentské skupiny byly vytvořeny.
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Registrovat
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",Tento sklad bude použit k vytvoření Objednávek. Nouzový sklad je &quot;Obchody&quot;.
DocType: Vehicle Service,Oil Change,Výměna oleje
DocType: Project User,Project User,Uživatel projektu
DocType: Course,Assessment,Posouzení
DocType: Promotional Scheme,Price Discount Slabs,Cena Sleva Desky
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,noví zákazníci
DocType: Project,Total Expense Claim (via Expense Claims),Celkový nárok na výdaje (prostřednictvím nároků na výdaje)
DocType: Instructor Log,Other Details,Další detaily
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Po transakci s akciemi nelze změnit atributy. Vytvořte novou položku a přeneste ji do nové položky
DocType: Employee Attendance Tool,Employees HTML,Zaměstnanci HTML
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Zastavit uživatelům v následujících dnech ponechání aplikací Leave Applications.
DocType: Budget,Ignore,Ignorovat
,Sales Person Target Variance Based On Item Group,Prodejní cílová varianta založená na skupině položek
DocType: Education Settings,Current Academic Year,Aktuální akademický rok
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Odeslat / odsouhlasit platby
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastavení záloh a přidělení (FIFO)
DocType: BOM,Item to be manufactured or repacked,"Zboží, které má být vyrobeno nebo přebaleno"
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,Nový košík
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Nejprve vyberte možnost Vzorový skladový sklad
DocType: Lab Test Template,Result Format,Formát výsledků
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Vedoucí (nebo skupiny), proti kterým jsou prováděny účetní položky, a zůstatky."
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Požadavek materiálu použitý k provedení této položky
DocType: Request for Quotation,Link to material requests,Odkaz na materiálové požadavky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Nezajištěné půjčky
apps/erpnext/erpnext/public/js/event.js,Add Customers,Přidat zákazníky
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Výchozí sklad dokončeného zboží
DocType: Grant Application,Grant Description,Popis grantu
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedena, nProsím uveďte také &quot;Hmotnost UOM&quot;"
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1} je zakázáno
DocType: Contract,Contract Period,Smluvní období
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,Zadejte kód položky pro získání čísla šarže
DocType: Cash Flow Mapping,Is Working Capital,Je pracovní kapitál
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Chybějící šablona e-mailu pro odeslání. Nastavte jednu z možností Nastavení odesílání.
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Lze použít proměnné scorecard, stejně jako: {total_score} (celkové skóre z tohoto období), {period_number} (počet období do dnešního dne)"
apps/erpnext/erpnext/public/js/stock_analytics.js,Value Or Qty,Hodnota nebo množství
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js,Please register the SIREN number in the company information file,Zaregistrujte prosím číslo SIREN v informačním souboru společnosti
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Zaškrtnutím tohoto políčka povolíte plánovanou denní synchronizaci pomocí plánovače
DocType: Employee Tax Exemption Declaration,Declarations,Prohlášení
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Suroviny založené na
DocType: Cheque Print Template,Distance from top edge,Vzdálenost od horního okraje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Popis práce
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher",Nelze filtrovat na základě poukázky č
DocType: Purchase Receipt Item,Received and Accepted,Přijaté a přijaté
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Negativní oceňovací kurz není povolen
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Uživatel, který bude použit k vytvoření Zákazníků, Položky a Objednávky odběratele. Tento uživatel by měl mít příslušná oprávnění."
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Vytvořit objednávku
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,Definujte rozpočet na rozpočtový rok.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Tabulka účtů nemůže být prázdná.
,Payment Period Based On Invoice Date,Doba splatnosti založená na datu faktury
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Datum instalace nemůže být před datem dodání položky {0}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Odkaz na žádost o materiál
DocType: Warranty Claim,From Company,Od společnosti
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Typ mapovaných dat
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Řádek {0}: Pro tento sklad již existuje položka Uspořádání {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Datum dokumentu
DocType: Monthly Distribution,Distribution Name,Název distribuce
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,"Skupina do skupiny, která není členem skupiny"
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Aktualizace probíhá. Může to chvíli trvat.
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Příklad: ABCD. ##### Pokud je nastavena řada a sériové číslo není uvedeno v transakcích, bude na základě této série vytvořeno automatické sériové číslo. Pokud chcete pro tuto položku vždy výslovně uvést sériová čísla. nechte toto prázdné."
DocType: Stock Entry,Stock Entry (Outward GIT),Položka skladu (GIT směrem ven)
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Zpracování adres adres
DocType: Selling Settings,Delivery Note Required,Požadavek na doručení
DocType: Pricing Rule,Sales Partner,Prodejní partner
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní položky zmrazené do tohoto data, nikdo nemůže provádět / upravovat položku s výjimkou role uvedené níže."
DocType: Vehicle Log,Fuel Qty,Množství paliva
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Mobile Ne
DocType: Invoice Discounting,Disbursed,Vyplaceno
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Čistá změna závazků
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Není dostupný
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Poloviční úvazek
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,dodávka
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kurz vytvoření nástroje studentské skupiny
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Přidělená částka nesmí být vyšší než neupravená částka
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor třetí strany / prodejce / zprostředkovatel / partner / prodejce, který prodává společnosti produkty za provizi."
DocType: BOM Item,Original Item,Původní položka
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Řada je povinná
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Potenciální možnosti prodeje.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show PDC in Print,Zobrazit PDC v tisku
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify Dodavatel
DocType: POS Profile User,POS Profile User,Uživatel profilu POS
DocType: Student,Middle Name,Prostřední jméno
DocType: Sales Person,Sales Person Name,Jméno prodejní osoby
DocType: Packing Slip,Gross Weight,Celková hmotnost
DocType: Journal Entry,Bill No,Bill č
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Nové umístění
,Project wise Stock Tracking,Project moudré sledování skladeb
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-
DocType: Student,A+,A +
DocType: Issue,Service Level Agreement,Smlouva o úrovni služeb
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.js,Please select Employee and Date first,Nejdříve vyberte zaměstnance a datum
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Míra ocenění položky se přepočítává s ohledem na částku kupónového nákladu
DocType: Timesheet,Employee Detail,Detail zaměstnance
DocType: Tally Migration,Vouchers,Poukazy
DocType: Student,Guardian Details,Podrobnosti opatrovníka
DocType: Shopify Settings,eg: frappe.myshopify.com,např .: frappe.myshopify.com
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","E-mailová adresa musí být jedinečná, již existuje pro {0}"
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Shoda plateb s fakturami
DocType: Holiday List,Weekly Off,Týdenní vypnuto
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nepovoluje nastavit alternativní položku pro položku {0}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Program {0} neexistuje.
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Kořenový uzel nelze upravit.
DocType: Fee Schedule,Student Category,Kategorie studentů
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ","Položka {0}: {1} vyrobeno,"
DocType: Identification Document Type,Identification Document Type,Typ identifikačního dokumentu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,Nedostatečné zásoby
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Řádek {0}: Konverzní faktor je povinný
DocType: Buying Settings,Purchase Receipt Required,Požadavek na nákup
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Cena kusovníku
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The check digit validation has failed. ,Neplatný GSTIN! Validace kontrolní číslice selhala.
DocType: HR Settings,Max working hours against Timesheet,Maximální pracovní doba proti rozvrhu
DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnout svátky do celkem č. pracovních dnů
DocType: Quality Meeting,Quality Meeting,Kvalitní setkání
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Poradenství
DocType: Payment Gateway Account,Default Payment Request Message,Výchozí zpráva o požadavku na platbu
DocType: GST Settings,GSTIN Email Sent On,GSTIN Email odeslán
DocType: Amazon MWS Settings,Enable Scheduled Synch,Povolit naplánovanou synchronizaci
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Vyberte prosím zaměstnance
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Pokud je zaškrtnuto, bude vytvořen zákazník, který bude mapován na pacienta. Proti tomuto zákazníkovi budou vytvořeny faktury pro pacienta. Můžete také vybrat existujícího zákazníka při vytváření pacienta."
DocType: Fiscal Year,Stock User,Uživatel
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Smlouva o úrovni služeb.
DocType: Additional Salary,Date on which this component is applied,Datum uplatnění této složky
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,Seznam dostupných akcionářů s čísly folio
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Nastavení účtů brány.
DocType: Service Level,Response Time Period,Doba odezvy
DocType: Purchase Invoice,Purchase Taxes and Charges,Nákupní daně a poplatky
DocType: Course Activity,Activity Date,Datum aktivity
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Vyberte nebo přidejte nového zákazníka
DocType: Contract,Unfulfilled,Nenaplněno
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Číst blog
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Hodnota projektu
DocType: Task,Expected Time (in hours),Očekávaný čas (v hodinách)
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Aktualizace variant ...
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person in Print,Zobrazit prodejní osobu v tisku
DocType: Supplier Scorecard,Per Year,Za rok
DocType: Inpatient Record,Admitted Datetime,Přiznaný Datetime
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Šablona daně je povinná.
DocType: Clinical Procedure,Patient,Trpěliví
DocType: Timesheet Detail,Costing Amount,Částka kalkulace
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Přidat / Upravit ceny
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Non-GST vnější dodávky
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Řádek {0}: Čas musí být menší než čas
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazen zaměstnanci {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Zobrazení formuláře
DocType: Supplier Quotation,Auto Repeat Section,Sekce automatického opakování
DocType: Sales Person,Select company name first.,Nejdříve vyberte název společnosti.
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Finanční rok
DocType: Sales Invoice Item,Deferred Revenue,Odložené příjmy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodejních nebo nákupních musí být vybrán
,Item-wise Purchase History,Historie nákupu
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Nelze změnit datum zastavení služby pro položku v řádku {0}
DocType: Production Plan,Include Subcontracted Items,Zahrnout subdodávky
DocType: Salary Structure,Max Benefits (Amount),Max. Přínosy (částka)
DocType: Homepage,Hero Section,Sekce hrdinů
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,"Tam, kde jsou prováděny výrobní operace."
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Oznámení o odeslání
DocType: Projects Settings,Timesheets,Časové rozvrhy
DocType: Purchase Receipt,Get current stock,Získejte aktuální sklad
DocType: Account,Expense,Náklady
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} aktivum nelze převést
,Unpaid Expense Claim,Nesplacený nárok na výdaje
DocType: Employee,Family Background,Rodinné zázemí
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Datum platby Bonusem nemůže být datum
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Pro transakce mezi společnostmi nebylo nalezeno žádné číslo {0}.
DocType: Bank Account,Party Type,Typ strany
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Dokončit
DocType: Sales Invoice,C-Form Applicable,C-forma Použitelné
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek účtu již v debetu, není dovoleno nastavit &#39;zůstatek musí být&#39; jako &#39;kredit&#39;"
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Řádek # {0}: Množství vzrostlo o 1
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Položka Skupina pro tuto prodejní osobu.
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Student,Student Mobile Number,Studentské mobilní číslo
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Akademický rok:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Podle nákupních nastavení, pokud požadovaná objednávka == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit objednávku pro položku {0}"
DocType: Shipping Rule Condition,To Value,Na hodnotu
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Přidejte účet do kořenové společnosti -
DocType: Asset Settings,Number of Days in Fiscal Year,Počet dnů ve fiskálním roce
DocType: Journal Entry,Total Amount Currency,Celková měna částky
DocType: BOM,Allow Same Item Multiple Times,Povolit vícenásobné opakování stejné položky
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Vytvořit kusovník
DocType: Healthcare Practitioner,Charges,Poplatky
DocType: Student,Personal Details,Osobní údaje
DocType: Sales Order,Billing and Delivery Status,Stav fakturace a dodání
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Row {0}: For supplier {0} Email Address is required to send email,Řádek {0}: Pro odeslání e-mailu je nutné zadat adresu {0}
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Peněžní toky z investic
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,"Schválení role nemůže být stejné jako role, kterou pravidlo platí"
DocType: Crop,Crop Spacing,Mezery oříznutí
DocType: Selling Settings,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í.
DocType: Pricing Rule,Period Settings,Nastavení období
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Čistá změna pohledávek
DocType: Quality Feedback Template,Quality Feedback Template,Šablona kvality zpětné vazby
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Pro Množství musí být větší než nula
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Existují nesrovnalosti mezi sazbou, počtem akcií a vypočtenou částkou"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechte prázdné, pokud zadáváte skupiny studentů za rok"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Úvěry (závazky)
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Odeslat e-mail pro kontrolu grantu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-forma
DocType: Production Plan Item,Produced Qty,Vyrobeno Množství
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Zápis v deníku
DocType: Stock Entry,Purchase Receipt No,Potvrzení o nákupu č
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be before employee's joining Date {1},Od data {0} nemůže být před připojením zaměstnance Datum {1}
DocType: Journal Entry,Debit Note,Oznámení o debetu
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je tato daň zahrnuta do základní sazby?
DocType: Share Balance,Purchased,Zakoupeno
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou je měna Ceníku převedena na základní měnu společnosti"
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Zobrazit záznamy o poplatcích
DocType: Training Event,Theory,Teorie
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Vytvořit nabídku
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Řádek # {0}: Záznam žurnálu {1} nemá účet {2} nebo již nebyl porovnán s jiným dokladem
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Vytvořit nového zákazníka
DocType: BOM Website Operation,BOM Website Operation,Provoz webových stránek BOM
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Detaily faktury / deníku
DocType: Share Balance,Share Balance,Bilance akcií
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Uzávěrka období
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Ceník nákupu
DocType: Contract,Party User,Uživatel strany
DocType: Restaurant Order Entry,Restaurant Order Entry,Vstup do restaurace
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serializovanou položku {0} nelze aktualizovat pomocí odsouhlasení zásob, použijte položku Vstup do skladu"
DocType: Practitioner Schedule,Time Slots,Časové úseky
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Vyberte alespoň jednu hodnotu z každého z atributů.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Šek
DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy prostřednictvím e-mailu.
DocType: Quality Procedure Table,Step,Krok
DocType: Normal Test Items,Result Value,Výsledná hodnota
DocType: Cash Flow Mapping,Is Income Tax Liability,Je daň z příjmů
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Poplatek za návštěvu v nemocnici
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} neexistuje.
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aktualizovat odpověď
DocType: Bank Guarantee,Supplier,Dodavatel
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Zadejte hodnotu betweeen {0} a {1}
DocType: Purchase Order,Order Confirmation Date,Datum potvrzení objednávky
DocType: Delivery Trip,Calculate Estimated Arrival Times,Vypočítat odhadované časy příjezdu
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavení systému pojmenování zaměstnanců v nastavení lidských zdrojů&gt; Nastavení HR
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Spotřební materiál
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Subscription,Subscription Start Date,Datum zahájení odběru
DocType: Woocommerce Settings,Woocommerce Server URL,Adresa URL serveru Woocommerce
DocType: Payroll Entry,Number Of Employees,Počet zaměstnanců
apps/erpnext/erpnext/regional/india/bank_remittance.py,{0} field is limited to size {1},Pole {0} je omezeno na velikost {1}
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Toto {0} je v konfliktu s {1} pro {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Hodnota Proposition
DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Nelze nastavit autorizaci na základě slevy pro {0}
DocType: Attendance Request,Work From Home,Práce z domova
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Řádek {0}: Čas a čas je povinný.
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Id dodavatele
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Fakturu nelze provést za nulovou fakturační hodinu
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dovolená nemůže být přidělena před {0}, protože zůstatek dovolené již byl převeden v budoucím záznamu o přidělení dovolené {1}"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Datum poslední objednávky
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Chod:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Odeslání
DocType: Installation Note Item,Installation Note Item,Instalace Poznámka Položka
DocType: Journal Entry Account,Journal Entry Account,Účet pro zápis do deníku
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Varianta
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Činnost fóra
DocType: Service Level,Resolution Time Period,Časové období rozlišení
DocType: Request for Quotation,Supplier Detail,Detail dodavatele
DocType: Project Task,View Task,Zobrazit úkol
DocType: Serial No,Purchase / Manufacture Details,Podrobnosti o nákupu / výrobě
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Záznam o odpisu aktiv majetku automaticky
DocType: Work Order Operation,Operation completed for how many finished goods?,Operace dokončena pro kolik hotových výrobků?
DocType: Healthcare Settings,Employee name and designation in print,Jméno a označení zaměstnance v tisku
DocType: Tally Migration,Is Day Book Data Processed,Zpracovává se data denní knihy
DocType: Program,Courses,Kurzy
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Pro nákupní fakturu {0} musí být povolen aktualizační fond
DocType: Employee Boarding Activity,Employee Boarding Activity,Činnost stravování zaměstnanců
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Sklad {0} nepatří společnosti {1}
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Pokud je zakázáno, pole „In Words“ nebude v žádné transakci viditelné"
DocType: Payment Entry Reference,Allocated,Přidělené
DocType: Project,Time to send,Čas na odeslání
DocType: Vital Signs,Bloated,Nafouklý
DocType: Blanket Order,Order Type,Typ objednávky
DocType: POS Closing Voucher,Period Start Date,Datum začátku období
DocType: Maintenance Schedule,Generate Schedule,Generovat plán
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Hodnota otevření
DocType: Additional Salary,Additional Salary,Další plat
DocType: Loan,Repayment Method,Způsob splácení
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Náklady na různé činnosti
DocType: Opportunity,Mins to First Response,Miny na první odezvu
DocType: Patient Appointment,Patient Age,Věk pacienta
DocType: Patient Encounter,Investigations,Vyšetřování
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Kancelářské vybavení
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","LocalStorage je plná, neuložila"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Položky pro žádost o suroviny
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Vybrat položku (volitelné)
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Nadřazená položka {0} nesmí být skladovou položkou
DocType: Stock Entry Detail,Against Stock Entry,Proti vstupu na burzu
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Načíst rozloženou rozpisku (včetně podsestav)
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loan,Loan Application,Žádost o půjčku
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Pro pracovní kartu
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Zpracovat kmenová data
DocType: Cheque Print Template,Is Account Payable,Je splatný účet
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Celková hodnota objednávky
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Dodavatel {0} nebyl nalezen v {1}
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Nastavení SMS brány
DocType: Salary Component,Round to the Nearest Integer,Zaokrouhlit na nejbližší celé číslo
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Kořen nemůže mít mateřské nákladové středisko
DocType: Healthcare Service Unit,Allow Appointments,Povolit události
DocType: BOM,Show Operations,Zobrazit operace
DocType: Practitioner Schedule,Practitioner Schedule,Plán praktikujících
DocType: Asset Maintenance Task,Calibration,Kalibrace
DocType: Pricing Rule,Apply On,Použít na
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Ukončete rozvahu a zaúčtujte zisk nebo ztrátu.
DocType: Employee,Provide Email Address registered in company,Poskytněte e-mailovou adresu registrovanou ve společnosti
DocType: Item Alternative,Alternative Item Name,Alternativní název položky
DocType: Assessment Plan,Course,Chod
DocType: Patient,Patient Details,Podrobnosti o pacientovi
DocType: Employee Separation,Employee Separation,Separace zaměstnanců
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Dlužníci
DocType: Bank Statement Settings,Mapped Items,Mapované položky
DocType: Leave Control Panel,Department (optional),Oddělení (volitelné)
DocType: Task Type,Task Type,Typ úlohy
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Debetní A / C číslo
DocType: Timesheet,Total Billed Amount,Celková fakturovaná částka
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Datum splatnosti / reference nemůže být po {0}
DocType: Leave Allocation,Add unused leaves from previous allocations,Přidat nepoužité listy z předchozích alokací
DocType: Employee Transfer,New Company,Nová společnost
DocType: Sales Invoice,Commission Rate (%),Sazba Komise (%)
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad lze změnit pouze prostřednictvím skladu / dodacího listu / nákupního dokladu
DocType: Support Settings,Close Issue After Days,Zavřete problém po dnech
DocType: Payment Schedule,Payment Schedule,Platební kalendář
DocType: Patient Relation,Spouse,Manželka
DocType: Purchase Invoice,Reason For Putting On Hold,Důvod pro pozastavení
DocType: Item Attribute,Increment,Přírůstek
DocType: Vital Signs,Cuts,Řezy
DocType: Student Applicant,LMS Only,Pouze LMS
DocType: Shopping Cart Settings,Show Contact Us Button,Zobrazit Kontaktujte nás Tlačítko
apps/erpnext/erpnext/public/js/event.js,Add Employees,Přidat zaměstnance
DocType: Holiday List,Holidays,Prázdniny
DocType: Chapter,Chapter Head,Kapitola Vedoucí
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Nepovoleno. Zakažte testovací šablonu
DocType: Restaurant Reservation,No Show,Žádné vystoupení
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Prodejní částka
DocType: Amazon MWS Settings,AWS Access Key ID,ID přístupového klíče AWS
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} není v mateřské společnosti přítomno
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To Date cannot be before From Date,To Date nemůže být před From Date
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Přidat dodavatele
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Přehled pro tento měsíc a probíhající aktivity
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Mode of Transport,Způsob dopravy
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Hrubá mzda - celkový odpočet - splácení úvěru
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Datum účtování nemůže být datem budoucím
,Work Order Stock Report,Zpráva o stavu zakázky
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Povolit / zakázat měny.
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Zobrazit v košíku
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Načíst na základě FIFO
DocType: Timesheet,Total Billable Amount,Celková zúčtovatelná částka
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Pro položku {1} proti zakázce odběratele {2} lze podat žádost o materiál v maximální hodnotě {0}
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,Výrobní položka
DocType: Share Transfer,Equity/Liability Account,Účet vlastního kapitálu
apps/erpnext/erpnext/www/all-products/index.html,No values,Žádné hodnoty
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Nejprve nejprve zrušte položku žurnálu {0}
DocType: GL Entry,Remarks,Poznámky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Řádek {0}: Záloha vůči dodavateli musí být debetní
DocType: Student Report Generation Tool,Attended by Parents,Návštěvníci rodičů
DocType: POS Profile,Update Stock,Aktualizovat zásoby
DocType: Account,Old Parent,Starý rodič
DocType: Production Plan,Download Materials Required,Download Požadované materiály
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Další uzávěrka období {0} byla provedena po {1}
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Šablona položky
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Sleva z ceníku (%)
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Zkratka je povinná
DocType: Travel Request,Domestic,Domácí
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,SO Množství
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop by Guardian
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Zůstatek v základní měně
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Všechny produkty nebo služby.
DocType: Vehicle Service,Brake Pad,Brzdový pedál
DocType: Pricing Rule,Max Amt,Max Amt
DocType: Shopping Cart Settings,Show Stock Availability,Zobrazit skladovou dostupnost
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Cenová nabídka hotelového pokoje
DocType: Project Task,Pending Review,Probíhá kontrola
DocType: Employee,Date of Joining,Datum připojení
DocType: Patient,Patient Relation,Vztah pacienta
DocType: Currency Exchange,For Selling,Pro prodej
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Peněžní toky z financování
DocType: Blanket Order,Manufacturing,Výrobní
apps/erpnext/erpnext/templates/pages/home.html,By {0},Od {0}
DocType: Restaurant Menu,Restaurant Manager,Manažer restaurace
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,Hodnota Out
DocType: Volunteer,Availability and Skills,Dostupnost a dovednosti
DocType: Employee Advance,Advance Account,Účet záloh
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Faktury bez místa dodání
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
DocType: Invoice Discounting,Loan End Date,Datum ukončení úvěru
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Množství v řádku {0} ({1}) musí být stejné jako množství vyrobené {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,Komerční
DocType: Salary Slip,Bank Account No.,Číslo bankovního účtu
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Výše záloh nesmí být vyšší než {0} {1}
DocType: Cheque Print Template,Width of amount in word,Šířka množství slovem
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Přiřadit strukturu platu
DocType: Stock Entry,Stock Entry Type,Typ položky skladu
DocType: Quality Action Table,Responsible,Odpovědný
DocType: Room,Room Number,Číslo pokoje
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Vyberte fiskální rok ...
,Trial Balance,Zkušební zůstatek
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Převod zaměstnanců nelze předložit před datem převodu
DocType: Grading Scale,Grading Scale Name,Název stupnice
DocType: Location,Area UOM,Oblast UOM
DocType: Timesheet,Total Costing Amount,Celková částka nákladů
DocType: Material Request Plan Item,Material Issue,Problém materiálu
DocType: BOM,Item Image (if not slideshow),Obrázek položky (pokud není prezentace)
DocType: Share Balance,Is Company,Je společnost
DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte nejnovější cenu ve všech kusovnících
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků budou rozděleny do více zpráv
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Platový lístek předložený za období od {0} do {1}
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Pro cenovou nabídku nejsou k dispozici data projektu
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Outstanding Amt,Celkem Nesplacený Amt
DocType: Purchase Invoice Item,Item Tax Rate,Položka Daňová sazba
DocType: Sales Order Item,Planned Quantity,Plánované množství
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Zadržení zásob
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"V aplikaci Words (Export) se zobrazí, jakmile uložíte dodací poznámku."
DocType: Selling Settings,Each Transaction,Každá transakce
DocType: Program Enrollment,Institute's Bus,Autobus Institutu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Nejdříve vyberte společnost
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Účast pro zaměstnance {0} je pro tento den již označena
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Otevírací
DocType: Crop Cycle,Detected Disease,Zjištěná nemoc
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) nemůže být větší než plánovaná quanitity ({2}) ve výrobní objednávce {3}
DocType: Stock Ledger Entry,Stock Queue (FIFO),Fronta akcií (FIFO)
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,Zadejte „Je subkontraktováno“ jako Ano nebo Ne
DocType: Company,Default Holiday List,Výchozí seznam dovolené
DocType: Naming Series,Current Value,Současná cena
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Sezónnost pro stanovení rozpočtů, cílů atd."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornění: Objednávka {0} již existuje proti objednávce zákazníka {1}
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,Měsíční prodejní cíl (
DocType: Guardian,Guardian Interests,Zájmy opatrovníka
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,ID dávky je povinné
DocType: Item,Allow over delivery or receipt upto this percent,Povolit přes doručení nebo přijetí až do tohoto procenta
DocType: Payment Entry,Paid Amount (Company Currency),Placená částka (měna společnosti)
DocType: Shipping Rule Condition,Shipping Rule Condition,Přepravní pravidlo Podmínka
DocType: Employee Boarding Activity,Required for Employee Creation,Požadováno pro vytváření zaměstnanců
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Vyplacení věrnostního bodu
DocType: Job Applicant,Cover Letter,Průvodní dopis
DocType: Chart of Accounts Importer,Chart Preview,Náhled náhledu
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parametr kontroly kvality zboží
DocType: Support Settings,Get Started Sections,Začínáme sekce
DocType: Delivery Note,% of materials delivered against this Delivery Note,% materiálu dodaného proti tomuto dodacímu listu
DocType: Warranty Claim,Warranty / AMC Status,Záruka / stav AMC
apps/erpnext/erpnext/utilities/user_progress.py,Gram,Gram
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Přidělené množství nemůže být záporné
DocType: POS Profile,Item Groups,Skupiny položek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,Zákaznické číslo LPO
,Company Name,Jméno společnosti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Na adresu 1
,Purchase Receipt Trends,Trendy nákupu
DocType: Leave Block List,Leave Block List Dates,Ponechte data seznamu bloků
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Student {0} existuje proti studentovi {1}
DocType: Education Settings,LMS Settings,Nastavení LMS
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,"Tituly pro tiskové šablony, např. Proforma Invoice."
DocType: Serial No,Delivery Time,Čas doručení
DocType: Loan,Repayment Period in Months,Doba splácení v měsících
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID transportéru
apps/erpnext/erpnext/config/buying.py,Price List master.,Ceník master.
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,První schvalovatel výdajů v seznamu bude nastaven jako výchozí schvalovatel výdajů.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Reklamní
DocType: Authorization Rule,Customer or Item,Zákazník nebo položka
DocType: Vehicle Log,Invoice Ref,Faktura Ref
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},Formulář C neplatí pro fakturu: {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Faktura byla vytvořena
DocType: Patient Encounter,Review Details,Podrobnosti o kontrole
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Řádek {0}: Hodnota hodin musí být větší než nula.
DocType: Account,Account Number,Číslo účtu
DocType: Assessment Result Detail,Assessment Result Detail,Detail výsledku vyhodnocení
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Chcete-li povolit přefakturaci nebo nadměrné objednávání, aktualizujte položku „Přídavek“ v Nastavení skladu nebo v položce."
DocType: Support Settings,Auto close Issue after 7 days,Automatické zavření Problém po 7 dnech
DocType: Supplier,Is Frozen,Je zmrazen
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Celkové přiřazené vážení by mělo být 100%. Je to {0}
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Platí, pokud je společnost SpA, SApA nebo SRL"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Překrývající se podmínky nalezené mezi:
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Placené a nedoručené
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinný, protože položka není automaticky číslována"
DocType: GST HSN Code,HSN Code,Kód HSN
DocType: GSTR 3B Report,September,září
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Správní náklady
DocType: C-Form,C-Form No,C-formulář č
DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení běžného období faktury
DocType: Item,Manufacturers,Výrobci
DocType: Crop Cycle,Crop Cycle,Cyklus oříznutí
DocType: Serial No,Creation Time,Doba vytvoření
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Zadejte prosím Schvalovací roli nebo Schvalovací uživatele
DocType: Inpatient Record,Discharged,Vybité
DocType: BOM,Raw Material Cost(Company Currency),Náklady na suroviny (měna společnosti)
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Datum splatnosti / referenční datum překročí povolené dny kreditu zákazníka {0} den (dny)
DocType: Email Digest,New Sales Orders,Nové zakázky odběratele
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,na základě
DocType: Employee,Owned,Vlastněno
DocType: Item Default,Item Default,Položka Výchozí
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Strana může být pouze jedna
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Náklady na zábavu
DocType: Item,Inspection Required before Delivery,Kontrola před dodáním
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Otevírání vstupního deníku
DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo odečíst
DocType: POS Closing Voucher Details,Collected Amount,Shromážděná částka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komise pro prodej
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Zde začněte zadávat údaje:
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Zbytek světa
apps/erpnext/erpnext/templates/pages/home.html,Publications,Publikace
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Výchozí bankovní / hotovostní účet bude automaticky aktualizován v položce Deník platů, když je tento režim vybrán."
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Celkový rozpočet
DocType: Upload Attendance,Upload HTML,Nahrát HTML
DocType: Bank Reconciliation Detail,Payment Document,Platební doklad
DocType: Opportunity Item,Opportunity Item,Položka Příležitosti
DocType: Travel Itinerary,Travel From,Cestovat z
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,Účet CWIP
DocType: SMS Log,Sender Name,Jméno odesílatele
DocType: Pricing Rule,Supplier Group,Dodavatelská skupina
DocType: Employee,Date of Issue,Datum vydání
,Requested Items To Be Transferred,"Požadované položky, které mají být převedeny"
DocType: Employee,Contract End Date,Datum ukončení smlouvy
DocType: Purchase Order Item,Returned Qty,Vrácené množství
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Delivery Note,Required only for sample item.,Vyžadováno pouze pro ukázkovou položku.
DocType: Healthcare Service Unit,Vacant,Volný
DocType: Opportunity,Sales Stage,Prodejní fáze
DocType: Sales Order,In Words will be visible once you save the Sales Order.,V aplikaci Words se zobrazí po uložení objednávky odběratele.
DocType: Item Reorder,Re-order Level,Re-order Level
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Přednost
,Department Analytics,Oddělení Analytics
DocType: Crop,Scientific Name,Odborný název
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Částka slevy nesmí být vyšší než 100%
DocType: Student Guardian,Relation,Vztah
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Jméno nebo e-mail je povinný
DocType: Tax Rule,Billing Zipcode,Fakturační PSČ
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Tržiště
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} status je {2}
DocType: Quiz Activity,Quiz Activity,Kvízová aktivita
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} není v platném období mezd
DocType: Timesheet,Billed,Fakturováno
DocType: Restaurant Order Entry,Last Sales Invoice,Poslední prodejní faktura
DocType: Payment Terms Template,Payment Terms,Platební podmínky
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Rezervováno Množství: Množství objednané k prodeji, ale nedodáno."
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je povinné. Možná není vytvořen záznam měny pro {1} až {2}
DocType: Task,Actual End Date (via Time Sheet),Aktuální datum ukončení (přes časový výkaz)
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Skóre musí být menší nebo rovné 5
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Vyberte položku BOM v poli kusovníku pro položku {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Sériové číslo {0} je v záruce až {1}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Rozdělit
DocType: Bank Account,Bank Account No,Bankovní účet č
DocType: Payroll Entry,Salary Slip Based on Timesheet,Platový skluz na základě časového rozvrhu
DocType: Program Enrollment,Mode of Transportation,Způsob dopravy
DocType: Budget,Control Action,Kontrolní akce
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Celková částka osvobození
DocType: Medical Code,Medical Code Standard,Standard lékařského předpisu
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Řádek # {0}: Reqd podle data nemůže být před datem transakce
DocType: Education Settings,Current Academic Term,Aktuální akademické období
DocType: Employee,Short biography for website and other publications.,Krátká biografie pro internetové stránky a jiné publikace.
DocType: Purchase Invoice Item,Received Qty,Přijaté množství
DocType: Purchase Invoice Item,Rate (Company Currency),Sazba (měna společnosti)
DocType: Item Reorder,Request for,Žádost o
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Instalace předvoleb
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Zadejte Doby splácení
DocType: Pricing Rule,Advanced Settings,Pokročilé nastavení
DocType: Payment Entry,Paid Amount,Uhrazená suma
DocType: Setup Progress Action,Setup Progress Action,Nastavení Postup Akce
DocType: Subscription Plan,Billing Interval Count,Počet intervalů účtování
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Účetní závěrka
DocType: Project,Message will sent to users to get their status on the project,"Zpráva bude zaslána uživatelům, aby získali status v projektu"
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Podrobnosti o předložení daňového osvobození zaměstnance
DocType: Purchase Order,Delivered,Dodáno
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Doručeno
DocType: Lead,Request for Information,Požadavek na informaci
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Konec roku
DocType: Vehicle,Diesel,Nafta
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankovaná částka nesmí být vyšší než částka nárokovaná v řádku {0}.
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},Od {0} | {1} {2}
apps/erpnext/erpnext/education/api.py,Result already Submitted,Výsledek již byl odeslán
DocType: Pricing Rule Detail,Rule Applied,Platí pravidlo
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Aktuální množství je povinné
DocType: Purchase Order Item,Expected Delivery Date,očekávané datum doručení
DocType: Issue,Resolution Date,Datum rozlišení
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Dovolená typu {0} nemůže být delší než {1}
DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit nákupní košík
DocType: Pricing Rule,Apply Rule On Other,Použít pravidlo On Other
DocType: Vehicle,Last Carbon Check,Poslední kontrola uhlíku
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make,Udělat
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Prodejní faktura {0} byla vytvořena jako placená
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Pro vytvoření žádosti o platbu je vyžadován referenční dokument
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Daň z příjmu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Počítač
DocType: Material Request,% Ordered,Objednáno
apps/erpnext/erpnext/controllers/buying_controller.py,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Následující položky {0} nejsou označeny jako {1} položka. Můžete je povolit jako položku {1} ze svého hlavního prvku položky
DocType: Quiz,Passing Score,Předávání skóre
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavení domovské stránky webu
DocType: Work Order,Qty To Manufacture,Množství k výrobě
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Neziskové (beta)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Vynikající Amt
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN kód
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Povolit následujícím uživatelům schvalovat aplikace ponechat pro dny bloků.
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Vyberte Stav údržby jako Dokončeno nebo Odstraňte Datum dokončení
DocType: Production Plan,Get Items For Work Order,Získat položky pro pracovní příkaz
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Nastavit Project a všechny úkoly na stav {0}?
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Zobrazit &quot;Skladem&quot; nebo &quot;Není skladem&quot; na základě skladových zásob v tomto skladu.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Smazat trvale?
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
DocType: Leave Type,Is Leave Without Pay,Je ponechána bez placení
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,Řádek # {0}: Musí být odeslána položka {1}
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Částka dodatečné slevy (měna společnosti)
DocType: Patient,Tobacco Past Use,Tabákové minulé použití
DocType: Crop,Materials Required,Požadované materiály
DocType: POS Profile,POS Profile,Profil POS
DocType: Journal Entry,Write Off Entry,Zápis vypnuto
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Chcete-li se zaregistrovat na Marketplace, musíte být jiným uživatelem než administrátorem s rolemi System Manager a Item Manager."
DocType: Asset,Insured value,Pojistná hodnota
DocType: Quotation Item,Against Docname,Proti Docname
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox","Vzhledem k tomu, že předpokládané množství surovin je vyšší než požadované množství, není třeba vytvářet požadavky na materiál. Pokud chcete provést požadavek na materiál, zaškrtněte políčko <b>Ignorovat existující projektované množství</b>"
DocType: Packed Item,Prevdoc DocType,Prevdoc DocType
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,{0} payment entries can not be filtered by {1},{0} položky plateb nelze filtrovat pomocí {1}
DocType: Variant Field,Variant Field,Variantní pole
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,Access token or Shopify URL missing,Chybí přístupový token nebo adresa URL Shopify
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Bankovní účet nelze pojmenovat jako {0}
DocType: Terms and Conditions,Terms and Conditions Help,Nápověda a podmínky
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Od a Do požadovaných dat
DocType: Production Plan Item,Product Bundle Item,Produkt Balíček zboží
DocType: Student Group,Group Based On,Na základě skupiny
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Mobile Ne
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Povolit vícenásobnou spotřebu materiálu
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kritéria přijatelnosti
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravidlo přepravy platí pouze pro prodej
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Rate,Prodejní sazba
DocType: Account,Asset,Aktivum
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nemá plán zdravotnické praxe. Přidejte ji do programu Master of Healthcare Practitioner
DocType: Vehicle,Chassis No,Podvozek č
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Zkratka společnosti
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Strom kusovníku
DocType: Article,LMS User,Uživatel LMS
DocType: BOM,Allow Alternative Item,Povolit alternativní položku
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivita Náklady na zaměstnance
DocType: Email Digest,Open Quotations,Otevřené nabídky
DocType: Cash Flow Mapper,Section Footer,Zápatí oddílu
DocType: Lead,Next Contact By,Další Kontakt By
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Čekající množství
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,"Vyberte, chcete-li přidat sériové číslo."
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,upraveny
DocType: Pricing Rule,Qty,Množství
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC Available (A) - (B)
,Material Requests for which Supplier Quotations are not created,"Požadavky na materiál, pro které nejsou vytvořeny nabídky dodavatele"
DocType: GST Account,GST Account,Účet GST
DocType: Pricing Rule,For Price List,Pro ceník
DocType: GoCardless Mandate,GoCardless Mandate,Mandát GoCardless
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Přeskočit přenos materiálu do skladu WIP
DocType: Cheque Print Template,Primary Settings,Primární nastavení
DocType: Amazon MWS Settings,Customer Type,Typ zákazníka
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: POS Settings,Use POS in Offline Mode,Použijte POS v režimu offline
DocType: Territory,Parent Territory,Rodičovské území
DocType: Vehicle Log,Odometer Reading,Stav tachometru
DocType: Additional Salary,Salary Slip,Výplatní páska
DocType: Payroll Entry,Payroll Frequency,Frekvence mezd
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Datum zahájení a ukončení není v platném období mezd, nelze {0} vypočítat"
DocType: Products Settings,Home Page is Products,Domovská stránka je Produkty
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Volání
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Odkaz # {0} datováno {1}
DocType: Guardian Interest,Guardian Interest,Zájem opatrovníků
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO již vytvořená pro všechny položky zakázky odběratele
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Předplatné
DocType: Stock Entry Detail,Stock Entry Detail,Detail položky skladu
DocType: Email Digest,Sales Orders to Bill,Objednávky odběratelů společnosti Bill
DocType: Company,For reference only.,Pouze pro informaci.
DocType: GL Entry,GL Entry,Vstup GL
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorie osvobození zaměstnanců
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Řádek {0}: položka je vyžadována pro položku {1}
DocType: Expense Claim Detail,Sanctioned Amount,Sankovaná částka
DocType: Taxable Salary Slab,Taxable Salary Slab,Zdanitelná platová deska
DocType: Grant Application,Grant Application,Žádost o grant
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nelze najít skóre začínající na {0}. Musíte mít stálé skóre 0 až 100
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Sales Person,Parent Sales Person,Rodičovská prodejní osoba
DocType: Student Group Creation Tool,Get Courses,Získejte kurzy
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Řádek # {0}: Množství musí být 1, protože položka je fixní aktivum. Použijte samostatný řádek pro více qty."
DocType: Customer Group,Only leaf nodes are allowed in transaction,V transakci jsou povoleny pouze uzly listů
DocType: Grant Application,Organization,Organizace
DocType: Fee Category,Fee Category,Kategorie poplatků
DocType: Batch,Batch ID,ID dávky
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,"Nemůže být položkou s pevným majetkem, protože je vytvořena kniha akcií."
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Souhrn tohoto měsíce
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} neodpovídá {3}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Přejděte na Dodavatele
DocType: Payment Order,PMO-,PMO-
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Aktualizujte svůj stav pro tuto školení
DocType: Volunteer,Morning,Ráno
DocType: Quotation Item,Quotation Item,Položka nabídky
DocType: Journal Entry,Credit Card Entry,Vstup kreditní karty
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Přeskočení časového slotu, slot {0} až {1} překrývá existující slot {2} až {3}"
DocType: Journal Entry Account,If Income or Expense,Pokud jsou příjmy nebo náklady
DocType: Work Order Operation,Work Order Operation,Provoz zakázky
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,Adresa používaná k určení kategorie daně v transakcích.
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,Přejděte na stránku Zákazníci
DocType: Student Group,Set 0 for no limit,Nastavte 0 pro žádný limit
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktivní
DocType: Repayment Schedule,Payment Date,Datum splatnosti
DocType: Asset Maintenance Task,Assign To Name,Přiřadit název
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Požadovaný počet materiálu je menší než minimální objednávka
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Aktuální kusovník a nový kusovník nemohou být stejné
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Plodiny a pozemky
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr nemůže být prázdný nebo mezera
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}","Nelze dodat sériové číslo {0} položky {1}, protože je vyhrazeno k vyplnění objednávky odběratele {2}"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Načítání záznamů ......
DocType: Delivery Stop,Contact Information,Kontaktní informace
DocType: Sales Order Item,For Production,Pro výrobu
DocType: Serial No,Asset Details,Podrobnosti o aktivech
DocType: Restaurant Reservation,Reservation Time,Rezervační čas
DocType: Selling Settings,Default Territory,Výchozí území
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Dispensed Amount (Pro-Rated)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Maximální povolená sleva pro položku: {0} je {1}%
DocType: Product Bundle,List items that form the package.,"Seznam položek, které tvoří balíček."
DocType: Payment Request,Amount in customer's currency,Částka v měně zákazníka
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Získejte položky z nákupních příjmů
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Řádek # {0} (Platební tabulka): Částka musí být kladná
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Prohlášení o osvobození zaměstnanců
DocType: Project,Expected End Date,Očekávané datum ukončení
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,jméno instituce
DocType: Serial No,Asset Status,Stav aktiv
DocType: Salary Slip,Earnings,Zisk
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Celková zaplacená částka
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Do skladu
DocType: Appraisal,Total Score (Out of 5),Celkové skóre (mimo 5)
DocType: Journal Entry,Accounts Receivable,Pohledávky
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Nastavení výchozích hodnot
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.","Nelze zajistit doručení pomocí sériového čísla, protože položka {0} je přidána s a bez zajištění \ t"
,Invoiced Amount (Exclusive Tax),Fakturovaná částka (exkluzivní daň)
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},"Stav nelze změnit, protože student {0} je propojen se studentskou aplikací {1}"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Celkový počet přidělených listů je povinný pro typ dovolené {0}
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Import a nastavení dat
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Pokud je zaškrtnuto políčko Automaticky zapnout, budou zákazníci automaticky spojeni s příslušným věrnostním programem (při uložení)"
DocType: Account,Expense Account,Účet výdajů
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Vztah s Guardian1
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Vytvořit fakturu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request already exists {0},Žádost o platbu již existuje {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',Zaměstnanec uvolněný na {0} musí být nastaven jako &quot;levý&quot;
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Platit {0} {1}
DocType: Sales Order Item,Produced Quantity,Vyrobené množství
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,K žádosti o cenovou nabídku se dostanete kliknutím na následující odkaz
DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční distribuce
DocType: Production Plan,Get Raw Materials For Production,Získejte suroviny pro výrobu
DocType: Employee,New Workplace,Nové pracoviště
DocType: Support Search Source,API,API
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Chybí hodnota pro heslo, klíč API nebo adresu URL Shopify"
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Název parametru
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},Účet {0} neodpovídá společnosti {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Vyberte položku v košíku
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Vytvořit položky platby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Vyberte společnost
DocType: Material Request Plan Item,Material Request Type,Typ požadavku na materiál
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,Členské ID
DocType: Issue,Raised By (Email),Zvýšený o (e-mail)
DocType: Employee Health Insurance,Employee Health Insurance,Zdravotní pojištění zaměstnanců
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Období podávání žádostí nemůže být mimo dobu přidělení dovolené
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Pokud není zaškrtnuto, položka se nezobrazí v prodejní faktuře, ale může být použita ve vytvoření skupinového testu."
DocType: Healthcare Settings,Registration Fee,Registrační poplatek
,Produced,Vyrobeno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Bílý
DocType: Clinical Procedure,Procedure Template,Postup šablony
DocType: Account,Frozen,Zamrzlý
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Cena nenalezena pro položku {0} v ceníku {1}
DocType: Student Admission,Publish on website,Publikovat na internetových stránkách
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Toto je příklad webové stránky auto-generované z ERPNext
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Odpojit platbu při zrušení faktury
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Žádné úkoly
DocType: Delivery Note,Print Without Amount,Tisk bez částky
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Objednávky zadané dodavatelům.
,Reserved,Rezervováno
DocType: Employee,Notice (days),Oznámení (dny)
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Nastavení e-mailového účtu
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
DocType: Contract,Unsigned,Nepodepsaný
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"Den (dny), kdy žádáte o dovolenou, jsou svátky. Nemusíte žádat o dovolenou."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Nelze odeslat nějaké výplatní pásky
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství pro položku {1}"
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Příjmy z prodeje nákladů na přistání
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Schvalovat
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Žádné další aktualizace
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Úspěšně přidělené listy pro {0}
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Zpráva o hodnocení
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Chcete-li pravidlo o cenotvorbě v konkrétní transakci neuplatnit, je třeba všechny platné pravidla pro ceny zakázat."
DocType: Company,Default Deferred Revenue Account,Výchozí účet odložených výnosů
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Informace dárce.
DocType: Authorization Rule,Customerwise Discount,Zákaznická sleva
DocType: Stock Ledger Entry,Outgoing Rate,Odchozí rychlost
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vyberte alespoň přidělené množství, typ faktury a číslo faktury v jednom řádku"
DocType: Asset Category,Asset Category Name,Název kategorie aktiv
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Doklad o přijetí musí být předložen
,Employee Advance Summary,Přehled zaměstnanců
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Detailní důvod
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Nízká citlivost
DocType: Authorization Rule,Applicable To (Designation),Použitelné pro (označení)
DocType: Tax Rule,Billing City,Fakturační město
DocType: Item,Is Customer Provided Item,Položka poskytovaná zákazníkem
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Šablona nákupních daní a poplatků
DocType: Sales Invoice Item,Brand Name,Jméno značky
DocType: Fee Schedule,Total Amount per Student,Celková částka na studenta
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Oblečení a doplňky
DocType: Compensatory Leave Request,Work From Date,Práce od data
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Pozvánka na projektovou spolupráci
DocType: Student Attendance Tool,Student Attendance Tool,Nástroj pro docházku studentů
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Předepsané postupy
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Nelze najít proměnnou:
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Amount,Částka PDC / LC
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Nastavte Podrobnosti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Celková výše záloh nesmí být vyšší než celková požadovaná částka
DocType: POS Item Group,Item Group,Skupina položek
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,V současné době nejsou v žádném skladu k dispozici žádné zásoby
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),Nahrajte svou hlavičku dopisu (udržujte ji v přátelském prostředí jako 900 × 100 × 100 pixelů)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavena pro sériová čísla. Sloupec musí být prázdný
DocType: Company,Default Values,Výchozí hodnoty
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Jsou vytvořeny výchozí šablony daně pro prodej a nákup.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Opustit typ {0} nelze přenášet
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Debetní účet musí být účet Pohledávky
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Nastavte účet ve skladu {0} nebo výchozí účet inventáře ve společnosti {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Nastavit jako výchozí
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balení. (vypočteno automaticky jako součet čisté hmotnosti položek)
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Nelze nastavit pole <b>{0}</b> pro kopírování ve variantách
DocType: Payment Term,Month(s) after the end of the invoice month,Měsíc (měsíce) po skončení fakturačního měsíce
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Získejte zaměstnance
DocType: Student,Leaving Certificate Number,Opuštění čísla certifikátu
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Nezanikla
DocType: Company,Unrealized Exchange Gain/Loss Account,Účet nerealizované burzy / ztráty
DocType: Employee,Relieving Date,Datum uvolnění
DocType: Plant Analysis,Plant Analysis Criterias,Kritéria analýzy rostlin
DocType: Leave Block List Date,Leave Block List Date,Ponechte datum seznamu bloků
DocType: Payment Entry,Receive,Dostávat
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum připojení
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Chyba: Není platné ID?
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Nahraďte konkrétní kusovník ve všech ostatních kusovnících, kde se používá. Nahradí starý odkaz kusovníku, aktualizuje náklady a znovu vygeneruje tabulku &quot;BOM Explosion Item&quot; jako nový kusovník. Aktualizuje také nejnovější cenu ve všech kusovnících."
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Společnost, platební účet, datum a datum jsou povinné"
DocType: Sales Invoice Payment,Base Amount (Company Currency),Základní částka (měna společnosti)
DocType: Sales Invoice Advance,Sales Invoice Advance,Záloha prodejní faktury
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Upozornit zákazníky prostřednictvím e-mailu
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Proveďte pracovní příkaz pro položky dílčí sestavy
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Manažer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Zaniklé dávky
DocType: Shipping Rule,Shipping Rule Type,Typ pravidla přepravy
DocType: Job Offer,Accepted,Přijato
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","Chcete-li tento dokument zrušit, vymažte prosím <a href=""#Form/Employee/{0}"">{0}</a> zaměstnance"
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Už jste posuzovali hodnotící kritéria {}.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Vyberte Čísla šarží
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Věk (dny)
DocType: Student Batch Name,Batch Name,Název dávky
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Velký
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Účetní záznam pro {0}: {1} lze provést pouze v měně: {2}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Důvod pro pozastavení:
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Selhalo vytvoření poplatku
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Úroveň pořadí
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} &#39;{1}&#39; je zakázáno
DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutečné množství po transakci
DocType: Subscription,Cancel At End Of Period,Zrušit na konci období
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Strom zdravotnických služeb
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Balíček položek v době prodeje.
DocType: Payment Reconciliation Payment,Allocated Amount,Přidělené množství
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Vyberte společnost a označení
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Je vyžadováno datum
DocType: Email Digest,Bank Credit Balance,Bankovní zůstatek
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Zobrazit kumulativní částku
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Nemáte dostatek věrnostních bodů k vykoupení
DocType: Purchase Invoice,Additional DIscount Percentage,Další procento DIscount
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Před odesláním zadejte název banky nebo instituce poskytující úvěr.
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nekontroluje overbilling, protože částka pro položku {0} v {1} je nulová"
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Vyberte domény
DocType: Agriculture Task,Task Name,Název úlohy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Skladové položky již vytvořené pro pracovní příkaz
,Amount to Deliver,Částka k dodání
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Společnost {0} neexistuje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,"Nebyly nalezeny žádné nevyřízené požadavky na materiál, které by odkazovaly na dané položky."
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Studenti jsou v centru systému, přidávají všechny své studenty"
DocType: Company,Company Logo,Logo společnosti
DocType: Content Question,Question Link,Otázka Link
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Nechte schvalovacího pracovníka povinného v žádosti o dovolenou
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Přidat poznámky
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,Počet nalezených položek: {0}.
DocType: Patient,Personal and Social History,Osobní a sociální dějiny
DocType: Maintenance Visit Purpose,Work Done,Práce hotova
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavení událostí na {0}, protože Zaměstnanec připojený k níže uvedeným Prodejcům nemá ID uživatele {1}"
DocType: Student Guardian,Father,Otec
,Purchase Order Items To Be Received,Položky objednávky budou přijaty
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetní a úvěrový pro {0} # {1} není roven. Rozdíl je {2}.
DocType: Marketplace Settings,Custom Data,Vlastní data
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,V aplikaci Words se zobrazí po uložení objednávky.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Skutečný typ daně nelze zahrnout do položky Položky v řádku {0}
DocType: Lab Test Template,Compound,Sloučenina
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou je měna zákazníka převedena na základní měnu společnosti"
DocType: Lead,Converted,Převedeno
DocType: Email Digest,New Income,Nové příjmy
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry already created or Sample Quantity not provided,Zadaná skladová položka již byla vytvořena nebo není k dispozici množství vzorku
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Zpracování poukázek
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,Zadejte kód položky pro získání čísla šarže
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Datum zastavení služby nemůže být před datem zahájení služby
DocType: Employee Property History,Employee Property History,Historie majetku zaměstnance
,Requested Items To Be Ordered,"Požadované položky, které mají být objednány"
DocType: Vital Signs,Blood Pressure (systolic),Krevní tlak (systolický)
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Leave Without Pay neodpovídá schváleným záznamům Leave Application
DocType: Purchase Invoice Item,Expense Head,Výdaje Head
DocType: Employee,Reason for Resignation,Důvod pro odstoupení
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Načíst aktualizace předplatného
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + Odepsaná částka nesmí být větší než Grand Total
DocType: Asset Repair,Error Description,Popis chyby
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Položka Poplatek za konzultace s pacientem
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Žádné odpovědi od uživatele
DocType: Shopify Settings,Sales Order Series,Série prodejních objednávek
DocType: Accounts Settings,Automatically Fetch Payment Terms,Automaticky načíst platební podmínky
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat na číslo řádku větší nebo rovno aktuálnímu číslu řádku pro tento typ poplatku
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,Anonymní
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Vyberte prosím společnost
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time",Synchronizace kmenových dat může nějakou dobu trvat
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
DocType: Item,Customer Items,Položky zákazníka
DocType: Program Enrollment,Enrolled courses,Zapsané kurzy
DocType: Lab Prescription,Test Code,Testovací kód
DocType: Purchase Taxes and Charges,On Previous Row Total,Na předchozí řádek celkem
DocType: Student,Student Email Address,E-mailová adresa studenta
DocType: Academic Term,Education,Vzdělání
DocType: Supplier Quotation,Supplier Address,Adresa dodavatele
DocType: Salary Detail,Do not include in total,Nezahrnujte celkem
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Nelze nastavit více výchozích hodnot položky pro společnost.
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} neexistuje
DocType: Purchase Receipt Item,Rejected Quantity,Odmítnuté množství
DocType: Cashier Closing,To TIme,Chcete-li
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverze UOM ({0} -&gt; {1}) nebyl nalezen pro položku: {2}
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Uživatel skupiny pro denní práci
DocType: Fiscal Year Company,Fiscal Year Company,Společnost fiskálního roku
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Alternativní položka nesmí být stejná jako kód položky
DocType: Payment Schedule,Payment Term,Platební lhůta
DocType: Quality Action,Quality Review,Kontrola kvality
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Na skladě Množství
DocType: Material Request Plan Item,Customer Provided,Poskytovaný zákazník
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Pro tento úkol existuje podřízený úkol. Tuto úlohu nelze odstranit.
DocType: Item,Inventory,Inventář
DocType: Supplier Scorecard Criteria,Criteria Name,Název kritéria
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Celkový počet přidělených listů
DocType: Chapter,Members,Členové
DocType: Fees,Student Details,Podrobnosti studenta
DocType: Account,Fixed Asset,Dlouhodobý majetek
DocType: Cheque Print Template,Has Print Format,Má formát tisku
DocType: Training Result Employee,Training Result Employee,Školení Výsledek Zaměstnanec
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Účet s podřízenými uzly nelze nastavit jako hlavní knihu
apps/erpnext/erpnext/config/buying.py,Purchase Order to Payment,Objednávka k platbě
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Počáteční den je větší než koncový den v úkolu &#39;{0}&#39;
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Čisté peněžní prostředky z financování
DocType: Quiz,Enter 0 to waive limit,Zadejte 0 pro omezení limitu
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Čas by měl být menší než čas
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Vydavatelé novin
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodavatel je povinen platit na účet {2}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Nevyrovnané šeky a vklady k vyrovnání
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,V předplatném můžete mít pouze plány se stejným fakturačním cyklem
DocType: Vehicle,Natural Gas,Zemní plyn
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Sériové číslo {0} nebylo nalezeno
DocType: Hub User,Hub Password,Heslo rozbočovače
,Bank Reconciliation Statement,Prohlášení o usmíření bank
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Čistá změna dlouhodobého majetku
DocType: Payment Request,Paid,Zaplaceno
DocType: Maintenance Visit,Completion Status,Stav dokončení
DocType: Job Card,Transferred Qty,Převedené množství
DocType: Healthcare Service Unit,Occupied,Obsazený
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Otevření {0} Faktura byla vytvořena
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Vytvoření webové stránky se nezdařilo
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Příležitosti podle zdroje olova
DocType: Grading Scale Interval,Grading Scale Interval,Interval stupnice
DocType: Education Settings,Instructor Records to be created by,"Instruktor Záznamy, které mají být vytvořeny"
DocType: Student Report Generation Tool,Student Report Generation Tool,Nástroj pro generování přehledů studentů
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Zobrazit Ledger
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jakékoli další poznámky, pozoruhodné úsilí, které by mělo jít do záznamů."
DocType: Travel Request,"Details of Sponsor (Name, Location)","Podrobnosti o sponzorovi (jméno, místo)"
DocType: Project Task,Weight,Hmotnost
DocType: Staffing Plan Detail,Current Count,Aktuální počet
DocType: Sales Team,Incentives,Pobídky
DocType: Program Fee,Program Fee,Poplatek za program
DocType: Delivery Settings,Delay between Delivery Stops,Prodleva mezi zastaveními doručení
DocType: Stock Settings,Freeze Stocks Older Than [Days],Zmrazení zásob starších než [dny]
DocType: Promotional Scheme,Promotional Scheme Product Discount,Sleva na propagační program
DocType: Account,Asset Received But Not Billed,"Aktiva přijata, ale neúčtována"
DocType: POS Closing Voucher,Total Collected Amount,Celková částka inkasa
DocType: Course,Default Grading Scale,Výchozí stupnice třídění
DocType: POS Profile,Allow user to edit Discount,Povolit uživateli upravit slevu
DocType: POS Closing Voucher,Linked Invoices,Propojené faktury
DocType: Volunteer,Weekends,Víkendy
DocType: Employee,Health Details,Podrobnosti o zdraví
DocType: Employee Education,Graduate,Absolvovat
DocType: Asset Maintenance Task,Asset Maintenance Task,Úkol údržby
DocType: Restaurant Order Entry,Restaurant Table,Restaurace tabulka
DocType: Amazon MWS Settings,CN,CN
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Zadání objednávky
DocType: Request for Quotation Supplier,Download PDF,Stáhnout PDF
DocType: Payment Entry,Unallocated Amount,Nepřidělená částka
DocType: Travel Itinerary,Rented Car,Pronajaté auto
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Pozastaveno
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Časový rozvrh prodejní faktury
DocType: Subscription,Plans,Plány
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Částka nákladového listu přistání
DocType: Student Log,Medical,Lékařský
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Účet {0} je zmrazen
DocType: Project,First Email,První e-mail
DocType: Supplier Scorecard,Criteria Setup,Nastavení kritérií
DocType: Crop,Yield UOM,Výnos UOM
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Laboratorní předpisy
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Náklady na služby
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Pro číslo {0} je vyžadováno referenční číslo a referenční datum
DocType: Salary Structure,Leave Encashment Amount Per Day,Nechte zaplacení částky za den
DocType: Student Admission Program,Naming Series (for Student Applicant),Řada pojmenování (pro studenta)
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Podle oddílu 17 odst. 5
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotek {1} potřebných v {2} na {3} {4} pro {5} k dokončení této transakce.
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Kreditní dny nemohou být záporným číslem
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Několikrát byl zadán stejný dodavatel
DocType: Customs Tariff Number,Tariff Number,Číslo celního sazebníku
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximální přípustná hodnota
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Přijaté položky skladu
DocType: Opportunity,Opportunity Amount,Částka příležitosti
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Částka objednávky
DocType: C-Form,III,III
DocType: Contract,Fulfilment Terms,Splnění podmínek
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,"Skupina, která není členem skupiny"
DocType: Student Guardian,Mother,Matka
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odpočet daně pro nevyžádané zaměstnanecké výhody
DocType: Travel Request,Travel Funding,Cestovní financování
DocType: Shipping Rule,Fixed,Pevný
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nemůže být větší než plánované množství ({2}) v pracovním řádu {3}
DocType: Quality Review,Additional Information,dodatečné informace
DocType: Course Scheduling Tool,Reschedule,Změna plánu
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Zvolte Stávající společnost pro vytváření účtové osnovy
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Aktivní zákazníci / zákazníci
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1 přesná shoda.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Sportovní
DocType: Employee Advance,Claimed Amount,Nárokovaná částka
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kritéria analýzy rostlin
DocType: Fee Schedule,Send Payment Request Email,Odeslat e-mail s žádostí o platbu
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,V aplikaci Words budou viditelné po uložení prodejní faktury.
DocType: Sales Invoice,Sales Team1,Prodejní tým1
DocType: Work Order,Required Items,Požadované položky
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Přečtěte si manuál ERPNext
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Zkontrolujte číslo faktury dodavatele Jedinečnost
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Hledat dílčí sestavy
DocType: Rename Tool,Type of document to rename.,"Typ dokumentu, který chcete přejmenovat."
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Vedení vám pomůže získat obchod, přidat všechny své kontakty a více jako vaše vede"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Nepřímé výdaje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Internetové publikování
DocType: Customer,Account Manager,Správce účtu
DocType: Amazon MWS Settings,BR,BR
DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js,No items found.,Žádné předměty nenalezeny.
DocType: Item Attribute,From Range,Z dosahu
DocType: Clinical Procedure,Consumables,Spotřební materiál
DocType: Purchase Taxes and Charges,Reference Row #,Řádek reference #
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Nastavte ve společnosti {0} „Centrum pro odpisy nákladů“
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the trasaction,Řádek # {0}: K dokončení transakce je vyžadován platební doklad
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Kliknutím na toto tlačítko vytáhnete data prodejní objednávky z Amazon MWS.
,Assessment Plan Status,Stav plánu hodnocení
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Nejprve vyberte {0}
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,Odeslat toto vytvořit záznam zaměstnance
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojeno k kódu položky varianty. Pokud je například zkratka &quot;SM&quot; a kód položky je &quot;T-SHIRT&quot;, kód položky varianty bude &quot;T-SHIRT-SM&quot;"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Zadejte datum dodání
DocType: Purchase Invoice Item,Quality Inspection,Inspekce kvality
DocType: Account,Root Type,Typ kořene
DocType: Journal Entry,Write Off Based On,Zapnuto zapnuto
DocType: Lab Test,Report Preference,Nastavení zprávy
DocType: Products Settings,Products Settings,Nastavení produktů
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synchronizace daní a poplatků
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Celkem nemůže být nula
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Otevření (Cr)
DocType: Employee,Company Email,Email společnosti
DocType: Shopping Cart Settings,Show Stock Quantity,Zobrazit skladové množství
DocType: Student,A-,A-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Účet {0} je přidán v podřízené společnosti {1}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum odchodu do důchodu musí být větší než Datum připojení
DocType: Restaurant Order Entry,Add Item,Přidat položku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Nemocná dovolená
DocType: Lab Test,Lab Test,Laboratorní test
DocType: Account,Accumulated Depreciation,Akumulované odpisy
DocType: Support Search Source,Source Type,Typ zdroje
DocType: Department Approver,Department Approver,Schvalovací pracovník oddělení
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Množství za řádek kusovníku
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Přijaté + zamítnuté Počet musí být roven přijatému množství pro položku {0}
apps/erpnext/erpnext/config/hr.py,Expense Claims,Reklamace výdajů
DocType: Bank Account,Address HTML,Adresa HTML
,Stock Projected Qty,Sklad
DocType: Employee Onboarding,Job Offer,Nabídka práce
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Žádné poznámky
DocType: Sales Invoice,Change Amount,Změnit částku
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Množství pro zápis
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Žádné položky k dispozici pro přenos
DocType: Work Order,Actual End Date,Aktuální datum ukončení
DocType: Loyalty Point Entry,Loyalty Point Entry,Vstup do věrnostního bodu
DocType: Travel Itinerary,Train,Vlak
DocType: BOM Explosion Item,BOM Explosion Item,Položka výbuchu kusovníku
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Inward Supplies (Invertní dodávky)
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} nebyl nalezen v tabulce Podrobnosti faktury
DocType: Stock Entry,Total Incoming Value,Celková příchozí hodnota
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Vybrat sklad ...
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Typ podnikání
apps/erpnext/erpnext/config/buying.py,All Addresses.,Všechny adresy.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolení „Použít pro nákupní košík“, protože nákupní košík je povolen a mělo by existovat alespoň jedno daňové pravidlo pro nákupní košík"
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Vyberte kurz
DocType: Taxable Salary Slab,Percent Deduction,Procentní odpočet
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Množství k produkci nemůže být menší než nula
DocType: Share Balance,To No,Na Ne
DocType: Leave Control Panel,Allocate Leaves,Přidělit listy
DocType: Assessment Result,Student Name,Jméno studenta
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Plán údržby.
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Následující požadavky na materiál byly automaticky zvýšeny na základě úrovně opakované objednávky položky
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Akce v případě kumulovaného měsíčního rozpočtu překročeného u PO
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Plný úvazek
DocType: Program Enrollment,Vehicle/Bus Number,Číslo vozidla / sběrnice
DocType: Tax Rule,Purchase Tax Template,Šablona nákupní daně
DocType: Production Plan,Material Request Planning,Plánování požadavků na materiál
DocType: UOM,Check this to disallow fractions. (for Nos),Zaškrtnutím tohoto políčka zakážete zlomky. (pro čísla)
DocType: Retention Bonus,Bonus Payment Date,Datum platby bonusu
DocType: BOM,Operating Cost,Provozní náklady
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Vyberte položky podle data doručení
DocType: Homepage,Tag Line,Tag Line
DocType: Customer,From Lead,Od vedení
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Uzavřený zisk / ztráta za účetní období
DocType: Agriculture Analysis Criteria,Agriculture,Zemědělství
DocType: Quality Procedure,Parent Procedure,Postup rodičů
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Nastavit Otevřít
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Přepnout filtry
DocType: Production Plan,Material Request Detail,Podrobnosti o požadavku na materiál
DocType: Material Request Item,Quantity and Warehouse,Množství a sklad
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,Přejděte na položku Programy
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Řádek # {0}: Duplicitní položka v Referencích {1} {2}
DocType: Loyalty Point Entry,Loyalty Program,Věrnostní program
DocType: Lost Reason Detail,Opportunity Lost Reason,Příležitost Lost Reason
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,"Platí, pokud je společnost s ručením omezeným"
DocType: Patient,"Allergies, Medical and Surgical History","Alergie, lékařská a chirurgická historie"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Kapitálové zásoby
DocType: Share Transfer,From Folio No,Z Folio Ne
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Zbývající platby
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Vyhledávací položka
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Celkový počet listů
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Rychlost aktualizace za poslední nákup
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Vyberte prosím tabulku
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,"{0} je blokováno, takže tato transakce nemůže pokračovat"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items From,Získat položky z
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Věrnostní body budou vypočteny z vynaložených (prostřednictvím Prodejní faktury) na základě zmíněného sběrného faktoru.
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Položka {0} musí být skladová položka
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Sloučit účet
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Převést na skupinu
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default",Výchozí nastavení v profilu profilu {0} pro uživatele {1} je již nastaveno jako výchozí
DocType: Fiscal Year,Companies,Společnosti
,Minutes to First Response for Opportunity,Zápis do první reakce na příležitost
DocType: Hotel Room Amenity,Hotel Room Amenity,Vybavení pokoje hotelu
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Faktury pro zákazníky.
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Pro toto označení nebyly nalezeny žádné personální plány
DocType: BOM Update Tool,Current BOM,Aktuální kusovník
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Příležitostné dovolené
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Aktualizováno náklady
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Jeden zákazník může být součástí jediného věrnostního programu.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Nelze zrušit transakci pro Dokončený pracovní příkaz.
DocType: Grant Application,Grant Application Details ,Podrobnosti o žádosti o grant
DocType: Purchase Invoice,Apply Additional Discount On,Použít další slevu
,Sales Partner Commission Summary,Souhrnná zpráva obchodního partnera
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},Typ objednávky musí být {0}
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Položka platby již existuje
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Nebyly vytvořeny žádné pracovní příkazy
DocType: Assessment Plan,Grading Scale,Hodnotící stupnice
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Marketingové náklady
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Další kontaktní datum nemůže být v minulosti
DocType: Shopify Settings,Webhooks Details,Podrobnosti Webhooks
DocType: Authorization Rule,Authorization Rule,Pravidlo autorizace
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Informace o typu dobrovolníka.
DocType: Naming Series,This is the number of the last created transaction with this prefix,Toto je číslo poslední vytvořené transakce s touto předponou
DocType: Supplier Scorecard,Indicator Color,Indikátor Barva
DocType: Item Variant Settings,Copy Fields to Variant,Kopírovat pole do varianty
DocType: Soil Texture,Sandy Loam,Sandy Loam
DocType: Question,Single Correct Answer,Single Correct Answer
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Od data nemůže být menší než datum nástupu zaměstnance
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povolit více objednávek odběratele proti objednávce zákazníka
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,PDC/LC,PDC / LC
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Pokud je tato volba zaškrtnuta, bude částka daně považována za již zahrnutou v částce Print Rate / Print Amount"
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se opakuje
DocType: Pricing Rule,Party Information,Informace o straně
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Dlužníci ({0})
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,"K dnešnímu dni nemůže být větší než datum, kdy se zaměstnanec uvolní"
DocType: Expense Claim,Employees Email Id,Id zaměstnance Zaměstnanci
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Aktualizace ceny z Shopify do ERPNext Ceník
DocType: Healthcare Settings,Default Medical Code Standard,Standardní standard zdravotnického kódu
DocType: Woocommerce Settings,Tax Account,Daňový účet
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Paid Amt,Celkový placený amt
DocType: BOM,Website Specifications,Specifikace webových stránek
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated","Od dodavatele ve schématu složení, s výjimkou a Nil"
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Chcete aktualizovat účast? <br> Současnost: {0} <br> Chybějící: {1}
DocType: Leave Control Panel,Employee (optional),Zaměstnanec (volitelné)
DocType: Purchase Invoice,Supplier Invoice Details,Podrobnosti o dodavatelské faktuře
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Zákazník {0} je vytvořen.
DocType: Company,Default Cost of Goods Sold Account,Standardní náklady prodaného účtu zboží
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Číslo {1} již bylo použito v účtu {2}
DocType: Mode of Payment Account,Default Account,Výchozí účet
DocType: Purchase Invoice,Disable Rounded Total,Zakázat zaokrouhlený součet
DocType: Contract,Signee,Signee
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Datum ukončení nemůže být před datem zahájení.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Sklady s existující transakcí nelze převést na skupinu.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Oba sklady musí patřit ke stejné společnosti
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti dokumentu Detail č
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Nastavte hodnotu {0}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Nejdříve vyberte prosím prefix
apps/erpnext/erpnext/config/buying.py,Managing Subcontracting,Správa subdodávek
DocType: Activity Cost,Projects User,Uživatel projektu
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Proměnná hodnotící karty dodavatelů
DocType: Item Group,Item Group Name,Název skupiny položek
DocType: Budget,Applicable on Material Request,Platí pro materiálové požadavky
DocType: Support Settings,Search APIs,Vyhledávací rozhraní API
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Procento nadprodukce Pro zakázku odběratele
apps/erpnext/erpnext/templates/generators/item/item_specifications.html,Specifications,Specifikace
DocType: Purchase Invoice,Supplied Items,Dodávané položky
DocType: Leave Control Panel,Select Employees,Vyberte zaměstnance
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Vyberte úrokový výnos v úvěru {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Všechny položky již byly převedeny na tento pracovní příkaz.
DocType: Certification Application,Payment Details,Platební údaje
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Tisk a značkování
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, který se zobrazí na vrcholu seznamu produktů."
,Sales Payment Summary,Přehled plateb za prodej
DocType: Salary Component,Is Flexible Benefit,Je flexibilní přínos
DocType: GST Account,IGST Account,Účet IGST
DocType: Shopping Cart Settings,Checkout Settings,Nastavení služby Checkout
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Nastavte prosím fiskální kód pro zákazníka &#39;% s&#39;
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Měsíční distribuce ** vám pomáhá distribuovat rozpočet / cíl v průběhu měsíců, pokud máte sezónnost ve svém podnikání."
DocType: Guardian,Students,Studenti
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Požadavek na náklady {0} již existuje pro záznam vozidla
DocType: Salary Component,"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 uvedená nebo vypočtená v této složce nebude přispívat k zisku nebo srážkám. Jeho hodnota však může být označena jinými komponenty, které mohou být přidány nebo odečteny."
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Zadejte částku splátek
DocType: Sales Invoice,Is Opening Entry,Otevírá se vstup
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Nastavit nové datum vydání
DocType: Account,Expenses Included In Valuation,Náklady zahrnuté do ocenění
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Sériová čísla
DocType: Salary Slip,Deductions,Srážky
,Supplier-Wise Sales Analytics,Analytika prodejních dodavatelů
DocType: GSTR 3B Report,February,Únor
DocType: Appraisal,For Employee,Pro zaměstnance
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Delivery Date,Aktuální datum dodání
DocType: Sales Partner,Sales Partner Name,Jméno obchodního partnera
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Řádek odpisu {0}: Datum odpisu odpisu se zadává jako datum
DocType: GST HSN Code,Regional,Regionální
DocType: Lead,Lead is an Organization,Vedení je Organizace
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Nejdříve vyberte Typ nabíjení
DocType: Purchase Receipt Item,Accepted Quantity,Přijaté množství
DocType: Amazon MWS Settings,DE,DE
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Výsledky vyhledávání
DocType: Item Default,Default Buying Cost Center,Výchozí nákupní středisko
DocType: Production Plan,Include Non Stock Items,"Zahrnout položky, které nejsou skladem"
DocType: Student,AB+,AB +
DocType: Upload Attendance,Upload Attendance,Nahrát účast
DocType: Drug Prescription,Drug Code,Drogový zákoník
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,Povolte prosím platné náklady na rezervaci
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Poplatek
DocType: Purchase Order,Supply Raw Materials,Dodávky surovin
,Item-wise Price List Rate,Sazba ceny podle položek
DocType: Purchase Invoice Item,BOM,BOM
DocType: Quality Inspection,Readings,Čtení
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Chyba při zpracování odloženého účetnictví pro {0}
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Nastavte prosím daňové identifikační číslo nebo fiskální kód společnosti „% s“
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Přidat sériové číslo
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Prům. Prodejní sazba
DocType: Payment Request,payment_url,payment_url
DocType: Delivery Note,Excise Page Number,Číslo stránky spotřební daně
,Sales Partner Target Variance based on Item Group,Cílová varianta prodejního partnera založená na skupině položek
DocType: Stock Settings,Naming Series Prefix,Pojmenování předpony Series
DocType: BOM Operation,Workstation,Pracovní stanice
DocType: Employee Boarding Activity,Task Weight,Úloha Hmotnost
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Roční fakturace: {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Fiskální rok {0} nelze odstranit. Fiskální rok {0} je nastaven jako výchozí v globálním nastavení
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Zatím žádné zákazníky!
DocType: Company,Enable Perpetual Inventory,Povolit trvalý inventář
DocType: Opportunity,Potential Sales Deal,Potenciální prodejní dohoda
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Faktura spotřební daně
DocType: Supplier Scorecard,Supplier Scorecard,Karta hodnocení dodavatelů
DocType: Travel Itinerary,Travel To,Cestovat do
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Označit Účast
DocType: POS Closing Voucher,Difference,Rozdíl
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Malý
DocType: Work Order Item,Work Order Item,Položka objednávky zakázky
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Prodej a výnosy
DocType: Budget,Monthly Distribution,Měsíční distribuce
DocType: Quality Action,Quality Action,Kvalitní akce
DocType: Work Order,Work-in-Progress Warehouse,Work-in-progress skladu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Vyplacené dividendy
DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
DocType: Sales Person,Name and Employee ID,Jméno a ID zaměstnance
DocType: Subscription,Generate Invoice At Beginning Of Period,Generování faktury na začátku období
DocType: Item,Minimum Order Qty,Minimální počet objednávek
DocType: Leave Block List,Block Holidays on important days.,Blokovat svátky na důležité dny.
apps/erpnext/erpnext/public/js/conf.js,Documentation,Dokumentace
DocType: Item Alternative,Alternative Item Code,Alternativní kód položky
DocType: Sales Partner,Partner website,Webové stránky partnerů
DocType: Loan,Applicant,Žadatel
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Jednotlivý pro výsledky, které vyžadují pouze jeden vstup, výsledek UOM a normální hodnotu <br> Směs pro výsledky, které vyžadují více vstupních polí s odpovídajícími názvy událostí, výsledkem UOM a normálními hodnotami <br> Popisný pro testy, které mají více výsledných komponent a odpovídající pole pro zadání výsledku. <br> Seskupeny pro testovací šablony, které jsou skupinou jiných testovacích šablon. <br> Ne Výsledek pro testy bez výsledků. Také není vytvořen žádný laboratorní test. např. Sub Tests pro seskupené výsledky."
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,Uveďte prosím společnost Round Off Cost Center ve společnosti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Poznámky k doručení {0} musí být zrušeny před zrušením této objednávky odběratele
DocType: Grant Application,Show on Website,Zobrazit na webových stránkách
DocType: Sales Invoice,Shipping Address Name,Název dodací adresy
apps/erpnext/erpnext/healthcare/setup.py,Drug,Lék
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} je zavřeno
DocType: Patient,Medical History,Zdravotní historie
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Počet dnů po uplynutí data faktury před zrušením předplatného nebo označení předplatného jako nezaplaceného
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána
DocType: Patient Relation,Family,Rodina
DocType: Work Order Operation,Updated via 'Time Log',Aktualizováno přes „Časový záznam“
DocType: Quality Inspection,Sample Size,Velikost vzorku
DocType: Journal Entry,Reference Number,Referenční číslo
DocType: UOM Conversion Detail,UOM Conversion Detail,Detail převodu UOM
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Zahájení odpisů musí být menší než {0}
DocType: Antibiotic,Antibiotic Name,Název antibiotika
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",V níže uvedené tabulce bude vybrán pouze Žadatel o studium se statusem &quot;Schváleno&quot;.
DocType: Task,% Progress,Pokrok
DocType: UOM Category,UOM Category,Kategorie UOM
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Publikování položek na webových stránkách
DocType: Chapter,Meetup Embed HTML,Meetup Vložit HTML
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Nejprve vyberte Typ strany
DocType: Loan,Repayment Start Date,Datum začátku splácení
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,"Není povoleno, protože {0} překračuje limity"
DocType: Procedure Prescription,Procedure Created,Postup byl vytvořen
,Serial No Warranty Expiry,Prodloužení platnosti sériové záruky
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Změna profilu POS
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Vytvořit olovo
DocType: Shopify Settings,Default Customer,Výchozí zákazník
DocType: Payment Entry Reference,Supplier Invoice No,Faktura dodavatele č
DocType: Pricing Rule,Mixed Conditions,Smíšené podmínky
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Toto je výchozí UOM použité pro položky a objednávky odběratele. Záložní UOM je &quot;Nos&quot;.
DocType: Payment Request,Mute Email,Vypnout e-mail
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Bod 2
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,"Sazby srážkové daně, které se použijí na transakce."
DocType: Dosage Strength,Strength,Síla
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotek {1} potřebných v {2} k dokončení této transakce.
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush Surové materiály Subcontract založené na
DocType: Bank Guarantee,Customer,Zákazník
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Pokud je tato možnost povolena, pole Akademický termín bude povinné v nástroji pro zápis do programu."
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Pro skupinu studentů založenou na dávkách bude studentská dávka validována pro každého studenta ze zápisu do programu.
DocType: Course,Topics,Témata
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Řádek # {0}: Nastavte počet objednávek
DocType: Crop Cycle,Linked Location,Připojené umístění
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Není povoleno pro {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} je plně účtováno
DocType: Payment Request,Inward,Vnitřní
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Viz všechny články
DocType: Bank Reconciliation Detail,Payment Entry,Zadání platby
DocType: Payment Request,Recipient Message And Payment Details,Zpráva příjemce a podrobnosti platby
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Detail platebních podmínek šablony
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Označte množství
DocType: Student Attendance,Student Attendance,Účast studentů
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automaticky nastavit sériová čísla na základě FIFO
,Available Qty,K dispozici Množ
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Získejte faktury na základě filtrů
DocType: Operation,Default Workstation,Výchozí pracovní stanice
DocType: Salary Slip,Salary Structure,Struktura platu
DocType: Products Settings,Enable Attribute Filters,Povolit filtry atributů
DocType: Member,Non Profit Member,Neziskový člen
DocType: Material Request Plan Item,Material Request Plan Item,Položka plánu požadavku materiálu
DocType: Holiday List,Add to Holidays,Přidat do svátků
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Překročen limit
DocType: Company,Transactions Annual History,Roční historie transakcí
DocType: Company,Delete Company Transactions,Smazat transakce společnosti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Do stavu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Obchodní domy
DocType: Healthcare Service Unit,Inpatient Occupancy,Obsazení nemocných
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Řádek {0}: Datum splatnosti nemůže být před datem účtování
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,V nastavení restaurace nastavte výchozího zákazníka
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Skupinová role č
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Zadejte platné ID řádku pro řádek {0} v tabulce {1}
DocType: Asset Movement,To Employee,Zaměstnanci
DocType: Item,End of Life,Konec života
DocType: Lab Test Template,Sensitivity,Citlivost
DocType: Territory,Territory Targets,Územní cíle
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Přeskočení Opustit přidělení pro následující zaměstnance, protože záznamy o přidělení dovolené již existují proti nim. {0}"
DocType: Quality Action Resolution,Quality Action Resolution,Řešení kvality
DocType: Sales Invoice Item,Delivered By Supplier,Dodáno dodavatelem
DocType: Agriculture Analysis Criteria,Plant Analysis,Analýza rostlin
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Účet výdajů je povinný pro položku {0}
,Subcontracted Raw Materials To Be Transferred,"Subdodavatelské suroviny, které mají být převedeny"
DocType: Cashier Closing,Cashier Closing,Uzavření pokladny
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Položka {0} již byla vrácena
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,Neplatný GSTIN! Zadaný vstup neodpovídá formátu GSTIN pro držitele UIN nebo poskytovatele služeb OIDAR
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Pro tento sklad existuje dětský sklad. Tento sklad nelze smazat.
DocType: Diagnosis,Diagnosis,Diagnóza
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Mezi {0} a {1} není žádná dovolená doba
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{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}. Překročí {5}
DocType: Purchase Invoice Item,Asset Location,Umístění majetku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Zadejte prosím rozdílný účet
DocType: Journal Entry,Total Credit,Celkový kredit
DocType: Certified Consultant,Name of Consultant,Jméno konzultanta
DocType: Driver,License Number,Číslo licence
DocType: Program Enrollment Tool,Program Enrollment Tool,Nástroj pro zápis programu
DocType: Amazon MWS Settings,US,NÁS
DocType: Sales Order,Track this Sales Order against any Project,Sledujte tuto zakázku odběratele proti jakémukoli projektu
DocType: QuickBooks Migrator,Authorization Settings,Nastavení autorizace
DocType: Homepage,Products,produkty
,Profit and Loss Statement,Výkaz zisků a ztrát
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Pokoje Rezervace
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Duplicitní položka proti kódu položky {0} a výrobci {1}
DocType: Item Barcode,EAN,EAN
DocType: Purchase Invoice Item,Total Weight,Celková váha
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Cestovat
,Stock Ledger,Skladová kniha
DocType: Volunteer,Volunteer Name,Jméno dobrovolníka
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,Neplatný GSTIN! První 2 číslice GSTIN by se měly shodovat se stavovým číslem {0}.
DocType: Quality Inspection,Report Date,Datum zprávy
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Vytvořit položku Interní deník společnosti
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Dostatek dílů k sestavení
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Náklady na emitované položky
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Mezní hodnota {0}% se zobrazí více než jednou
DocType: Chapter,Chapter Members,Členové kapitoly
DocType: Warranty Claim,Service Address,Adresa služby
DocType: Journal Entry,Remark,Poznámka
DocType: Patient Encounter,Encounter Time,Čas setkání
DocType: Serial No,Invoice Details,Detaily faktury
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být provedeny v rámci skupin, ale záznamy mohou být provedeny proti skupinám"
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,Skladové položky
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Řádek {0} # Přidělená částka {1} nemůže být vyšší než nevyžádaná částka {2}
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Reqd Qty
DocType: Vital Signs,Body Temperature,Tělesná teplota
DocType: Customer Group,Customer Group Name,Jméno skupiny zákazníků
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Celkové přidělené listy jsou více než dny v daném období
DocType: Homepage Section,Section Cards,Sekce Karty
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Pravidla pro přidávání přepravních nákladů.
DocType: Item Price,Valid From,Platnost od
DocType: Travel Itinerary,Preferred Area for Lodging,Preferovaná oblast pro ubytování
DocType: Student Attendance,Absent,Absentní
DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
DocType: Additional Salary,Overwrite Salary Structure Amount,Přepsat výši struktury mzdy
DocType: Supplier Quotation,Is Subcontracted,Subdodavatelská smlouva
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Částka úvěru nesmí překročit maximální výši úvěru {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM neobsahuje žádnou skladovou položku
DocType: Employee Skill Map,Employee Skill Map,Zaměstnanecká mapa dovedností
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Marketing
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Řádek # {0}: Není dovoleno měnit dodavatele, protože objednávka již existuje"
DocType: Item,Maximum sample quantity that can be retained,"Maximální množství vzorku, které lze zachovat"
DocType: Staffing Plan,Total Estimated Budget,Celkový odhadovaný rozpočet
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stálý název
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Ověřit zapsaný kurz pro studenty ve studentské skupině
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be after employee's relieving Date {1},Od data {0} nemůže být po uvolnění data zaměstnance {1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Celkové množství / množství převodu {0} v požadavku na materiál {1} nesmí být větší než požadované množství {2} pro položku {3}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Vyberte {0}
DocType: Selling Settings,Default Customer Group,Výchozí skupina zákazníků
DocType: Journal Entry Account,Debit in Company Currency,Debet v měně společnosti
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Záložní série je &quot;SO-WOO-&quot;.
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Agenda kvality jednání
DocType: Cash Flow Mapper,Section Header,Záhlaví oddílu
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Vaše produkty nebo služby
DocType: Crop,Perennial,Trvalka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Dopravné a spediční poplatky
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Poslední kupní cena
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Daňová aktiva
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Pokud je zvoleno pravidlo pro stanovení ceny pro „Rate“, přepíše Ceník. Cenová sazba je konečná sazba, takže žádná další sleva by neměla být použita. Proto v transakcích, jako je zakázka odběratele, objednávka atd., Bude tato transakce načtena do pole „sazba“ namísto pole „kurzovní lístek“."
DocType: Share Balance,Share Type,Typ sdílení
DocType: Agriculture Analysis Criteria,Soil Analysis,Analýza půdy
DocType: Water Analysis,Water Analysis Criteria,Kritéria pro analýzu vody
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Poznámka: Celkový počet přidělených listů {0} by neměl být menší než počet již schválených listů {1} pro dané období
DocType: Salary Component,Deduction,Dedukce
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,"Nelze restartovat předplatné, které není zrušeno."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Pokroky zaměstnanců
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Předběžný zisk / ztráta (kredit)
DocType: Employee Tax Exemption Category,Max Exemption Amount,Maximální částka osvobození
DocType: Timesheet,TS-.YYYY.-,TS-.YYYY.-
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Různé položky UOM pro položky povedou k nesprávné hodnotě (celkové) čisté hmotnosti. Ujistěte se, že čistá hmotnost každé položky je ve stejném UOM."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Dodavatelská nabídka
DocType: Item,Auto re-order,Automatické přeuspořádání
DocType: Expense Claim,Total Advance Amount,Celková výše záloh
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Řádek # {0}: Datum schválení {1} nemůže být před datem kontroly {2}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Platit lze pouze za nevyfakturované {0}
DocType: BOM,Thumbnail,Miniatura
DocType: Production Plan Item,Planned Qty,Plánované množství
DocType: Tax Withholding Category,Rates,Sazby
DocType: Asset,Journal Entry for Scrap,Záznam žurnálu pro šrot
DocType: GL Entry,Voucher Detail No,Detail poukázky č
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Varianta Zapnuto nelze změnit
DocType: Task,Review Date,Datum kontroly
DocType: Crop,Biennial,Bienále
DocType: Woocommerce Settings,Endpoints,Koncové body
DocType: Subscription Plan Detail,Plan,Plán
DocType: Employee Education,Year of Passing,Rok předání
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Daň celkem
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Zadejte výchozí měnu ve službě Master společnosti
DocType: Tally Migration,Processed Files,Zpracované soubory
DocType: Leave Type,Is Earned Leave,Je vydělán
DocType: Support Search Source,Search Term Param Name,Hledaný výraz Param Název
DocType: Sales Invoice,Time Sheets,Časové listy
DocType: Installation Note,Installation Time,Doba instalace
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Šablony proměnných typu scorecard dodavatele.
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která je kupována, prodávána nebo uchovávána na skladě."
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Uzavření (otevření + celkem)
DocType: Supplier Scorecard Criteria,Criteria Formula,Kritérium vzorec
apps/erpnext/erpnext/config/support.py,Support Analytics,Podpora Analytics
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Recenze a akce
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Pokud je účet zmrazen, jsou položky vyhrazeny omezeným uživatelům."
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Částka po odpisu
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Importovat kmenová data
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,Musí být aktivní kusovník {0}
,GST Sales Register,GST Prodejní registr
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Datum faktury dodavatele nemůže být větší než datum účtování
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Správa objednávek
DocType: Supplier Scorecard,Notify Supplier,Informujte dodavatele
,GSTR-2,GSTR-2
DocType: Sales Invoice,Credit Note Issued,Vydaná dobropis
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,To se týká všech scorecards vázaných na tuto Setup
DocType: Payment Order,Payment Order Type,Typ platebního příkazu
DocType: Account,Parent Account,Rodičovský účet
DocType: Maintenance Visit,Unscheduled,Neplánovaný
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Problémový materiál
DocType: Work Order,Use Multi-Level BOM,Použijte víceúrovňovou rozpisku
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Počet pro {0}
DocType: Salary Slip,Loan Repayment,Splácení úvěru
DocType: Employee Education,Major/Optional Subjects,Hlavní / volitelné předměty
DocType: Soil Texture,Silt,Silt
DocType: Bank Guarantee,Bank Guarantee Type,Typ bankovní záruky
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Pokud je zakázáno, pole Zaoblený součet nebude v žádné transakci viditelné"
DocType: Pricing Rule,Min Amt,Min Amt
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,Jedná se o kořenovou službu zdravotní péče a nelze ji upravovat.
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,"Nastavte toto, pokud je zákazník společností veřejné správy."
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,"Max dávky by měly být větší než nula, aby byly dávky vypláceny"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Job Card # {4},Řádek # {0}: Operace {1} není dokončena pro {2} počet hotových výrobků v pracovním řádu # {3}. Aktualizujte stav operace pomocí karty Job Card # {4}
DocType: Production Plan Item,Planned Start Date,Datum zahájení plánu
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Údržba aktiv
DocType: Lead,Interested,Zájem
DocType: Purchase Invoice,Net Total (Company Currency),Čistý součet (měna společnosti)
DocType: Salary Component,Depends on Payment Days,Závisí na Platebních dnech
DocType: Subscription,Taxes,Daně
DocType: Bank Account,Bank Account,Bankovní účet
DocType: Homepage Section,Section HTML,Oddíl HTML
DocType: Sales Invoice,Packed Items,Balené položky
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Vytvoří se nová pravidla pro oceňování {0}
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Dosažené ({})
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investiční bankovnictví
DocType: Contract Template,Contract Terms and Conditions,Smluvní podmínky
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Načíst data
DocType: Stock Settings,Default Item Group,Výchozí skupina položek
DocType: Sales Invoice Timesheet,Billing Hours,Fakturační hodiny
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Proti studentovi {0} již existuje aplikace {0}
DocType: Pricing Rule,Margin Type,Typ okraje
DocType: Purchase Invoice Item,Rejected Serial No,Odmítnuto sériové číslo
DocType: Stock Reconciliation Item,Current Amount,Aktuální množství
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Nastavení výchozích hodnot pro faktury POS
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Náklady na
apps/erpnext/erpnext/config/projects.py,Project Update.,Aktualizace projektu.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Typ kořenového adresáře je povinný
apps/erpnext/erpnext/setup/utils.py,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nelze najít směnný kurz pro {0} až {1} pro klíčové datum {2}. Vytvořte záznam měny ručně
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% Fakturováno
DocType: Purchase Invoice,Overdue,Zpožděný
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daného množství surovin
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otevření položky Vytvoření faktury
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Bank Reconciliation,Include POS Transactions,Zahrnout transakce POS
DocType: Payment Entry,Received Amount (Company Currency),Přijatá částka (měna společnosti)
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","LocalStorage je plná, neuložila"
DocType: Chapter Member,Chapter Member,Člen kapitoly
DocType: Certified Consultant,Certification Validity,Platnost certifikace
DocType: Share Transfer,Asset Account,Účet aktiv
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,Suplier
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Podrobnosti o uzávěrce POS
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Delivery Settings,Delivery Settings,Nastavení doručení
DocType: Email Digest,Receivables,Pohledávky
DocType: Crop,Annual,Roční
DocType: Item Tax Template Detail,Tax Rate,Sazba daně
DocType: Patient Encounter,Medical Coding,Lékařské kódování
DocType: Purchase Invoice,Total Quantity,Celkové množství
DocType: Asset,Comprehensive Insurance,Komplexní pojištění
DocType: Purchase Invoice Item,Quantity and Rate,Množství a rychlost
DocType: Employee Benefit Claim,Max Amount Eligible,Max
DocType: Salary Slip,Employee Loan,Půjčka zaměstnanců
DocType: Payment Entry,Account Paid To,Zaplaceno na účet
DocType: Lab Test Template,Single,Singl
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',Zákazník požadován pro „Zákaznickou slevu“
DocType: Purchase Invoice,Advance Payments,Zálohové platby
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.","Nelze zajistit doručení pomocí sériového čísla, protože položka {0} je přidána s a bez zajištění \ t"
DocType: Inpatient Record,Discharge Date,Datum propuštění
,Open Work Orders,Otevřete pracovní příkazy
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Seznam nemocí zjištěných na poli. Pokud je vybrána, automaticky se přidá seznam úkolů, které se mají s touto nemocí vypořádat"
DocType: SMS Center,All Lead (Open),Všechna vedení (otevřená)
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Nebyly vytvořeny žádné studentské skupiny.
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Duplikovat řádek {0} se stejným {1}
DocType: Employee,Salary Details,Podrobnosti o platu
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Special Test Items,Particulars,Údaje
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,Nastavte filtr na základě položky nebo skladu
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Nesplacená částka
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Transakce smí smazat pouze autor společnosti
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","U položek „Produktový balíček“ bude sklad, sériové číslo a číslo šarže zohledněn v tabulce „Seznam balení“. Pokud jsou sklad a šarže č. Stejné pro všechny položky balení pro položku „Produktový balíček“, mohou být tyto hodnoty zadány do hlavní tabulky položek, hodnoty budou zkopírovány do tabulky „Seznam balení“."
DocType: Lab Test,Submitted Date,Datum odeslání
DocType: Delivery Settings,Send with Attachment,Odeslat s přílohou
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Účet {0} neexistuje
DocType: BOM Item,BOM No,Číslo kusovníku č
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Avg Daily Outgoing
DocType: Patient,Allergies,Alergie
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Objednávka / nabídka%
DocType: Delivery Note,Transporter Info,Informace o dopravci
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',Vyberte jinou skupinu hodnocení než „Všechny hodnotící skupiny“
DocType: Leave Encashment,Payroll,Mzdy
DocType: POS Closing Voucher,Expense Amount,Částka výdajů
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Přijato Zapnuto
DocType: Travel Itinerary,Flight,Let
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Daň a poplatky za přistání
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Více než jeden výběr pro {0} není povolen
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Čistá změna vlastního kapitálu
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Listy byly uděleny úspěšně
DocType: Loyalty Point Entry,Expiry Date,Datum vypršení platnosti
DocType: Project Task,Working,Pracovní
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} již má rodičovský postup {1}.
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,To je založeno na transakcích s tímto pacientem. Podrobnosti naleznete v níže uvedené časové ose
DocType: Material Request,Requested For,Požadováno pro
DocType: SMS Center,All Sales Person,Veškerá prodejní osoba
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Nastavit výchozí účet ve složce Plat {0}
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Nebyly nalezeny žádné produkty
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Rezervované množství pro výrobu: Množství surovin pro výrobu výrobních položek.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Volitelný. Toto nastavení bude použito pro filtrování v různých transakcích.
DocType: Stock Entry,Target Warehouse Address,Adresa cílového skladu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Zdanitelné dodávky (nulová hodnota)
DocType: Sales Invoice,Customer Address,Adresa zákazníka
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Majetek {0} nepatří společnosti {1}
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Kapacita pokoje
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Vyberte dávku
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Vyberte hodnoty atributu
DocType: Cheque Print Template,Signatory Position,Pozice signatáře
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Řádek {0}: Pro účet pohledávek / závazků {1} je vyžadován typ strany a strana
apps/erpnext/erpnext/config/manufacturing.py,Production,Výroba
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Nepodařilo se nastavit příslušenství společnosti Post
apps/erpnext/erpnext/config/support.py,Communication log.,Komunikační protokol.
DocType: Purchase Invoice Item,Enable Deferred Expense,Povolit odložené náklady
DocType: Purchase Order,Customer Contact Email,E-mailová adresa zákazníka
DocType: Clinical Procedure Template,Collection Details,Podrobnosti o sbírce
DocType: Stock Entry Detail,Stock Entry Child,Sklad Vstupní Dítě
DocType: Request for Quotation Supplier,No Quote,Žádná nabídka
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Omlouváme se, sériová čísla nelze sloučit"
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py,This is based on transactions against this Sales Person. See timeline below for details,To je založeno na transakcích proti této prodejní osobě. Podrobnosti naleznete v níže uvedené časové ose
DocType: Course Content,Quiz,Kviz
DocType: Sales Invoice Item,Delivered Qty,Dodané množství
DocType: Material Request Plan Item,Minimum Order Quantity,Minimální množství pro objednání
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozornit objednávky
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která je oprávněna podávat transakce, které přesahují stanovené limity úvěrů."
DocType: Employee Boarding Activity,Activity Name,Název aktivity
DocType: Item Barcode,UPC-A,UPC-A
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detail
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Varianta
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Cílový sklad je povinný pro řádek {0}
apps/erpnext/erpnext/config/support.py,Warranty,Záruka
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID aplikace Guardian2
DocType: Expense Claim Detail,Expense Claim Type,Typ nároku na výdaje
DocType: Email Digest,Bank Balance,Stav účtu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Pravidlo tvorby cen se provádí tak, že přepíše Ceník / definuje procentní sazbu slevy na základě některých kritérií."
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu
DocType: Authorization Rule,Applicable To (Employee),Platné pro (zaměstnanec)
DocType: Tally Migration,Day Book Data,Data v denní knize
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Hrubý zisk / ztráta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Částka pro dobropis
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Platba
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Capacity Planning Error,Chyba plánování kapacity
DocType: Supplier,Prevent POs,Zabránit organizacím producentů
DocType: QuickBooks Migrator,Authorization Endpoint,Koncový bod autorizace
DocType: Payment Gateway Account,Payment Gateway Account,Účet platební brány
,BOM Variance Report,Zpráva o variantě rozpisky
apps/erpnext/erpnext/utilities/activation.py,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Přidejte zbytek své organizace jako své uživatele. Můžete také přidat pozvání Zákazníci do svého portálu přidáním z Kontaktů
DocType: Training Event,Employee Emails,Zaměstnanecké e-maily
DocType: Travel Request,Any other details,Další podrobnosti
DocType: Patient,Inpatient Status,Stav pacienta
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Vytvořit položku vrácení
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,{0} existuje mezi {1} a {2} (
DocType: BOM,Scrap,Šrot
DocType: Clinical Procedure,Clinical Procedure,Klinický postup
DocType: Supplier,Hold Type,Typ přidržení
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Zpracovat data denní knihy
DocType: Fee Validity,Fee Validity,Platnost poplatku
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Vytvořit poplatky
DocType: Cheque Print Template,Date Settings,Nastavení data
DocType: BOM Operation,Operation Time,Doba provozu
DocType: Asset,Value After Depreciation,Hodnota po odpisu
apps/erpnext/erpnext/projects/doctype/project/project.py,Start date of task <b>{0}</b> cannot be less than <b>{1}</b> expected start date <b>{2}</b>,Datum zahájení úlohy <b>{0}</b> nemůže být kratší než <b>{1}</b> očekávané datum zahájení <b>{2}</b>
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,Zbývající
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Počet vedoucích
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou tento systém nastavujete."
DocType: Serial No,Out of AMC,Z AMC
DocType: Job Opening,"Job profile, qualifications required etc.","Profil práce, požadované kvalifikace atd."
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Stát lodí
DocType: Opportunity Item,Basic Rate,Základní sazba
DocType: Compensatory Leave Request,Work End Date,Datum ukončení práce
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Požadavek na suroviny
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Cíl kvality.
apps/erpnext/erpnext/templates/pages/projects.js,Show Open,Zobrazit Otevřít
DocType: Item Attribute,Attribute Name,Název atributu
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Informace o typu dárce.
DocType: Supplier,Is Transporter,Je Transporter
DocType: Loan Type,Maximum Loan Amount,Maximální částka úvěru
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,E-mail nebyl nalezen ve výchozím kontaktu
DocType: Hotel Room Reservation,Booked,Zarezervováno
DocType: Maintenance Visit,Partially Completed,Částečně dokončeno
DocType: Quality Procedure Process,Process Description,Popis procesu
DocType: Company,Default Employee Advance Account,Výchozí účet zaměstnance
DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Název plánu hodnocení
DocType: Supplier,Default Payment Terms Template,Standardní šablona platebních podmínek
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Přidat další položky nebo otevřít celý formulář
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Souhrn práce pro {0}
DocType: Academic Term,Academic Term,Akademický termín
DocType: Pricing Rule,Quantity and Amount,Množství a množství
DocType: Stock Entry,Target Warehouse Name,Název cílového skladu
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Maximální osvobozená částka
DocType: Stock Settings,Sample Retention Warehouse,Vzorový retenční sklad
DocType: Pricing Rule,Discount Percentage,Procento slevy
DocType: Company,Company Description,Popis společnosti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Sériové číslo {0} nepatří do položky {1}
DocType: Work Order,Scrap Warehouse,Skladový šrot
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Informace o kapitole.
apps/erpnext/erpnext/hr/utils.py,) for {0},) pro {0}
DocType: Sales Invoice Item,References,Reference
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Rezervované množství
DocType: Shift Assignment,Shift Type,Typ řazení
DocType: Delivery Stop,Delivery Stop,Zastavení dodávky
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,"Žádný výsledek, který chcete odeslat"
DocType: Loyalty Program,Redemption,Vykoupení
DocType: Material Request,Transferred,Přestoupil
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} má platnost do {1}
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Všechna studentská přijímací řízení
DocType: Travel Request,Address of Organizer,Adresa pořadatele
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Hodnoty osvobozených, nulových a neinvestičních zásob"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Návštěva {0} musí být zrušena před zrušením této objednávky odběratele
DocType: Quotation Item,Stock Balance,Stav zůstatku
DocType: Delivery Note Item,Available Qty at From Warehouse,Dostupný Množství ve skladu
DocType: Stock Entry,Repack,Repack
DocType: UOM,Must be Whole Number,Musí to být celé číslo
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditní limit byl překročen pro zákazníka {0} ({1} / {2})
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Odeslané objednávky nelze smazat
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Ahoj
DocType: Vehicle Service,Change,Změna
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Náklady na aktivitu existují pro zaměstnance {0} proti typu aktivity - {1}
DocType: Request for Quotation Item,Request for Quotation Item,Požadavek na položku nabídky
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} zadáno dvakrát v položce Daň z položky
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Srážka plná daň na vybrané mzdové datum
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Poslední datum kontroly uhlíku nemůže být datem do budoucna
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Vyberte účet částky změny
DocType: Support Settings,Forum Posts,Fórum Příspěvky
DocType: Timesheet Detail,Expected Hrs,Očekávané hodiny
DocType: Subscription Plan,Payment Plan,Platebni plan
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Nejdříve
DocType: Program Enrollment Tool,Enroll Students,Zapsat studenty
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Opakujte výnosy zákazníka
DocType: Company,Date of Commencement,Datum začátku
DocType: Bank,Bank Name,Jméno banky
DocType: GSTR 3B Report,December,prosinec
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Platnost od data musí být kratší než platné
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,To je založeno na účasti tohoto zaměstnance
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Pokud je zaškrtnuto, domovská stránka bude výchozí skupinou položek pro webovou stránku"
DocType: Crop,Row Spacing UOM,Rozteč řádků UOM
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Lze odeslat pouze aplikace, které mají status „Schváleno“ a „Odmítnuto“"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import v hromadném
DocType: Material Request,Terms and Conditions Content,Smluvní podmínky Obsah
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Částka objednávky (měna společnosti)
DocType: Healthcare Practitioner,Hospital,Nemocnice
,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní kurz pro položku {0} je nižší než {1}. Prodejní cena by měla být minimálně {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Aplikace fondů (aktiv)
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Šablony postavení dodavatele.
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,Grant
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Ceník Nezvolena měna
DocType: Salary Slip,Total in words,Celkem ve slovech
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Je-li tato volba povolena, systém automaticky zaúčtuje položky účtování zásob."
DocType: BOM Item,BOM Item,Položka kusovníku
DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Nejdříve zadejte podrobnosti o údržbě
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Předpokládaný vzorec množství
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Skóre hodnocení dodavatelů Stojící
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Řádek {0}: Nastavte správný kód způsobu platby {1}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maximální dávka zaměstnance {0} převyšuje {1} součtem {2} předchozí nárokované částky
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,"Stav zaměstnance nelze nastavit na hodnotu „Left“, protože tento zaměstnanec v současné době podává zprávy tomuto zaměstnanci:"
DocType: BOM Explosion Item,Source Warehouse,Zdrojový sklad
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Přidat uživatele
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Platební Tems
DocType: SMS Center,All Sales Partner Contact,Kontakt pro všechny obchodní partnery
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Celkem (Amt)
DocType: Bank Statement Transaction Invoice Item,Payment Description,Popis platby
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,PSČ
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Akumulované hodnoty
DocType: Grading Scale,Intervals,Intervaly
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Tréninkové akce
DocType: Production Plan Item,Quantity and Description,Množství a popis
DocType: Payment Entry,Payment Type,Způsob platby
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Čísla folia neodpovídají
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Kontrola kvality: {0} není pro položku předloženo: {1} v řádku {2}
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Zobrazit {0}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,{0} nalezena položka.
,Stock Ageing,Stárnutí zásob
DocType: Customer Group,Mention if non-standard receivable account applicable,"Uveďte, zda lze použít nestandardní účet pohledávek"
,Subcontracted Item To Be Received,Subcontracted Item to Be Received
DocType: Item,Synced With Hub,Synced S Hubem
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,K dnešnímu dni nemůže být menší než od data
DocType: Guardian,Work Address,Pracovní adresa
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Celkový dokončený počet nemůže být větší než pro množství
DocType: POS Item Group,POS Item Group,Skupina POS položek
DocType: Homepage,Company Description for website homepage,Společnost Popis stránky domovské stránky
,Delivery Note Trends,Trendy dodacího listu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,"Stopped Production Order cannot be cancelled, Unstop it first to cancel",Zastavenou výrobní zakázku nelze zrušit
DocType: Share Balance,Current State,Současný stav
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Otevřít položku {0}
,Batch-Wise Balance History,Historie dávkových dávek
DocType: Monthly Distribution Percentage,Percentage Allocation,Procentní alokace
DocType: Vital Signs,One Sided,Jednostranný
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Vztah s Guardian2
DocType: Asset,Disposal Date,Datum likvidace
DocType: Opportunity,Opportunity Type,Typ příležitosti
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Šablona mapování peněžních toků
DocType: Asset Settings,Depreciation Options,Možnosti odpisů
DocType: Student Admission,Admission Start Date,Datum zahájení přijetí
DocType: Manufacturing Settings,Update BOM Cost Automatically,Automaticky aktualizovat náklady na kusovník
DocType: Subscription Settings,Subscription Settings,Nastavení předplatného
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,Částka CGST
DocType: Amazon MWS Settings,Seller ID,ID prodejce
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',&quot;K případu č.&quot; nesmí být menší než „Od případu č.“
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Sloučení je možné pouze tehdy, jsou-li v obou záznamech stejné vlastnosti. Je skupina, typ root, společnost"
DocType: SMS Log,SMS Log,Protokol SMS
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Zadejte prosím buď Množství nebo Míra ocenění nebo obojí
DocType: Salary Component,Amount based on formula,Částka podle vzorce
DocType: Clinical Procedure Item,Transfer Qty,Převod Qty
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Nákladová střediska
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Dávka je povinná v řádku {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Chyba ve vzorci nebo podmínce: {0}
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",K zahrnutí daně v řádku {0} do položky Item rate musí být zahrnuty také daně v řádcích {1}
,Trial Balance (Simple),Zkušební zůstatek (jednoduchý)
DocType: Purchase Order,Customer Contact,Kontakt se zákazníkem
DocType: Marketplace Settings,Registered,Registrovaný
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Hrubá částka nákupu je povinná
DocType: Fee Structure,Components,Komponenty
DocType: Pricing Rule,Promotional Scheme,Propagační program
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Řádek # {0}: Účet {1} nepatří společnosti {2}
DocType: Quotation Item,Against Doctype,Proti Doctype
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Celková částka složky flexibilního požitku {0} by neměla být nižší než maximální hodnota {1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Od GSTIN
DocType: Sales Invoice,Return Against Sales Invoice,Návratnost proti prodejní faktuře
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Přejmenovat hodnotu atributu v atributu položky.
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Ve frontě pro aktualizaci nejnovější ceny ve všech kusovnících. Může to trvat několik minut.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Vyberte prosím sklad
DocType: Purchase Invoice Item,Weight UOM,Hmotnost UOM
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Přehled závazků
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} proti zakázce odběratele {1}
DocType: Payroll Employee Detail,Payroll Employee Detail,Detail mzdy zaměstnance
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Přijetí a zápis
DocType: Budget Account,Budget Amount,Částka rozpočtu
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} se neshoduje se společností {1} v režimu účtu: {2}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Zadejte prosím doklad o přijetí
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Změňte počáteční / aktuální pořadové číslo existující série.
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Životní cyklus zaměstnanců
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Pro Množství musí být menší než množství {0}
DocType: Assessment Plan,Assessment Plan,Plán hodnocení
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Reklamace
DocType: Company,Date of Incorporation,Datum začlenění
DocType: Asset,Double Declining Balance,Dvojitý klesající zůstatek
DocType: Payroll Entry,Validate Attendance,Ověřit účast
DocType: Lab Test,LP-,LP-
DocType: POS Customer Group,POS Customer Group,POS Customer Group
,Qty to Deliver,Množství k dodání
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Vyžaduje se fiskální rok {0}
DocType: HR Settings,Employee Records to be created by,"Záznamy o zaměstnancích, které mají být vytvořeny"
DocType: Depreciation Schedule,Depreciation Amount,Částka odpisů
DocType: Sales Order Item,Gross Profit,Hrubý zisk
DocType: Quality Inspection,Item Serial No,Položka Sériové číslo
DocType: Asset,Insurer,Pojistitel
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Nákup částka
DocType: Asset Maintenance Task,Certificate Required,Požadovaný certifikát
DocType: Retention Bonus,Retention Bonus,Retenční bonus
DocType: Item,Asset Naming Series,Řada názvů aktiv
DocType: Healthcare Settings,Laboratory Settings,Laboratorní nastavení
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Výše integrované daně
DocType: Branch,Branch,Větev
DocType: Request for Quotation Item,Required Date,Požadované datum
DocType: Cashier Closing,Returns,Vrací
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Vyjednávání / Přezkum
,Stock Summary,Přehled zásob
DocType: Bank Reconciliation,From Date,Od data
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Můžete uplatnit pouze částku {0}, zbytek {1} by měl být v aplikaci jako pro-rata komponenta"
DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logický sklad, ve kterém jsou provedeny skladové položky."
DocType: Stock Entry Detail,Difference Account,Účet rozdílů
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Tím odešlete výplatní pásky a vytvoříte záznam akruálního žurnálu. Chcete pokračovat?
DocType: Manufacturer,Manufacturers used in Items,Výrobci používali v položkách
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Student {0} nepatří do skupiny {1}
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržujte stejnou rychlost v celém nákupním cyklu
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Nastavit výchozí účet inventáře pro trvalé zásoby
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Čekání na vytvoření poplatku
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Zrušení zálohy na zrušení objednávky
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Navštivte zprávu o volání údržby.
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Chcete-li z programu ERPNext co nejlépe využít, doporučujeme vám věnovat si čas a sledovat tato videa nápovědy."
DocType: Fertilizer Content,Fertilizer Content,Obsah hnojiva
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Sériové číslo {0} nelze smazat, protože se používá ve skladových transakcích"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v Potvrzení nákupu proti každé položce
DocType: Account,Credit,Kredit
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Stáhnout JSON
DocType: Sales Invoice,Loyalty Amount,Věrnostní částka
DocType: Account,Accounts,Účty
DocType: Loyalty Program,Expiry Duration (in days),Doba vypršení platnosti (ve dnech)
DocType: Pricing Rule,Product Discount Scheme,Systém slev na produkty
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Vytváření společnosti a import účtové osnovy
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Skladem k dispozici
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Přiřazení zaměstnancům
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Žádný zaměstnanec pro uvedená kritéria
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Nebyly nalezeny žádné položky
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Karta úlohy {0} byla vytvořena
DocType: Delivery Note,Is Return,Je návrat
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kritéria analýzy půdy
DocType: Quiz Result,Selected Option,Vybraná možnost
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Náhled Plat Slip
DocType: Asset,Assets,Aktiva
DocType: Pricing Rule,Rate or Discount,Sazba nebo sleva
DocType: Travel Itinerary,Non-Vegetarian,Nevegetarián
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Celkem: {0}
DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,Neznámý
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Synchronizace offline faktur
DocType: Practitioner Schedule,Schedule Name,Název plánu
DocType: Shopify Settings,Shopify Settings,Shopify Settings
DocType: Company,Sales Monthly History,Prodejní měsíční historie
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,"„Nemá sériové číslo“ nemůže být „ne“ pro položku, která není skladem"
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Celková zdanitelná částka
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Neplatný atribut {0} {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Sériové číslo {0} již bylo vráceno
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
DocType: Student Group Student,Group Roll Number,Číslo skupiny
DocType: QuickBooks Migrator,Default Shipping Account,Výchozí přepravní účet
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Subscription,Trialling,Zkouška
DocType: Loyalty Program,Single Tier Program,Jednostupňový program
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Proti půjčce: {0}
DocType: Tax Withholding Category,Tax Withholding Rates,Daňové srážkové sazby
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Fórum Společenství
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Typ účtu pro {0} musí být {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Vyberte prosím Dokončení pro dokončenou opravu
DocType: Clinical Procedure,Medical Department,Lékařské oddělení
DocType: Share Transfer,From Shareholder,Od akcionáře
DocType: Company,Default Terms,Výchozí podmínky
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Přidat časové úseky
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zajistit dodávku na základě vyrobeného sériového čísla
,Eway Bill,Eway Bill
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Zboží nelze aktualizovat proti dodacímu listu {0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Podtyp
DocType: Task,Closing Date,Uzávěrka
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Přejděte na Plochu a začněte používat ERPNext
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Duplicitní sériové číslo zadáno pro položku {0}
DocType: Item Price,Packing Unit,Balicí jednotka
DocType: Travel Request,International,Mezinárodní
DocType: Item Tax Template Detail,Item Tax Template Detail,Detail položky daňové šablony
DocType: BOM Update Tool,New BOM,Nový kusovník
DocType: Supplier,Is Internal Supplier,Je interním dodavatelem
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Odmítnout
DocType: Salary Slip,net pay info,informace o čistém platu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Povinnosti a daně
DocType: Appraisal Goal,Score Earned,Získané skóre
DocType: Task,Dependent Tasks,Závislé úkoly
DocType: Tax Rule,Shipping Zipcode,Poštovní směrovací kód
DocType: Naming Series,Update Series,Aktualizace série
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",např. &quot;Sestavení nástrojů pro stavitele&quot;
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Prohledávání
DocType: Bank Statement Transaction Entry,Bank Statement,Výpis z bankovního účtu
DocType: Appointment Type,Default Duration,Výchozí doba trvání
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Výchozí nastavení pro nákupní transakce.
DocType: Work Order Operation,Actual Time and Cost,Skutečný čas a náklady
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,Hodnocení
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Životní cyklus
DocType: Student Sibling,Studying in Same Institute,Studium ve stejném institutu
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Kód kurzu:
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Příspěvek%
DocType: Journal Entry,Credit Note,Dobropis
DocType: Batch,Parent Batch,Rodičovská dávka
DocType: Payment Reconciliation,Get Unreconciled Entries,Získejte nesouhlasné položky
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Nastavte společnost
DocType: Lead,Lead Type,Typ elektrody
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Řádek # {0}: Datum zaúčtování musí být stejné jako datum nákupu {1} aktiva {2}
DocType: Payment Entry,Difference Amount (Company Currency),Částka rozdílu (měna společnosti)
DocType: Invoice Discounting,Sanctioned,Schváleno
DocType: Course Enrollment,Course Enrollment,Zápis kurzu
DocType: Item,Supplier Items,Položky dodavatele
DocType: Sales Order,Not Applicable,Nelze použít
DocType: Support Search Source,Response Options,Možnosti odpovědi
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0} by měla být hodnota mezi 0 a 100
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Prodavač
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Balení Slip
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Při synchronizaci zákazníků ze služby Shopify bude skupina zákazníků nastavena na vybranou skupinu
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Použijte nyní
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Hotovo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Výrobní množství je povinné
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Obejít kontrolu kreditu na zakázce odběratele
DocType: Bin,Stock Value,Hodnota akcií
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Šablona daně pro položky sazby daně.
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} není aktivní
DocType: Inpatient Record,O Positive,O Pozitivní
DocType: Training Event,Training Program,Tréninkový program
DocType: Cashier Closing Payments,Cashier Closing Payments,Uzavření plateb pokladní
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,„Od balíčku č.“ pole nesmí být prázdné ani menší než 1.
,Purchase Order Trends,Trendy nákupní objednávky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Zadejte mateřské nákladové středisko
DocType: Purchase Receipt,Supplier Delivery Note,Dodací list dodavatele
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Zvolte prosím Drug
DocType: Support Settings,Post Route Key,Zadejte klíč trasy
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Přijímání studentů
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Podrobnosti o členství
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Probace
,Inactive Sales Items,Neaktivní položky prodeje
DocType: Amazon MWS Settings,AU,AU
DocType: Vital Signs,Abdomen,Břicho
DocType: HR Settings,Employee Settings,Nastavení zaměstnance
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,Arrear
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Řídící skupina dodavatelů.
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Zákazník se stejným názvem již existuje
DocType: Course Enrollment,Program Enrollment,Zápis programu
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Pracovní příležitosti pro označení {0} již otevřeno nebo najímání dokončeno podle personálního plánu {1}
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Autorizovaný signatář
DocType: Pricing Rule,Discount on Other Item,Sleva na jiné položky
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Počet nabídek
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Žádní studenti nenalezeni
DocType: Journal Entry,Bank Entry,Vstup do banky
DocType: Antibiotic,Antibiotic,Antibiotikum
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Procento, které můžete obdržet nebo dodat více proti objednanému množství. Například: Pokud jste si objednali 100 jednotek. a vaše Příspěvek je 10%, pak máte povoleno přijímat 110 jednotek."
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Podpora dotazů od zákazníků.
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Aktuální
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Do výše uvedené tabulky zadejte požadavky na materiál
DocType: Item Reorder,Item Reorder,Změna pořadí položek
DocType: Company,Stock Settings,Nastavení skladu
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Řádek # {0}: Sériové číslo je povinné
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,"Počet sloupců pro tuto sekci. Pokud vyberete 3 sloupce, zobrazí se 3 řádky."
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,Konzultace
DocType: Employee Benefit Claim,Claim Benefit For,Využití nároku
DocType: Fiscal Year,Year Name,Název roku
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Odsouhlasené transakce
apps/erpnext/erpnext/controllers/status_updater.py,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,"Poznámka: Systém nebude kontrolovat nadměrné doručení a přeúčtování položky {0}, protože množství nebo částka je 0"
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Zahajovací zůstatek
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',Hodnota „Od data“ musí být za „To Date“
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Celková částka {0}
DocType: Employee Skill,Evaluation Date,Datum hodnocení
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",&quot;Položka poskytovaná zákazníkem&quot; nemůže být také zakoupena
DocType: C-Form Invoice Detail,Grand Total,Celkový součet
apps/erpnext/erpnext/selling/doctype/customer/customer.py,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úvěrový limit je nižší než aktuální nesplacená částka pro zákazníka. Limit kreditu musí být minimálně {0}
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Pouze {0} skladem pro položku {1}
DocType: Payment Reconciliation,Bank / Cash Account,Bankovní / peněžní účet
apps/erpnext/erpnext/projects/doctype/project/project.py,Task weight cannot be negative,Hmotnost úkolu nemůže být záporná
DocType: Serial No,Creation Date,Datum vzniku
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Dokončené Dobře
DocType: Healthcare Settings,Manage Sample Collection,Správa kolekce vzorků
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Nelze najít DocType {0}
DocType: Purchase Invoice Item,Item Weight Details,Položka Hmotnost Podrobnosti
DocType: POS Closing Voucher,Modes of Payment,Způsoby platby
DocType: Naming Series,Series List for this Transaction,Seznam sérií pro tuto transakci
DocType: Crop,Produce,Vyrobit
DocType: Woocommerce Settings,API consumer key,Spotřebitelský klíč API
DocType: Quality Inspection Reading,Reading 2,Čtení 2
DocType: Driver,Driving License Categories,Kategorie řidičského průkazu
DocType: Asset Repair,Asset Repair,Oprava aktiv
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Kurzové přehodnocení
DocType: Warehouse,Warehouse Contact Info,Skladové kontaktní informace
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Požadavek na dodavatele nabídky
DocType: Travel Request,Costing,Kalkulace
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Dlouhodobý majetek
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Salary Structure,Total Earning,Celkový zisk
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
DocType: Share Balance,From No,Od č
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Faktura pro odsouhlasení platby
DocType: Purchase Invoice,Taxes and Charges Added,Přidané daně a poplatky
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň nebo poplatek za
DocType: Authorization Rule,Authorized Value,Autorizovaná hodnota
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Přijato od
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Sklad {0} neexistuje
DocType: Item Manufacturer,Item Manufacturer,Položka Výrobce
DocType: Sales Invoice,Sales Team,Prodejní tým
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Balík Množství
DocType: Purchase Order Item Supplied,Stock UOM,Skladové UOM
DocType: Installation Note,Installation Date,Datum instalace
DocType: Email Digest,New Quotations,Nové nabídky
DocType: Production Plan Item,Ordered Qty,Objednané množství
,Minutes to First Response for Issues,Zápis do první reakce na problémy
DocType: Vehicle Log,Refuelling Details,Podrobnosti o doplňování paliva
DocType: Sales Partner,Targets,Cíle
DocType: Buying Settings,Settings for Buying Module,Nastavení modulu Nákup
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Objednávka {0} není odeslána
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Byla odeslána materiální žádost {0}.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Datum účtování a čas odeslání je povinný
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} of {}
DocType: Lab Test Template,Lab Routine,Laboratorní rutina
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Platba selhala. Další podrobnosti naleznete v účtu GoCardless
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Řádek {0}: Datum zahájení musí být před datem ukončení
apps/erpnext/erpnext/config/education.py,LMS Activity,Aktivita LMS
DocType: Asset,Next Depreciation Date,Další odpisový den
DocType: Healthcare Settings,Appointment Reminder,Připomenutí jmenování
DocType: Cost Center,Cost Center Name,Název nákladového střediska
DocType: Pricing Rule,Margin Rate or Amount,Míra marže nebo částka
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinický postup Spotřební materiál
DocType: Asset,Manual,Manuál
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Suroviny nemohou být prázdné.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Zadejte prosím nákladové středisko
DocType: Support Search Source,Source DocType,Zdroj DocType
DocType: Assessment Group,Parent Assessment Group,Skupina pro hodnocení rodičů
DocType: Purchase Invoice Item,Accepted Warehouse,Přijatý sklad
DocType: Sales Invoice Item,Discount and Margin,Sleva a marže
,Student and Guardian Contact Details,Kontaktní údaje studenta a opatrovníka
DocType: Pricing Rule,Buying,Nákup
DocType: Student Attendance,Present,"Současnost, dárek"
DocType: Membership,Member Since,Členem od
DocType: Tax Rule,Use for Shopping Cart,Použití pro nákupní košík
DocType: Loan,Loan Account,Úvěrový účet
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Všechny povinné úkoly pro tvorbu zaměstnanců ještě nebyly provedeny.
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimální délka mezi jednotlivými rostlinami v poli pro optimální růst
DocType: Budget,Applicable on Purchase Order,Platí pro Objednávku
DocType: Stock Entry,Receive at Warehouse,Přijmout ve skladu
DocType: Cash Flow Mapping,Is Income Tax Expense,Je daň z příjmů
DocType: Journal Entry,Make Difference Entry,Make Difference Entry
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Celkem (kredit)
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Značka
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Bod 3
DocType: Purchase Invoice Item,Deferred Expense Account,Účet odložených nákladů
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Částka akumulovaných odpisů
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinné pro položku {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Žádné účetní položky pro následující sklady
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Nejprve prosím uložte
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Extra malý
DocType: Assessment Group,Assessment Group,Posuzovací skupina
DocType: Pricing Rule,UOM,UOM
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,Účty vznesené dodavateli.
DocType: Additional Salary,HR User,Uživatel HR
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Zisk za rok
DocType: Codification Table,Medical Code,Lékařský zákoník
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Aktualizujte data bankovních plateb pomocí časopisů.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Aktuální aktiva
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Řádek # {0}: Majetek {1} nepatří společnosti {2}
DocType: Purchase Invoice,Contact Person,Kontaktní osoba
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} není zapsáno v dávce {2}
DocType: Holiday List,Holiday List Name,Název seznamu prázdnin
DocType: Water Analysis,Collection Temperature ,Teplota sběru
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Spravovat fakturaci schůzky odesílat a rušit automaticky pro pacientské setkání
DocType: Employee Benefit Claim,Claim Date,Datum nároku
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,"Pokud je dodavatel blokován na dobu neurčitou, ponechte prázdné"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Docházka od data a doposud je povinná
DocType: Serial No,Out of Warranty,bez záruky
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Stejnou položku nelze zadat vícekrát.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Vyberte manuálně studenty pro skupinu založenou na aktivitě
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Aktualizováno
DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Vyberte možnost Pacient
DocType: Asset,Straight Line,Přímka
DocType: Quality Action,Resolutions,Usnesení
DocType: SMS Log,No of Sent SMS,Číslo odeslané SMS
,GST Itemised Sales Register,GST Katalogizovaný prodejní registr
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Celková výše záloh nesmí být vyšší než celková sankční částka
DocType: Lab Test,Test Name,Název testu
DocType: Task,Total Billing Amount (via Time Sheet),Celková částka fakturace (prostřednictvím časového výkazu)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Nabídka {0} je zrušena
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Jasné hodnoty
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,Sledovatelnost
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Stejná společnost je zadána více než jednou
DocType: Delivery Stop,Contact Name,kontaktní jméno
DocType: Customer,Is Internal Customer,Je interní zákazník
DocType: Purchase Taxes and Charges,Account Head,Vedoucí účtu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Nižší příjem
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Datum zahájení by mělo být kratší než datum ukončení úlohy {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Služby zákazníkům
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Poplatek
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},Kusovník {0} nepatří do položky {1}
DocType: Daily Work Summary,Daily Work Summary Group,Skupina denní práce
apps/erpnext/erpnext/config/help.py,Customizing Forms,Přizpůsobení formulářů
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Cancel Material Visit {0} před zrušením této Reklamace
DocType: POS Profile,Ignore Pricing Rule,Ignorovat pravidlo určování cen
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Jídlo
DocType: Lost Reason Detail,Lost Reason Detail,Detail ztraceného důvodu
DocType: Maintenance Visit,Customer Feedback,Zákaznická zpětná vazba
DocType: Serial No,Warranty / AMC Details,Podrobnosti o záruce / AMC
DocType: Issue,Opening Time,Otevírací doba
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Zobrazte seznam všech videí nápovědy
DocType: Purchase Invoice,Party Account Currency,Měna účtu strany
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,"Vyberte numpad pole, které chcete upravit"
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kritéria plánu hodnocení
DocType: Products Settings,Item Fields,Pole položek
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Správa obchodních partnerů.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracené, protože nabídka byla provedena."
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržet rodinné údaje, jako je jméno a povolání rodič, manželka a děti"
DocType: Tax Rule,Shipping City,Přepravní město
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Aktualizovat položky
,Customer Ledger Summary,Přehled zákazníků
DocType: Inpatient Record,B Positive,B Pozitivní
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Účetní zápisy.
DocType: Buying Settings,Purchase Order Required,Požadavek na objednávku
DocType: Program Enrollment Tool,New Student Batch,Nová studentská dávka
DocType: Account,Account Type,Typ účtu
DocType: Vehicle,Fuel Type,Typ paliva
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},E-mail odeslán na adresu {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Změnit datum vydání
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM for {0} not found,Výchozí kusovník pro {0} nebyl nalezen
,HSN-wise-summary of outward supplies,HSN-moudrý souhrn vnějších dodávek
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Jmenování a setkání
DocType: Tax Withholding Category,Tax Withholding Category,Kategorie srážkové daně
DocType: Agriculture Analysis Criteria,Linked Doctype,Propojený Doctype
DocType: Account,Cost of Goods Sold,Cena prodaného zboží
DocType: Quality Inspection Reading,Reading 3,Čtení 3
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Skupina podle kupónu
,Delivered Items To Be Billed,Dodané položky k vyúčtování
DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o převodu zaměstnanců
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrační čísla společnosti pro váš odkaz. Daňová čísla atd.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Sériové číslo {0} nepatří do skladu {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,Del
apps/erpnext/erpnext/templates/pages/task_info.html,on,na
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Zde můžete definovat všechny úkoly, které je třeba provést pro tuto plodinu. Denní pole se používá k označení dne, kdy je třeba úkol provést, 1 je 1. den atd."
DocType: Asset Maintenance Log,Task,Úkol
DocType: Naming Series,Help HTML,Nápověda HTML
DocType: Drug Prescription,Dosage by time interval,Dávkování podle časového intervalu
DocType: Batch,Batch Description,Popis dávky
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Nastavte prosím přidružený účet v kategorii daňová srážková kategorie {0} proti společnosti {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Analýza potřeb
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Přidělené listy
DocType: Payment Request,Transaction Details,Detaily transakce
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikovat na skladě &quot;In Stock&quot; nebo &quot;Not in Stock&quot; na základě skladů dostupných v tomto skladu.
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Název společnosti není stejný
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Propagaci zaměstnance nelze podat před datem propagace
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Není povoleno aktualizovat akciové transakce starší než {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Datum zahájení by mělo být menší než datum ukončení položky {0}
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Vytvořit zákaznické nabídky
DocType: Buying Settings,Buying Settings,Nastavení nákupu
DocType: Restaurant Menu Item,Restaurant Menu Item,Položka menu restaurace
DocType: Appraisal,Calculate Total Score,Vypočítat celkové skóre
DocType: Issue,Issue Type,Typ problému
apps/erpnext/erpnext/projects/doctype/project/project.py,Start date of task <b>{0}</b> cannot be greater than <b>{1}</b> expected end date <b>{2}</b>,Datum zahájení úlohy <b>{0}</b> nemůže být delší než <b>{1}</b> očekávané datum ukončení <b>{2}</b>
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Hodnota zůstatku
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Skupiny
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Cílový sklad v řádku {0} musí být stejný jako pracovní příkaz
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je již uvedeno v prodejní faktuře: {1}
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Pokud Shopify neobsahuje zákazníka v objednávce, pak při synchronizaci objednávek systém zváží výchozí zákazníka pro objednávku"
DocType: Shopify Settings,Shopify Tax Account,Shopify Daňový účet
apps/erpnext/erpnext/setup/doctype/company/company.js,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 smazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou zachována. Tuto akci nelze vrátit zpět."
DocType: Purchase Receipt,Auto Repeat Detail,Detail automatického opakování
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,Uveďte prosím uvedené položky za nejlepší možné ceny
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} v řádku {1}
DocType: Job Card Time Log,Job Card Time Log,Časový záznam pracovní karty
DocType: Patient,Patient Demographics,Demografie pacientů
DocType: Share Transfer,To Folio No,Na Folio Ne
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Peněžní toky z operací
DocType: Stock Settings,Allow Negative Stock,Povolit zápornou zásobu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Žádná z položek nemá žádnou změnu v množství nebo hodnotě.
DocType: Asset,Purchase Date,Datum nákupu
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Položka nastavení bankovního výpisu
,BOM Stock Report,Výkaz skladu kusovníku
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Odepsat
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Řádek {0}: Očekávaná hodnota po užitečné životnosti musí být menší než hrubá částka nákupu
DocType: Employee,Personal Bio,Osobní Bio
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Zaměstnanec {0} již požádal o {1} dne {2}:
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Standardní prodej
DocType: Clinical Procedure,Invoiced,Fakturováno
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Uživatel {0} již existuje
DocType: Account,Profit and Loss,Zisk a ztráta
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Diff Qty
DocType: Asset Finance Book,Written Down Value,Napsaná hodnota dolů
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Otevření zůstatku vlastního kapitálu
DocType: GSTR 3B Report,April,duben
DocType: Supplier,Credit Limit,Úvěrový limit
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Rozdělení
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,debit_note_amt,debit_note_amt
DocType: Quality Inspection,Inspected By,Kontrola By
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Získejte položky z produktového balíčku
DocType: Employee Benefit Claim,Employee Benefit Claim,Nárok na zaměstnanecké požitky
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Odbavení Datum není uvedeno
DocType: Company,Default Receivable Account,Výchozí účet pohledávek
DocType: Location,Check if it is a hydroponic unit,"Zkontrolujte, zda se jedná o hydroponickou jednotku"
DocType: Student Guardian,Others,Ostatní
DocType: Patient Appointment,Patient Appointment,Jmenování pacienta
DocType: Inpatient Record,AB Positive,AB Pozitivní
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,Datum odpisu
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Nadcházející události kalendáře
apps/erpnext/erpnext/config/hr.py,"Appraisals, Expense Claims and Loans","Ocenění, náklady a pohledávky"
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Vytvořit studentskou dávku
DocType: Travel Itinerary,Travel Advance Required,Vyžaduje se cestovní záloha
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Objednávky byly uvolněny do výroby.
DocType: Loyalty Program,Collection Rules,Pravidla sběru
DocType: Asset Settings,Disable CWIP Accounting,Zakázat účet CWIP
DocType: Homepage Section,Section Based On,Oddíl založený na
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} již přidělené pro zaměstnance {1} pro období {2} až {3}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Řádek {0}: Od času a do času {1} se překrývá s {2}
DocType: Vital Signs,Very Hyper,Velmi hyper
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Vyberte si charakter svého podnikání.
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Vyberte měsíc a rok
DocType: Student Log,Student Log,Záznam studenta
DocType: Shopping Cart Settings,Enable Checkout,Povolit službu Checkout
apps/erpnext/erpnext/config/settings.py,Human Resources,Lidské zdroje
DocType: Stock Entry,Total Value Difference (Out - In),Rozdíl celkové hodnoty (Out - In)
DocType: Work Order Operation,Actual End Time,Skutečný čas ukončení
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Nastavení daní
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Čisté peněžní prostředky z investic
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Účetní knihy
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Strom skupiny položek
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&#39;Celkový&#39;
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Položka 1
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,Studentské dávky
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Připojte soubor CSV se dvěma sloupci, jeden pro starý název a druhý pro nový název"
DocType: Bank Statement Transaction Payment Item,outstanding_amount,nesplacená částka
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Citlivý
DocType: Purchase Invoice,Total (Company Currency),Celkem (měna společnosti)
DocType: Item,Website Content,Obsah webových stránek
DocType: Driver,Driving License Category,Kategorie řidičského průkazu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Řádek # {0}: Očekávané datum doručení nemůže být před datem objednávky
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Zaplatit
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Typ strany je povinný
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Pole Od akcionáře a akcionáře nemohou být prázdné
DocType: Customer Feedback,Quality Management,Řízení jakosti
DocType: BOM,Transfer Material Against,Přenos materiálu proti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Dočasně podrženo
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Připojit Shopify s ERPNext
DocType: Homepage Section Card,Subtitle,Podtitul
DocType: Soil Texture,Loam,Hlína
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
DocType: BOM,Scrap Material Cost(Company Currency),Cena materiálu šrotu (měna společnosti)
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Poznámka k doručení {0} nesmí být odeslána
DocType: Task,Actual Start Date (via Time Sheet),Skutečné datum zahájení (přes časový výkaz)
DocType: Sales Order,Delivery Date,Datum doručení
,Item Shortage Report,Zpráva o nedostatku položek
DocType: Subscription Plan,Price Determination,Stanovení ceny
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Maloobchod a velkoobchod
DocType: Project,Twice Daily,Dvakrát denně
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Integrovaná daň
DocType: Payment Entry,Deductions or Loss,Srážky nebo ztráty
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Fiskální režim je povinný, laskavě nastavte fiskální režim ve společnosti {0}"
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Přidány časové úseky
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,"Listy musí být přiděleny v násobcích 0,5"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Částka {0} {1} byla odečtena proti {2}
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba za odsouhlasení platby
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Šablona termínů nebo smlouvy.
DocType: Item,Barcodes,Čárové kódy
DocType: Course Enrollment,Enrollment Date,Datum zápisu
DocType: Holiday List,Clear Table,Vymazat tabulku
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Založení společnosti
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Volný kód položky není vybrán
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Celkem nezaplaceno: {0}
DocType: Account,Balance must be,Zůstatek musí být
DocType: Supplier,Default Bank Account,Výchozí bankovní účet
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Vytváření poplatků
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Zvolte prosím počet položek proti položce {0}
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Nepotvrzujte, zda je událost vytvořena ve stejný den"
DocType: Loan,Repaid/Closed,Zaplaceno / zavřeno
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Řádek {0}: {1} Sériová čísla potřebná pro položku {2}. Poskytli jste {3}.
DocType: Exchange Rate Revaluation Account,Gain/Loss,Zisk / Ztráta
DocType: POS Profile,Sales Invoice Payment,Platba prodejní faktury
DocType: Timesheet,Payslip,Payslip
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Žádost o cenovou nabídku.
,Procurement Tracker,Sledování zakázek
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Typ důkazu
DocType: Purchase Receipt,Vehicle Date,Datum vozidla
DocType: Delivery Settings,Dispatch Settings,Nastavení odesílání
DocType: Task,Dependencies,Závislosti
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Ztracený
DocType: BOM Update Tool,Replace BOM,Vyměňte kusovník
DocType: Patient,Marital Status,Stav
DocType: HR Settings,Enter retirement age in years,Vstup do důchodového věku v letech
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Žádné položky nejsou uvedeny
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Žádné údaje pro export
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Pokud chcete také zahrnout zůstatek předchozího fiskálního roku do tohoto fiskálního roku, vyberte možnost Přeposlat dále"
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Otevření bilance akcií
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Nechat blokováno
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Kategorie aktiv je povinná pro položku Fixed Asset
DocType: Purchase Receipt Item,Required By,Požadováno By
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Přidat do Podrobnosti
,Inactive Customers,Neaktivní zákazníci
DocType: Drug Prescription,Dosage,Dávkování
DocType: Cheque Print Template,Starting position from top edge,Výchozí pozice od horního okraje
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Trvání schůzky (min)
DocType: Accounting Dimension,Disable,Zakázat
DocType: Email Digest,Purchase Orders to Receive,Objednávky obdržíte
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Výrobní objednávky nelze získat pro:
DocType: Projects Settings,Ignore Employee Time Overlap,Ignorovat přesah zaměstnanců
DocType: Employee Skill Map,Trainings,Školení
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Ztracené důvody
DocType: Inpatient Record,A Positive,Pozitivní
DocType: Quality Inspection Reading,Reading 7,Čtení 7
DocType: Purchase Invoice Item,Serial No,Sériové č
DocType: Material Request Plan Item,Required Quantity,Požadované množství
DocType: Location,Parent Location,Parent Poloha
DocType: Production Plan,Material Requests,Požadavky na materiál
DocType: Buying Settings,Material Transferred for Subcontract,Materiál převedený na subdodávky
DocType: Job Card,Timing Detail,Detail načasování
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Požadováno Zapnuto
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Importing {0} of {1},Import {0} z {1}
DocType: Job Offer Term,Job Offer Term,Pracovní nabídka Termín
DocType: SMS Center,All Contact,Všechny kontakty
DocType: Project Task,Project Task,Projektový úkol
DocType: Item Barcode,Item Barcode,Čárový kód položky
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Úrovně zásob
DocType: Vital Signs,Height (In Meter),Výška (v metru)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Hodnota objednávky
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže můžete nastavit a sledovat cíle."
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Už jste vybrali položky z {0} {1}
DocType: Request for Quotation,Get Suppliers,Získat dodavatele
DocType: Sales Team,Contribution (%),Příspěvek (%)
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Nelze nastavit přijaté RFQ na No Quote
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Vytvořit zakázku odběratele
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím burzovních transakcí
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Žádost o {1}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Vyberte hodnotu {0} quotation_to {1}
DocType: Opportunity,Opportunity Date,Datum příležitosti
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Další kroky
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Vzdělávací zpětná vazba
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
DocType: Holiday List,Total Holidays,Celkový svátek
DocType: Fertilizer,Fertilizer Name,Název hnojiva
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Dům pronajal data potřebná pro výpočet výjimky
,Expiring Memberships,Ukončení členství
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dodavatel (y)
DocType: GL Entry,To Rename,Přejmenovat
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Kontaktujte nás
DocType: POS Closing Voucher,Cashier,Pokladní
DocType: Drug Prescription,Hour,Hodina
DocType: Support Settings,Show Latest Forum Posts,Zobrazit nejnovější příspěvky ve fóru
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Distributor
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Přidejte prosím zbývající výhody {0} do aplikace jako poměrná složka
DocType: Invoice Discounting,Short Term Loan Account,Krátkodobý úvěrový účet
DocType: Cash Flow Mapper,Section Subtotal,Oddíl Mezisoučet
apps/erpnext/erpnext/config/buying.py,Material Request to Purchase Order,Požadavek materiálu na objednávku
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS Částka
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Není oprávněn upravovat zmrazený účet {0}
DocType: POS Closing Voucher Details,Expected Amount,Očekávaná částka
DocType: Customer,Default Price List,Výchozí ceník
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Žádné položky vybrané pro přenos
DocType: Payment Schedule,Payment Amount,Částka k úhradě
DocType: Grant Application,Assessment  Manager,Assessment Manager
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,Chemikálie
apps/erpnext/erpnext/config/education.py,Assessment Reports,Zprávy o hodnocení
DocType: C-Form,IV,IV
DocType: Student Log,Academic,Akademický
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,Položka {0} není nastavena pro sériová čísla
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Ze státu
DocType: Leave Type,Maximum Continuous Days Applicable,Maximální použitelné dny
apps/erpnext/erpnext/config/support.py,Support Team.,Tým podpory.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Nejdříve zadejte název společnosti
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Import byl úspěšný
DocType: Guardian,Alternate Number,Alternativní číslo
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Všechna oddělení
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Proveďte projekt ze šablony.
DocType: Purchase Order,Inter Company Order Reference,Mezipodniková objednávka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Pracovní příkaz {0} musí být zrušen před zrušením této objednávky
DocType: Education Settings,Employee Number,Číslo zaměstnance
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Buying Rate,Prům. Kupní kurz
DocType: Manufacturing Settings,Capacity Planning For (Days),Plánování kapacity pro (dny)
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Hodnota musí být menší než hodnota v řádku {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Vyberte položku BOM a Qty for Production
DocType: Price List Country,Price List Country,Ceník Země
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Vytvořit daňové šablony
DocType: Item Attribute,Numeric Values,Číselné hodnoty
DocType: Delivery Note,Instructions,Instrukce
DocType: Blanket Order Item,Blanket Order Item,Položka objednávky deka
DocType: Accounting Dimension,Mandatory For Profit and Loss Account,Povinné Pro výkaz zisků a ztrát
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Sazba Komise nesmí být vyšší než 100%
DocType: Course Topic,Course Topic,Téma kurzu
DocType: Employee,This will restrict user access to other employee records,To omezí přístup uživatele k ostatním záznamům zaměstnanců
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Vytvořte prosím zákazníka z vedení {0}
DocType: QuickBooks Migrator,Company Settings,Nastavení společnosti
DocType: Travel Itinerary,Vegetarian,Vegetariánský
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje se stejným názvem ({0}), změňte název skupiny položek nebo přejmenujte položku"
DocType: Hotel Room,Hotel Room Type,Typ pokoje hotelu
,Cash Flow,Tok peněz
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemůže být vyšší než Vyrovnaná částka {2}
DocType: Student Log,Achievement,Úspěch
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Přidat více úkolů
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Položka Varianta {0} již existuje se stejnými atributy
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Faktura {0} již neexistuje
DocType: Item,Will also apply for variants unless overrridden,"Platí také pro varianty, pokud nejsou přepsány"
DocType: Cash Flow Mapping Accounts,Account,Účet
DocType: Sales Order,To Deliver,Dodat
,Customers Without Any Sales Transactions,Zákazníci bez jakýchkoli prodejních transakcí
DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu č
apps/erpnext/erpnext/config/education.py,Content Masters,Obsah Masters
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Správa předplatného
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Získejte zákazníky
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
DocType: Employee,Reports to,Nahlásit
DocType: Video,YouTube,Youtube
DocType: Party Account,Party Account,Účet strany
DocType: Assessment Plan,Schedule,Plán
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Prosím Vstupte
DocType: Lead,Channel Partner,Partner kanálu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Invoiced Amount,Fakturovaná částka
DocType: Project,From Template,Ze šablony
,DATEV,DATEV
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Předplatné
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,"Množství, které má být provedeno"
DocType: Quality Review Table,Achieved,Dosažené
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Částka příspěvku
DocType: Budget,Fiscal Year,Fiskální rok
DocType: Supplier,Prevent RFQs,Zabránit RFQs
DocType: Company,Discount Received Account,Účtem přijaté slevy
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),(Půldenní)
DocType: Email Digest,Email Digest,Email Digest
DocType: Crop,Crop,Oříznutí
DocType: Email Digest,Profit & Loss,Ztráta zisku
DocType: Homepage Section,Section Order,Řádek sekce
DocType: Healthcare Settings,Result Printed,Výsledek Vytištěno
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Studentská skupina
DocType: Purchase Taxes and Charges Template,"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.

#### Note

The 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.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **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.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. 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).
9. 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.
10. Add or Deduct: Whether you want to add or deduct the tax.","Standardní vzor daně, který lze použít pro všechny nákupní transakce. Tato šablona může obsahovat seznam daňových hlav a dalších nákladových hlav, jako je „Odeslání“, „Pojištění“, „Manipulace“ atd. #### Poznámka Zde definovaná sazba daně bude standardní sazbou daně pro všechny položky **. *. Pokud existují ** Položky **, které mají různé sazby, musí být přidány do ** Položka Daň ** ** v ** Položka ** master. #### Popis sloupců 1. Typ výpočtu: - Toto může být na ** Čistý součet ** (což je součet základní částky). - ** Na předchozí řádek celkem / částka ** (pro kumulativní daně nebo poplatky). Pokud vyberete tuto možnost, bude daň použita jako procento z předchozího řádku (v daňové tabulce) částky nebo celkem. - ** Skutečnost ** (jak je uvedeno). 2. Vedoucí účtu: Účetní kniha, pod kterou bude tato daň zaúčtována 3. Nákladové středisko: Pokud je daň / poplatek příjmem (např. Přepravou) nebo nákladem, musí být zaúčtován proti nákladovému středisku. 4. Popis: Popis daně (která bude vytištěna na fakturách / kottech). 5. Sazba: Sazba daně. 6. Částka: Částka daně. 7. Celkem: Kumulativní součet k tomuto bodu. 8. Zadejte řádek: Pokud na základě &quot;Předchozí řádek celkem&quot; můžete vybrat číslo řádku, které bude použito jako základ pro tento výpočet (výchozí je předchozí řádek). 9. Zvažte daň nebo poplatek za: V této sekci můžete specifikovat, zda je daň / poplatek pouze pro ocenění (nikoli pro částku celkem), nebo pouze pro součet (nepřidává hodnotu k položce) nebo pro obě. 10. Přidat nebo odečíst: zda chcete přidat nebo odečíst daň."
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Připojení k Quickbooks
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Kořen nelze upravovat.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Inženýr
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Řádek # {0}: Přidána položka
DocType: Student Admission,Eligibility and Details,Způsobilost a podrobnosti
DocType: Staffing Plan,Staffing Plan Detail,Detail personálního plánu
DocType: Email Digest,Annual Income,Roční příjem
DocType: Journal Entry,Subscription Section,Odběrová sekce
DocType: Salary Slip,Payment Days,Platební dny
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Informace dobrovolníka.
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazené zásoby starší než` by měly být menší než% d dní.
DocType: Bank Reconciliation,Total Amount,Celková částka
DocType: Certification Application,Non Profit,Neziskové
DocType: Subscription Settings,Cancel Invoice After Grace Period,Zrušení faktury po období grace
DocType: Loyalty Point Entry,Loyalty Points,Věrnostní body
DocType: Purchase Order,Set Target Warehouse,Nastavit cílový sklad
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} má v současné době {1} výsledkovou tabulku dodavatelů a RFQ k tomuto dodavateli by měly být vydávány s opatrností.
DocType: Travel Itinerary,Check-in Date,Datum příjezdu
DocType: Tally Migration,Round Off Account,Účet zaokrouhlení
DocType: Serial No,Warranty Period (Days),Záruční doba (dny)
DocType: Expense Claim Detail,Expense Claim Detail,Detail reklamace nákladů
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Program:
DocType: Patient Medical Record,Patient Medical Record,Lékařský záznam pacienta
DocType: Item,Variant Based On,Varianta založená na
DocType: Vehicle Service,Brake Oil,Brzdový olej
DocType: Employee,Create User,Vytvořit uživatele
DocType: Codification Table,Codification Table,Kodifikační tabulka
DocType: Training Event Employee,Optional,Volitelný
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Zobrazit listy všech členů oddělení v kalendáři
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Did not found transfered item {0} in Work Order {1}, the item not added in Stock Entry","Nenalezena převedená položka {0} v pracovní objednávce {1}, položka nebyla přidána do položky Vstup"
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Podívejte se na všechny otevřené vstupenky
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Operace nelze ponechat prázdné
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,Pro POS fakturu je vyžadován alespoň jeden způsob platby.
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,ID aplikace Guardian1
DocType: Sales Order Item,Supplier delivers to Customer,Dodavatel dodá zákazníkovi
DocType: Procedure Prescription,Appointment Booked,Jmenování rezervováno
DocType: Crop,Target Warehouse,Target Warehouse
DocType: Accounts Settings,Stale Days,Stale Days
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Řádek {0}: Zadání kreditu nemůže být spojeno s {1}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Zdravotní lékař {0} není k dispozici {1}
DocType: SMS Center,All Customer Contact,Veškerý kontakt se zákazníkem
apps/erpnext/erpnext/stock/doctype/item/item.py," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Udržet vzorek je založen na dávce, zkontrolujte prosím položku No Batch No."
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Disk
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Proveďte účetní zápis pro každé skladové hnutí
DocType: Travel Itinerary,Check-out Date,Zkontrolovat datum
DocType: Agriculture Analysis Criteria,Fertilizer,Hnojivo
DocType: Supplier,Default Tax Withholding Config,Výchozí daň srážková Config
DocType: Production Plan,Total Produced Qty,Celkem vyrobeno Množství
DocType: Leave Allocation,Leave Period,Období dovolené
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Byl vytvořen požadavek na platbu {0}
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Konverze UOM v hodinách
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Prům. Prodejní cena sazba
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Generování požadavků na materiál (MRP) a pracovních příkazů.
DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
DocType: Asset Maintenance Log,Periodicity,Periodicita
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Zdravotní záznam
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Provedení
DocType: Item,Valuation Method,Metoda oceňování
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} proti prodejní faktuře {1}
DocType: Quiz Activity,Pass,Složit
DocType: Sales Partner,Sales Partner Target,Cíl obchodního partnera
DocType: Patient Appointment,Referring Practitioner,Praktikující
DocType: Account,Expenses Included In Asset Valuation,Náklady zahrnuté do oceňování aktiv
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Publikování
DocType: Production Plan,Sales Orders Detail,Detail prodejních objednávek
DocType: Salary Slip,Total Deduction,Celkový odpočet
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavte předponu pro číslování série transakcí
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Záznamy žurnálu {0} jsou un-linked
apps/erpnext/erpnext/config/buying.py,Other Reports,Další zprávy
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Všechny položky již byly fakturovány
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Majetek vyřazen prostřednictvím položky deníku {0}
DocType: Employee,Prefered Email,Preferovaný e-mail
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Nelze změnit způsob oceňování, protože existují transakce proti některým položkám, které nemají vlastní metodu oceňování"
DocType: Cash Flow Mapper,Section Name,Název sekce
DocType: Packed Item,Packed Item,Balená položka
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Pro účet {2} je vyžadována částka debetní nebo kreditní.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Odeslání výplatních pásek ...
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Žádná akce
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nelze přiřadit k hodnotě {0}, protože se nejedná o účet příjmů ani výdajů"
apps/erpnext/erpnext/config/accounting.py,Masters and Accounts,Mistři a účty
DocType: Quality Procedure Table,Responsible Individual,Odpovědný jednotlivec
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Celkové vážení všech kritérií hodnocení musí být 100%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Během procesu aktualizace došlo k chybě
DocType: Sales Invoice,Customer Name,Jméno zákazníka
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Částka by neměla být nižší než nula.
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Průměrný věk
DocType: Shopping Cart Settings,Show Price,Zobrazit cenu
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Student programu pro zápis do programu
DocType: Tax Rule,Shipping State,Námořní stát
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,"Prosím, nastavte společnost"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Váha (Dr - Cr)
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Typ dodávky
DocType: Healthcare Settings,Create documents for sample collection,Vytvořit dokumenty pro odběr vzorků
DocType: Selling Settings,Close Opportunity After Days,Zavřete příležitost po dnech
DocType: Item Customer Detail,Ref Code,Ref Code
DocType: Employee,Widowed,Ovdovělý
DocType: Tally Migration,ERPNext Company,ERPNext Společnost
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,"Chcete-li použít standardní formát dodacího listu, ponechte prázdné"
DocType: Purchase Invoice Item,Accepted Qty,Přijaté množství
DocType: Pricing Rule,Apply Rule On Brand,Použít pravidlo na značce
DocType: Products Settings,Show Availability Status,Zobrazit stav dostupnosti
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Úspěch importu
DocType: Agriculture Analysis Criteria,Soil Texture,Textura půdy
DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
DocType: Customer Feedback Table,Qualitative Feedback,Kvalitativní zpětná vazba
DocType: Service Level,Response and Resoution Time,Reakce a doba resolace
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Platnost vyprší
DocType: Supplier Scorecard,Scorecard Actions,Akce karty hodnocení
DocType: Account,Stock Adjustment,Úprava zásob
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Zdravotní péče
DocType: Restaurant Table,No of Seats,Počet sedadel
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Smažte všechny transakce pro tuto společnost
,Lead Details,Detaily olova
DocType: Service Level Agreement,Default Service Level Agreement,Výchozí dohoda o úrovni služeb
apps/erpnext/erpnext/portal/doctype/products_settings/products_settings.py,"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Filtrovat pole Řádek # {0}: Název pole <b>{1}</b> musí být typu &quot;Link&quot; nebo &quot;Tabulka MultiSelect&quot;
DocType: Lead,Suggestions,Návrhy
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get from,Dostat se z
DocType: Tax Rule,Tax Rule,Daňové pravidlo
DocType: Payment Entry,Payment Order Status,Stav platebního příkazu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,duplicitní záznam
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Příklad: Masters in Computer Science
DocType: Purchase Invoice Item,Purchase Invoice Item,Položka nákupní faktury
DocType: Certified Consultant,Non Profit Manager,Správce neziskových organizací
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,For Warehouse is required before Submit,Pro sklad je vyžadován před odesláním
DocType: Authorization Rule,Applicable To (User),Platné pro (uživatel)
DocType: Appraisal Goal,Appraisal Goal,Posouzení Cíl
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozornit na nové objednávky
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Zobrazit graf účtů
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,Citáty:
DocType: Opportunity,To Discuss,Probrat
DocType: Quality Inspection Reading,Reading 9,Čtení 9
DocType: Authorization Rule,Applicable To (Role),Použitelné pro (role)
DocType: Quotation Item,Additional Notes,Další poznámky
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} nemůže být negativní
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Vytvořit nákupní objednávky
DocType: Staffing Plan Detail,Estimated Cost Per Position,Odhadovaná cena za pozici
DocType: Loan Type,Loan Name,Název úvěru
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Nastavit výchozí režim platby
DocType: Quality Goal,Revision,Revize
DocType: Healthcare Service Unit,Service Unit Type,Typ servisní jednotky
DocType: Purchase Invoice,Return Against Purchase Invoice,Return Against Purchase Invoice
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Generovat tajemství
DocType: Loyalty Program Collection,Loyalty Program Collection,Sbírka věrnostního programu
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Pošlete hromadné SMS svým kontaktům
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Vytvořit plán poplatků
DocType: Rename Tool,File to Rename,Soubor přejmenovat
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Časovač překročil stanovené hodiny.
DocType: Shopify Tax Account,ERPNext Account,ERPDalší účet
DocType: Item Supplier,Item Supplier,Položka Dodavatel
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Ceník {0} je zakázán nebo neexistuje
DocType: Sales Invoice Item,Deferred Revenue Account,Účet odložených výnosů
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Půdní kompozice nepřidávají až 100%
DocType: Salary Slip,Salary Slip Timesheet,Rozvrh časového rozvrhu
DocType: Budget,Warn,Varovat
DocType: Grant Application,Email Notification Sent,Odeslání e-mailového oznámení
DocType: Work Order,Planned End Date,Datum ukončení plánu
DocType: QuickBooks Migrator,Quickbooks Company ID,ID společnosti Quickbooks
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Sklad nelze změnit pro sériové číslo
DocType: Loan Type,Rate of Interest (%) Yearly,Úroková míra (%) Ročně
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Náklady na vyřazený majetek
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Nastavte adresu ve společnosti &#39;% s&#39;
DocType: Patient Encounter,Encounter Date,Datum setkání
DocType: Shopify Settings,Webhooks,Webhookové
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Podrobnosti o typu Memebership
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Odolný
DocType: Hotel Room Package,Hotel Room Package,Balíček hotelových pokojů
DocType: Sales Team,Contribution to Net Total,Příspěvek k čistému součtu
DocType: Customer,"Reselect, if the chosen contact is edited after save","Znovu vyberte, pokud je vybraný kontakt upraven po uložení"
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Podkategorie pro osvobození zaměstnanců od daně
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Řádek {0} # Zaplacená částka nesmí být vyšší než požadovaná částka předem
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Tato hodnota se používá pro výpočet pro-rata temporis
DocType: Company,Change Abbreviation,Změnit zkratku
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Celkové náklady na spotřebovaný materiál (prostřednictvím položky skladu)
DocType: Purchase Invoice,Raw Materials Supplied,Dodávané suroviny
DocType: Salary Detail,Condition and Formula Help,Nápověda a nápověda
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Zůstatek ({0})
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,ID studenta:
DocType: Leave Control Panel,New Leaves Allocated (In Days),Přidělené nové listy (ve dnech)
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Datetime
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Laboratorní výsledek datetime nemůže být před testováním datetime
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,"Zadejte název společnosti, který chcete potvrdit"
DocType: Subscription,Subscription Period,Období předplatného
DocType: Cash Flow Mapper,Position,Pozice
DocType: Student,Sibling Details,Podrobnosti o sourozenci
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Je úprava finančních nákladů
DocType: Patient Encounter,Encounter Impression,Encounter Impression
DocType: Contract,N/A,N / A
DocType: Lab Test,Lab Technician,Laboratorní technik
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, vyberte jednu z jejích variant"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,Jak se používá pravidlo pro stanovení cen?
DocType: Email Digest,Email Digest Settings,Nastavení Digestu e-mailu
DocType: Journal Entry,Inter Company Journal Entry,Vstup do společnosti Inter Journal
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Vytvořit doručení cesty
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Sériové číslo {1} neodpovídá {2} {3}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Požadavek na objednávku pro položku {0}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Získat podrobnosti z prohlášení
,Support Hour Distribution,Distribuce hodin podpory
DocType: Company,Allow Account Creation Against Child Company,Povolit vytvoření účtu proti dětské společnosti
DocType: Payment Entry,Company Bank Account,Firemní bankovní účet
DocType: Amazon MWS Settings,UK,Spojené království
DocType: Normal Test Items,Normal Test Items,Normální položky testu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být menší než minimální objednávka {2} (definovaná v položce).
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Není skladem
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Vozík
DocType: Course Activity,Course Activity,Kurz Činnost
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Děkuji za Váš obchod!
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Proti vstupu do deníku {0} je již upraveno proti nějakému jinému poukazu
DocType: Journal Entry,Bill Date,Bill Date
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Zadejte prosím Zapsat účet
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Biotechnologie
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Nastavte svůj institut v ERPNext
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Položka {0} neexistuje
DocType: Asset Maintenance Log,Asset Maintenance Log,Protokol údržby majetku
DocType: Accounts Settings,Settings for Accounts,Nastavení účtů
DocType: Bank Guarantee,Reference Document Name,Odkaz Název dokumentu
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Pokud je prázdný, bude uvažován nadřazený účet skladu nebo společnost"
DocType: BOM,Rate Of Materials Based On,Míra Materiálů Na
DocType: Water Analysis,Container,Kontejner
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Dostupné sloty
DocType: Quiz,Max Attempts,Max pokusy
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Přehled o peněžních tocích
DocType: Loyalty Point Entry,Redeem Against,Uplatnit proti
DocType: Sales Invoice,Offline POS Name,Offline POS Name
DocType: Crop Cycle,ISO 8601 standard,Norma ISO 8601
DocType: Purchase Taxes and Charges,Deduct,Odečíst
DocType: C-Form Invoice Detail,C-Form Invoice Detail,Detail faktury C formuláře
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Změna stavu zásob
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Odpisy Částka za období
DocType: Shopify Settings,App Type,Typ aplikace
DocType: Lead,Blog Subscriber,Odběratel blogu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Chyba]
DocType: Restaurant,Active Menu,Aktivní nabídka
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Transakce proti společnosti již existují!
DocType: Customer,Sales Partner and Commission,Prodejní partner a Komise
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Cíle nemohou být prázdné
DocType: Work Order,Warehouses,Sklady
DocType: Crop Cycle,Detected Diseases,Zjištěné nemoci
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Před odesláním zadejte číslo bankovní záruky.
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Zpracování položek a UOM
DocType: Payment Request,Is a Subscription,Je předplatné
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Stáhnout jako Json
,Appointment Analytics,Jmenování Analytics
DocType: Quality Inspection,Inspection Type,Typ kontroly
DocType: Sales Invoice,Sales Taxes and Charges,Prodejní daně a poplatky
DocType: Employee,Health Insurance Provider,Poskytovatel zdravotního pojištění
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,Toto je skupina kořenových položek a nelze ji upravovat.
DocType: Production Plan,Projected Qty Formula,Promítaný vzorec množství
DocType: Payment Order,Payment Order Reference,Reference platebního příkazu
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Typ stromu
DocType: Activity Type,Default Costing Rate,Výchozí míra kalkulace
DocType: Vital Signs,Constipated,Zácpa
DocType: Salary Detail,Default Amount,Výchozí částka
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Seznam rozpočtu
DocType: Job Offer,Awaiting Response,Čeká na odpověď
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Vytvoření varianty bylo ve frontě.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","Částka {0}, která již byla pro komponentu {1} nárokována, nastaví hodnotu rovnou nebo vyšší než {2}"
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,Přidejte prosím zbývající výhody {0} na některou z existujících komponent
DocType: Vehicle Log,Odometer,Počítadlo kilometrů
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Měna transakce musí být stejná jako měna platební brány
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number",U položky {0} musí být množství záporné číslo
DocType: Additional Salary,Payroll Date,Datum výplaty mzdy
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Způsob platby je vyžadován pro provedení platby
DocType: BOM,Materials,Materiály
DocType: Delivery Note Item,Against Sales Order,Proti zakázce odběratele
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Delivery Note Item,Against Sales Order Item,Proti položce zakázky odběratele
DocType: Appraisal,Goals,Cíle
DocType: Employee,ERPNext User,ERPNext Uživatel
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Dostupné listy
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Kořenový účet musí být skupinou
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,E-mailové připomínky budou zaslány všem stranám s e-mailovými kontakty
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Vyberte typ ...
DocType: Workstation Working Hour,Workstation Working Hour,Pracovní doba pracovní stanice
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analytics
DocType: Maintenance Team Member,Maintenance Role,Údržba Role
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Šablona Smluvních podmínek
DocType: Fee Schedule Program,Fee Schedule Program,Program poplatků
DocType: Project Task,Make Timesheet,Vytvořit časový rozvrh
DocType: Production Plan Item,Production Plan Item,Položka plánu výroby
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Celkový počet studentů
DocType: Packing Slip,From Package No.,Z balíčku č.
DocType: Accounts Settings,Shipping Address,doručovací adresa
DocType: Vehicle Service,Clutch Plate,Deska spojky
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},Řádek # {0}: Hodnota {1} není propojena s položkou {2}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Skladová položka {0} vytvořena
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Datum objednávky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Měny společnosti obou společností by měly odpovídat transakcím mezi společnostmi.
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Kratší množství
DocType: Employee Attendance Tool,Marked Attendance,Označená účast
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Systém oznámí zvýšení nebo snížení množství nebo množství
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,Kosmetika
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte toto, pokud chcete, aby uživatel před uložením vybral řadu. Pokud toto zkontrolujete, nebude žádná výchozí hodnota."
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí mohou nastavit zmrazené účty a vytvářet / upravovat účetní položky proti zmrazeným účtům
DocType: Expense Claim,Total Claimed Amount,Celková částka nárokované částky
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový slot v následujících {0} dnech pro operaci {1}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Balení
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Obnovit lze pouze v případě, že vaše členství vyprší do 30 dnů"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Hodnota musí být mezi {0} a {1}
DocType: Quality Feedback,Parameters,Parametry
,Sales Partner Transaction Summary,Shrnutí transakce obchodního partnera
DocType: Asset Maintenance,Maintenance Manager Name,Název správce údržby
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,Je nutné načíst podrobnosti položky.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,To je založeno na pohybu zásob. Podrobnosti viz {0}
DocType: Clinical Procedure,Appointment,Jmenování
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Nejprve zadejte {0}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Surovina nemůže být stejná jako hlavní položka
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,V nastavení GST mohou být vybrány následující účty:
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,V tomto poli můžete použít libovolné platné označení Bootstrap 4. Zobrazí se na stránce Položka.
DocType: Serial No,Incoming Rate,Příchozí sazba
DocType: Cashier Closing,POS-CLO-,POS-CLO-
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Účet Pohledávky Diskontovaný účet
DocType: Tally Migration,Tally Debtors Account,Účet dlužníků
DocType: Grant Application,Has any past Grant Record,Má nějaké minulé Grant Record
DocType: POS Closing Voucher,Amount in Custody,Částka ve vazbě
DocType: Drug Prescription,Interval,Interval
DocType: Warehouse,Parent Warehouse,Rodičovský sklad
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Generované automatické požadavky na materiál
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Řádek {0}: Kontrola kvality odmítnuta pro položku {1}
DocType: Vehicle,Additional Details,další detaily
DocType: Sales Partner Type,Sales Partner Type,Typ obchodního partnera
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Vyberte rozpisku, počet a sklad"
DocType: Asset Maintenance Log,Maintenance Type,Typ údržby
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Toto pole slouží k vykreslení vlastního HTML kódu v sekci.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Jmenování bylo zrušeno, zkontrolujte a zrušte fakturu {0}"
DocType: Sales Invoice,Time Sheet List,Seznam časového rozvrhu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} proti Bill {1} datováno {2}
DocType: Shopify Settings,For Company,Pro společnost
DocType: Linked Soil Analysis,Linked Soil Analysis,Analýza propojené půdy
DocType: Project,Day to Send,Den odeslání
DocType: Salary Component,Is Tax Applicable,Je použitelná daň
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Číslo objednávky požadované pro položku {0}
DocType: Item Tax Template,Tax Rates,Daňová sazba
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Výsledky nápovědy pro
DocType: Student Admission,Student Admission,Vstupné pro studenty
DocType: Designation Skill,Skill,Dovednost
DocType: Budget Account,Budget Account,Účet rozpočtu
DocType: Employee Transfer,Create New Employee Id,Vytvořit nové Id zaměstnance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Profit and Loss' account {1}.,{0} je vyžadováno pro účet &#39;Zisk a ztráta&#39; {1}.
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Daň z zboží a služeb (GST Indie)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Vytváření výplatních pásů ...
DocType: Employee Skill,Employee Skill,Zaměstnanecká dovednost
DocType: Pricing Rule,Apply Rule On Item Code,Použít kód pravidla
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},"&#39;Aktualizovat zásoby&#39; nelze zkontrolovat, protože položky nejsou dodány prostřednictvím služby {0}"
DocType: Journal Entry,Stock Entry,Skladová položka
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Nájemné placené dny se překrývá s {0}
DocType: Employee,Current Address Is,Aktuální adresa je
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,Analytik
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,V tabulce plateb nebyly nalezeny žádné záznamy
DocType: Email Digest,Sales Orders to Deliver,Objednávky odběratele k dodání
DocType: Item,Units of Measure,Jednotky měření
DocType: Leave Block List,Block Days,Blokové dny
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Množství nesmí být větší než {0}
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Přidat položky
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Přidané daně a poplatky (měna společnosti)
DocType: Accounts Settings,Currency Exchange Settings,Nastavení směny měn
DocType: Taxable Salary Slab,From Amount,Od částky
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Sklad je povinný
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Přidat studenty
DocType: Payment Entry,Account Paid From,Účet placený od
DocType: Employee Attendance Tool,Marked Attendance HTML,Označené HTML docházky
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Položka {0} byla zakázána
DocType: Cheque Print Template,Amount In Figure,Částka na obrázku
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Nelze vytvořit více položky {0} než množství prodejní objednávky {1}
DocType: Purchase Invoice,Return,Vrátit se
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Tisk IRS 1099 formulářů
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,„Prodej aktualizací“ nelze kontrolovat pro prodej dlouhodobého majetku
DocType: Asset,Depreciation Schedule,Odpisový plán
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Pravidlo přepravy neplatí pro zemi {0}
DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy byly materiály obdrženy"
DocType: Tax Rule,Billing Country,Fakturační země
DocType: Journal Entry Account,Sales Order,Objednávka odběratele
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Chybí hodnota
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,Obchody
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Nový zůstatek v základní měně
DocType: POS Profile,Price List,Ceník
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Neplatné {0}: {1}
DocType: Article,Article,Článek
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,"Název institutu, pro který tento systém nastavujete."
apps/erpnext/erpnext/utilities/user_progress.py,A Product,Produkt
DocType: Crop,Crop Name,Název oříznutí
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,Vyžaduje se „From Date“
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Vyberte kusovník
DocType: Travel Itinerary,Travel Itinerary,Cestovní itinerář
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Připomenutí narozenin
apps/erpnext/erpnext/utilities/user_progress.py,Pair,Pár
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Položka Cena přidána pro {0} v ceníku {1}
DocType: Pricing Rule,Validate Applied Rule,Ověřit platné pravidlo
DocType: Job Card Item,Job Card Item,Položka pracovní karty
DocType: Homepage,Company Tagline for website homepage,Společnost Tagline pro domovskou stránku webu
DocType: Company,Round Off Cost Center,Nákladové středisko
DocType: Supplier Scorecard Criteria,Criteria Weight,Kritéria Hmotnost
DocType: Asset,Depreciation Schedules,Odpisy
DocType: Expense Claim Detail,Claim Amount,Částka nároku
DocType: Subscription,Discounts,Slevy
DocType: Shipping Rule,Shipping Rule Conditions,Podmínky přepravního pravidla
DocType: Subscription,Cancelation Date,Datum zrušení
DocType: Payment Entry,Party Bank Account,Bankovní účet strany
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Název nového nákladového střediska
DocType: Promotional Scheme Price Discount,Max Amount,Max
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby přesměrujte uživatele na vybranou stránku.
DocType: Salary Slip,Total Loan Repayment,Celková splátka úvěru
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Do fiskálního roku
DocType: Delivery Note,Return Against Delivery Note,Return Against Delivery Note
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Chcete-li zobrazit další možnosti, jako jsou například aktiva, sériová čísla, dávky atd., Upravte celou stránku."
DocType: Payment Entry,Allocate Payment Amount,Přidělit částku platby
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Řádek # {0}: Vrácená položka {1} neexistuje v {2} {3}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Zapsat studenty
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Umožnit uživateli upravovat sazbu ceníku v transakcích
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Nejprve vyberte typ dokumentu
DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervace hotelových pokojů
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Výzkumník
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} je zmrazené
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Kód položky nelze změnit pro sériové číslo
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkové daně a poplatky (měna společnosti)
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Konflikty daňových pravidel s {0}
DocType: Fiscal Year,Year End Date,Datum konce roku
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Vytvořit potenciální zákazníky
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Zobrazit nulové hodnoty
DocType: Employee Onboarding,Employee Onboarding,Zaměstnanec Onboarding
DocType: POS Closing Voucher,Period End Date,Datum ukončení období
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Opportunities by Source,Prodejní příležitosti podle zdroje
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,První Nechat schvalovatele v seznamu bude nastaven jako výchozí Leave Approver.
DocType: POS Settings,POS Settings,Nastavení POS
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Všechny účty
DocType: Hotel Room,Hotel Manager,Hotelový manažer
DocType: Opportunity,With Items,S položkami
DocType: GL Entry,Is Advance,Je Advance
DocType: Membership,Membership Status,Stav členství
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Prodejní kampaně.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM not found for Item {0} and Project {1},Výchozí kusovník nebyl nalezen pro položku {0} a Project {1}
DocType: Leave Type,Encashment Threshold Days,Dny prahu spalování
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Položky Filtrovat
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je pozastaveno do {1}
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktura odděleně jako Spotřební materiál
DocType: Subscription,Days Until Due,Dny do konce
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Zobrazit dokončeno
apps/erpnext/erpnext/config/accounting.py,Bank Statement Transaction Entry Report,Zpráva o vstupu transakce do výpisu z účtu
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Deatils,Bank Deatils
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Řádek # {0}: Rychlost musí být stejná jako {1}: {2} ({3} / {4})
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Healthcare Settings,Healthcare Service Items,Položky zdravotnické služby
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,No records found,Nenalezeny žádné záznamy
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Rozsah stárnutí 3
DocType: Vital Signs,Blood Pressure,Krevní tlak
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Cíl Zapnuto
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Všechny jednotky zdravotnické služby
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Povinné pole - Program
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Časovač
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavit {0} v kategorii aktiv {1} nebo společnosti {2}
DocType: Bank Statement Settings Item,Bank Header,Záhlaví banky
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,Není způsobilý pro přijetí v tomto programu podle DOB
DocType: Assessment Criteria,Assessment Criteria Group,Skupina Kritéria hodnocení
DocType: Options,Is Correct,Je správně
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Department,Parent Department,Rodičovské oddělení
DocType: Employee Internal Work History,Employee Internal Work History,Historie interní práce zaměstnance
DocType: Supplier,Warn POs,Varujte PO
DocType: Employee,Offer Date,Datum nabídky
DocType: Sales Invoice,Product Bundle Help,Produkt Bundle Help
DocType: Stock Reconciliation,Stock Reconciliation,Sladění zásob
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Účetní zápis pro akcie
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment overlaps with {0}.<br> {1} has appointment scheduled
			with {2} at {3} having {4} minute(s) duration.",Jmenování se překrývá s {0}. <br> {1} má naplánovanou schůzku s {2} na {3} s {4} minutami.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Sklady s podřízenými uzly nelze převést na účet
DocType: Project,Projects Manager,Správce projektů
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Koncový čas nemůže být před zahájením
DocType: UOM,UOM Name,Jméno UOM
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Hodiny
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Částka {0} {1} {2} {3}
,Supplier Ledger Summary,Přehled dodavatele
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,ID studentského e-mailu
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandát
DocType: Bank Account,IBAN,IBAN
DocType: Restaurant Reservation,No of People,Počet lidí
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Od data a do data leží v jiném fiskálním roce
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Pacient {0} nemá zákaznickou refrence k fakturaci
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Chyba syntaxe ve stavu: {0}
DocType: Payment Entry,Transaction ID,ID transakce
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Zadejte zprávu před odesláním
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Ref Datum
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Toto nákladové středisko je skupina. Nelze provést účtování proti skupinám.
DocType: Soil Analysis,Soil Analysis Criterias,Kritéria analýzy půdy
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Balení Slipy byly zrušeny
DocType: Company,Existing Company,Stávající společnost
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Dávky
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Obrana
DocType: Item,Has Batch No,Má dávku č
DocType: Lead,Person Name,Jméno osoby
DocType: Item Variant,Item Variant,Varianta položky
DocType: Training Event Employee,Invited,Pozván
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maximální částka způsobilá pro komponentu {0} přesahuje hodnotu {1}
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Částka pro účet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry",V případě {0} lze propojit pouze jiné debetní účty s jinou kreditní položkou
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Vytváření kót ...
DocType: Bank Statement Transaction Entry,Payable Account,Platební účet
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Neuvádějte žádné požadované návštěvy
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,"Vyberte pouze v případě, že máte nastaveny dokumenty mapovače peněžních toků"
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je svátek firmy
DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším vážením budou zobrazeny výše
DocType: Project,Project will be accessible on the website to these users,Projekt bude těmto uživatelům zpřístupněn na webových stránkách
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Tabulka atributů je povinná
DocType: Salary Slip,Total Working Hours,Celková pracovní doba
DocType: Crop,Planting UOM,Výsadba UOM
DocType: Inpatient Record,O Negative,O Negativní
DocType: Purchase Order,To Receive and Bill,Přijmout a Bill
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Počáteční a koncová data nejsou v platném Období mezd, nelze vypočítat {0}."
DocType: POS Profile,Only show Customer of these Customer Groups,Zákazníkům zobrazujte pouze tyto Zákaznické skupiny
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,Vyberte položky pro uložení faktury
DocType: Service Level,Resolution Time,Čas rozlišení
DocType: Grading Scale Interval,Grade Description,Popis třídy
DocType: Homepage Section,Cards,Karty
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Zápis o kvalitě jednání
DocType: Linked Plant Analysis,Linked Plant Analysis,Analýza propojených rostlin
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Datum ukončení služby nemůže být po datu ukončení služby
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Nastavte prosím B2C Limit v nastavení GST.
DocType: Member,Member Name,Jméno člena
DocType: Account,Payable,Splatné
DocType: Job Card,For Quantity,Pro Množství
DocType: Territory,For reference,Pro referenci
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Přidat do košíku
DocType: Global Defaults,Global Defaults,Globální výchozí hodnoty
DocType: Leave Application,Follow via Email,Sledujte e-mailem
DocType: Leave Allocation,Total Leaves Allocated,Celkem přidělené listy
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Surovina
DocType: Manufacturer,Limited to 12 characters,Omezeno na 12 znaků
DocType: Selling Settings,Customer Naming By,Zákaznické pojmenování
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Balené množství musí odpovídat množství pro položku {0} v řádku {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Jméno nového prodejce
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon bude synchronizovat data aktualizovaná po tomto datu
DocType: Service Day,Service Day,Den služby
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Odpočítané daně a poplatky (měna společnosti)
DocType: Project,Gross Margin %,Hrubá marže%
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Stav bankovního výpisu podle hlavní knihy
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Zdravotní péče (beta)
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Výchozí sklad pro vytvoření zakázky odběratele a dodacího listu
DocType: Opportunity,Customer / Lead Name,Jméno zákazníka
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Expense Claim Advance,Unclaimed amount,Nežádaná částka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Zdrojový a cílový sklad nemůže být stejný pro řádek {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Řádek odpisů {0}: Očekávaná hodnota po době použitelnosti musí být větší nebo rovna {1}
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Vyberte datum
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,"Mzdová struktura by měla mít pružnou složku (složky) výhod, aby mohla být vyplácena částka dávky"
DocType: Employee Attendance Tool,Employee Attendance Tool,Nástroj docházky zaměstnanců
DocType: Employee,Educational Qualification,Vzdělávací kvalifikace
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Přístupná hodnota
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Množství vzorku {0} nemůže být větší než přijaté množství {1}
DocType: POS Profile,Taxes and Charges,Daně a poplatky
DocType: Opportunity,Contact Mobile No,Kontakt Mobilní č
DocType: Employee,Joining Details,Podrobnosti o připojení
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Spusťte úlohu
DocType: Quality Action Table,Quality Action Table,Tabulka kvality akce
DocType: Healthcare Practitioner,Phone (Office),Telefon (kancelář)
DocType: Timesheet Detail,Operation ID,ID operace
DocType: Soil Texture,Silt Loam,Silt Loam
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Nastavte prosím výchozí středisko nákladů ve společnosti {0}.
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Aktualizovat e-mailovou skupinu
DocType: Employee Promotion,Employee Promotion Detail,Detail propagace zaměstnanců
DocType: Loan Application,Repayment Info,Informace o splácení
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Zobrazit nezařazené zůstatky P&amp;L fiskálního roku
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} označuje, že {1} neposkytuje cenovou nabídku, ale všechny položky byly citovány. Aktualizace stavu nabídky RFQ."
DocType: Asset,Finance Books,Finance Knihy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}",Pokud je jako {0} vybráno {
DocType: Stock Settings,Role Allowed to edit frozen stock,Role Povoleno editovat zmrazené zásoby
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Datum posledního sdělení
DocType: Activity Cost,Costing Rate,Míra kalkulace
DocType: Shipping Rule,example: Next Day Shipping,Příklad: Odeslání následujícího dne
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Položky platebních faktur
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Úlohy byly vytvořeny pro správu onemocnění {0} (v řádku {1})
DocType: Healthcare Settings,Confirmation Message,Potvrzení zprávy
DocType: Lab Test UOM,Lab Test UOM,Laboratorní test UOM
DocType: Leave Type,Earned Leave Frequency,Frekvence vydělané dovolené
DocType: Loyalty Program,Loyalty Program Type,Typ věrnostního programu
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Poštovní adresa nemá zemi, která je vyžadována pro toto přepravní pravidlo"
DocType: POS Profile,Terms and Conditions,Pravidla a podmínky
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',Klikněte na odkaz Generovat plán
DocType: Sales Invoice,Total Qty,Celkový počet
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All other ITC,Všechny ostatní ITC
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Dovážející strany a adresy
DocType: Item,List this Item in multiple groups on the website.,Seznam této položky ve více skupinách na webu.
DocType: Request for Quotation,Message for Supplier,Zpráva pro dodavatele
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change {0} as Stock Transaction for Item {1} exist.,"{0} nelze změnit, protože existuje transakce pro položku {1}."
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
DocType: Maintenance Team Member,Team Member,Člen týmu
DocType: Asset Category Account,Asset Category Account,Účet kategorie aktiv
,Team Updates,Aktualizace týmu
DocType: Bank Account,Party,Večírek
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Purchase Invoice,Write Off Amount (Company Currency),Částka odepsaná (měna společnosti)
DocType: Stock Entry,Including items for sub assemblies,Včetně položek pro dílčí sestavy
DocType: Course Topic,Topic Name,Název tématu
DocType: Budget,Applicable on booking actual expenses,Platí pro rezervaci skutečných nákladů
DocType: Purchase Invoice,Start date of current invoice's period,Datum zahájení běžného období faktury
apps/erpnext/erpnext/utilities/user_progress.py,Litre,Litr
DocType: Marketplace Settings,Hub Seller Name,Jméno prodejce rozbočovače
DocType: Stock Entry,Total Outgoing Value,Celková odchozí hodnota
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Automaticky se aktualizuje dokument
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li zahrnout {2} do položky Item rate, musí být také zahrnuty řádky {3}"
apps/erpnext/erpnext/config/stock.py,Serial No and Batch,Sériové číslo a šarže
DocType: Contract,Fulfilment Deadline,Plnění Termín
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Vytvořit pracovní kartu
,Sales Person Commission Summary,Souhrnný přehled o prodejní osobě
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,"Cannot process route, since Google Maps Settings is disabled.","Trasu nelze zpracovat, protože nastavení Map Google je zakázáno."
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,Přejít na položky
DocType: Asset Value Adjustment,Current Asset Value,Aktuální hodnota aktiv
DocType: Support Search Source,Result Preview Field,Výsledek Náhled pole
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Zadejte sériová čísla pro serializovanou položku
DocType: GL Entry,Against Voucher Type,Proti typu poukázky
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Smluvní podmínky plnění smlouvy
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Přidělení listů ...
DocType: Student Applicant,Admitted,Připustil
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Získat aktualizace
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Černá
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Year start date or end date is overlapping with {0}. To avoid please set company,"Datum začátku nebo konce roku se překrývá s {0}. Chcete-li se vyhnout, nastavte společnost"
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Zobrazit zavřeno
DocType: Sample Collection,No. of print,Počet výtisků
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
